@browserstack/mcp-server 1.2.3 → 1.2.5

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

@@ -0,0 +1,194 @@
+// Node.js instructions and commands for App SDK utilities
+import { AppSDKSupportedTestingFrameworkEnum, createStep, combineInstructions, } from "../index.js";
+export function getNodejsSDKCommand(testingFramework, username, accessKey) {
+    switch (testingFramework) {
+        case "webdriverio":
+            return getWebDriverIOCommand(username, accessKey);
+        case "nightwatch":
+            return getNightwatchCommand(username, accessKey);
+        case "jest":
+            return getJestCommand(username, accessKey);
+        case "mocha":
+            return getMochaCommand(username, accessKey);
+        case "cucumberJs":
+            return getCucumberJSCommand(username, accessKey);
+        default:
+            return "";
+    }
+}
+export function getNodejsAppInstructions(testingFramework) {
+    switch (testingFramework) {
+        case AppSDKSupportedTestingFrameworkEnum.webdriverio:
+            return createStep("Run your WebdriverIO test suite:", "Your test suite is now ready to run on BrowserStack. Use the commands defined in your package.json file to run the tests");
+        case AppSDKSupportedTestingFrameworkEnum.nightwatch:
+            return createStep("Run your App Automate test suite:", `For Android:
+          \`\`\`bash
+            npx nightwatch <path to tests> --env browserstack.android 
+          \`\`\`
+          For iOS:
+          \`\`\`bash
+            npx nightwatch <path to tests> --env browserstack.ios
+          \`\`\``);
+        case AppSDKSupportedTestingFrameworkEnum.jest:
+            return createStep("Run your Jest test suite with BrowserStack SDK:", `Use the npm script defined in your package.json. For example:\n\n\`\`\`bash\nnpx run browserstack-node-sdk jest specs/single_test.js\n\`\`\``);
+        case AppSDKSupportedTestingFrameworkEnum.mocha:
+            return createStep("Run your Mocha test suite with BrowserStack SDK:", `Use the npm script defined in your package.json. For example:\n\n\`\`\`bash\nnpx run browserstack-node-sdk mocha specs/single_test.js\n\`\`\``);
+        case AppSDKSupportedTestingFrameworkEnum.cucumberJs:
+            return createStep("Run your Cucumber JS test suite with BrowserStack SDK:", `Use the npm script defined in your package.json. For example:\n\n\`\`\`bash\nnpx run browserstack-node-sdk cucumber-js specs/single_test.js\n\`\`\``);
+        default:
+            return "";
+    }
+}
+function getWebDriverIOCommand(username, accessKey) {
+    const prerequisiteStep = createStep("Prerequisite Setup:", `a. Ensure you do not modify or replace any existing local driver code, 
+    as it will be automatically managed and overwritten by the BrowserStack SDK/Driver.
+    b. Do not create any YML file in this integration as it is not required.
+    c. Ensure you create the WDIO config file as per the instructions below.`);
+    const envStep = createStep("Set your BrowserStack credentials as environment variables:", `\`\`\`bash
+export BROWSERSTACK_USERNAME=${username}
+export BROWSERSTACK_ACCESS_KEY=${accessKey}
+\`\`\``);
+    const installStep = createStep("Install BrowserStack WDIO service:", `\`\`\`bash
+npm install @wdio/browserstack-service@^7 --save-dev
+\`\`\``);
+    const configStep = createStep("Update your WebdriverIO config file (e.g., \\`wdio.conf.js\\`) to add the BrowserStack service and capabilities:", `\`\`\`js
+exports.config = {
+  user: process.env.BROWSERSTACK_USERNAME || '${username}',
+  key: process.env.BROWSERSTACK_ACCESS_KEY || '${accessKey}',
+  hostname: 'hub.browserstack.com',
+  services: [
+    [
+      'browserstack',
+      {
+        app: 'bs://sample.app',
+        browserstackLocal: true,
+        accessibility: false,
+        testObservabilityOptions: {
+          buildName: "bstack-demo",
+          projectName: "BrowserStack Sample",
+          buildTag: 'Any build tag goes here. For e.g. ["Tag1","Tag2"]'
+        },
+      },
+    ]
+  ],
+  capabilities: [{
+    'bstack:options': {
+      deviceName: 'Samsung Galaxy S22 Ultra',
+      platformVersion: '12.0',
+      platformName: 'android',
+    }
+  }],
+  commonCapabilities: {
+    'bstack:options': {
+      debug: true,
+      networkLogs: true,
+      percy: false,
+      percyCaptureMode: 'auto'
+    }
+  },
+  maxInstances: 10,
+  // ...other config
+};
+\`\`\``);
+    return combineInstructions(prerequisiteStep, envStep, installStep, configStep);
+}
+function getNightwatchCommand(username, accessKey) {
+    const prerequisiteStep = createStep("Prerequisite Setup:", ` a. Ensure you do not modify or replace any existing local driver code, 
+      as it will be automatically managed and overwritten by the BrowserStack SDK/Driver.
+      b. Do not create any YML file in this integration as it is not required.
+      c. Ensure you create the WDIO config file as per the instructions below.`);
+    const envStep = createStep("Set your BrowserStack credentials as environment variables:", `\`\`\`bash 
+export BROWSERSTACK_USERNAME=${username}
+export BROWSERSTACK_ACCESS_KEY=${accessKey}
+\`\`\``);
+    const installStep = createStep("Install Nightwatch and BrowserStack integration:", `\`\`\`bash
+npm install --save-dev @nightwatch/browserstack
+\`\`\``);
+    const configStep = createStep("Update your Nightwatch config file (e.g., \\`nightwatch.conf.js\\`) to add the BrowserStack settings and capabilities:", `\`\`\`js
+
+    test_settings:{
+    ...
+    browserstack: {
+      selenium: {
+        host: 'hub.browserstack.com',
+        port: 443
+      },
+      desiredCapabilities: {
+       'bstack:options': {
+          userName: '',
+          accessKey: '',
+          appiumVersion: '2.0.0'
+        }
+      },
+      disable_error_log: false,
+      webdriver: {
+        timeout_options: {
+          timeout: 60000,
+          retry_attempts: 3
+        },
+        keep_alive: true,
+        start_process: false
+      }
+    },
+    'browserstack.android': {
+      extends: 'browserstack',
+      'desiredCapabilities': {
+        browserName: null,
+        'appium:options': {
+          automationName: 'UiAutomator2',
+          app: 'wikipedia-sample-app',// custom-id of the uploaded app
+          appPackage: 'org.wikipedia',
+          appActivity: 'org.wikipedia.main.MainActivity',
+          appWaitActivity: 'org.wikipedia.onboarding.InitialOnboardingActivity',
+          platformVersion: '11.0',
+          deviceName: 'Google Pixel 5'
+        },
+        appUploadUrl: 'https://raw.githubusercontent.com/priyansh3133/wikipedia/main/wikipedia.apk',// URL of the app to be uploaded to BrowserStack before starting the test
+        // appUploadPath: '/path/to/app_name.apk' // if the app needs to be uploaded to BrowserStack from a local system
+      }
+    },
+    'browserstack.ios': {
+      extends: 'browserstack',
+      'desiredCapabilities': {
+        browserName: null,
+        platformName: 'ios',
+        'appium:options': {
+          automationName: 'XCUITest',
+          app: 'BStackSampleApp',
+          platformVersion: '16',
+          deviceName: 'iPhone 14'
+        },
+        appUploadUrl: 'https://www.browserstack.com/app-automate/sample-apps/ios/BStackSampleApp.ipa',
+        // appUploadPath: '/path/to/app_name.ipa'
+      }
+    ...
+  }
+\`\`\``);
+    return combineInstructions(prerequisiteStep, envStep, installStep, configStep);
+}
+function getJestCommand(username, accessKey) {
+    const envStep = createStep("Set your BrowserStack credentials as environment variables:", `\`\`\`bash
+export BROWSERSTACK_USERNAME=${username}
+export BROWSERSTACK_ACCESS_KEY=${accessKey}
+\`\`\``);
+    const installStep = createStep("Install Jest and BrowserStack SDK:", `\`\`\`bash
+npm install --save-dev browserstack-node-sdk
+\`\`\``);
+    return combineInstructions(envStep, installStep);
+}
+function getMochaCommand(username, accessKey) {
+    const envStep = createStep("Set your BrowserStack credentials as environment variables:", `\`\`\`bash
+export BROWSERSTACK_USERNAME=${username}
+export BROWSERSTACK_ACCESS_KEY=${accessKey}
+\`\`\``);
+    const installStep = createStep("Install Mocha and BrowserStack SDK:", `\`\`\`bash
+npm install --save-dev browserstack-node-sdk
+\`\`\``);
+    return combineInstructions(envStep, installStep);
+}
+function getCucumberJSCommand(username, accessKey) {
+    return createStep("Set your BrowserStack credentials as environment variables:", `\`\`\`bash
+export BROWSERSTACK_USERNAME=${username}
+export BROWSERSTACK_ACCESS_KEY=${accessKey}
+\`\`\``);
+}

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

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

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

@@ -0,0 +1,76 @@
+// Python instructions and commands for App SDK utilities
+import { AppSDKSupportedTestingFrameworkEnum, createStep, createEnvStep, combineInstructions, PLATFORM_UTILS, } from "../index.js";
+export function getPythonAppInstructions(testingFramework) {
+    switch (testingFramework) {
+        case AppSDKSupportedTestingFrameworkEnum.robot:
+            return createStep("Run your App Automate test suite with Robot Framework:", `\`\`\`bash
+browserstack-sdk robot <path-to-test-files>
+\`\`\``);
+        case AppSDKSupportedTestingFrameworkEnum.pytest:
+            return createStep("Run your App Automate test suite with Pytest:", `\`\`\`bash
+browserstack-sdk pytest -s <file-name.py>
+\`\`\``);
+        case AppSDKSupportedTestingFrameworkEnum.behave:
+            return createStep("Run your App Automate test suite with Behave:", `\`\`\`bash
+browserstack-sdk behave <path-to-test-files>
+\`\`\``);
+        case AppSDKSupportedTestingFrameworkEnum.lettuce:
+            return createStep("Run your test with Lettuce:", `\`\`\`bash
+# Run using paver
+paver run first_test
+\`\`\``);
+        default:
+            return "";
+    }
+}
+export function getPythonSDKCommand(framework, username, accessKey) {
+    const { isWindows, getPlatformLabel } = PLATFORM_UTILS;
+    switch (framework) {
+        case "robot":
+        case "pytest":
+        case "behave":
+            return getPythonCommonSDKCommand(username, accessKey, isWindows, getPlatformLabel());
+        case "lettuce":
+            return getLettuceCommand(username, accessKey, isWindows, getPlatformLabel());
+        default:
+            return "";
+    }
+}
+function getPythonCommonSDKCommand(username, accessKey, isWindows, platformLabel) {
+    const envStep = createEnvStep(username, accessKey, isWindows, platformLabel, "Set your BrowserStack credentials as environment variables:");
+    const installStep = createStep("Install BrowserStack Python SDK:", `\`\`\`bash
+python3 -m pip install browserstack-sdk
+\`\`\``);
+    const setupStep = createStep("Set up BrowserStack SDK:", `\`\`\`bash
+browserstack-sdk setup --username "${username}" --key "${accessKey}"
+\`\`\``);
+    return combineInstructions(envStep, installStep, setupStep);
+}
+function getLettuceCommand(username, accessKey, isWindows, platformLabel) {
+    const envStep = createEnvStep(username, accessKey, isWindows, platformLabel, "Set your BrowserStack credentials as environment variables:");
+    const configStep = createStep("Configure Appium's desired capabilities in config.json:", `**Android example:**
+\`\`\`json
+{
+    "capabilities": {
+      "browserstack.user" : "${username}",
+      "browserstack.key" : "${accessKey}",
+      "project": "First Lettuce Android Project",
+      "build": "Lettuce Android",
+      "name": "first_test",
+      "browserstack.debug": true,
+      "app": "bs://<app-id>",
+      "device": "Google Pixel 3",
+      "os_version": "9.0"
+    }
+}
+\`\`\``);
+    const initStep = createStep("Initialize remote WebDriver in terrain.py:", `\`\`\`python
+# Initialize the remote Webdriver using BrowserStack remote URL
+# and desired capabilities defined above
+context.browser = webdriver.Remote(
+    desired_capabilities=desired_capabilities,
+    command_executor="https://hub-cloud.browserstack.com/wd/hub"
+)
+\`\`\``);
+    return combineInstructions(envStep, configStep, initStep);
+}

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

@@ -0,0 +1,2 @@
+export declare function getRubyAppInstructions(): string;
+export declare function getRubySDKCommand(framework: string, username: string, accessKey: string): string;

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

@@ -0,0 +1,85 @@
+// Ruby instructions and commands for App SDK utilities
+import { createStep, combineInstructions, createEnvStep, PLATFORM_UTILS, } from "../index.js";
+const username = "${process.env.BROWSERSTACK_USERNAME}";
+const accessKey = "${process.env.BROWSERSTACK_ACCESS_KEY}";
+export function getRubyAppInstructions() {
+    const configStep = createStep("Create/Update the config file (config.yml) as follows:", `\`\`\`yaml
+server: "hub-cloud.browserstack.com"
+
+common_caps:
+  "browserstack.user": "${username}"
+  "browserstack.key": "${accessKey}"
+  "project": "First Cucumber Android Project"
+  "build": "Cucumber Android"
+  "browserstack.debug": true
+
+browser_caps:
+  -
+    "deviceName": "Google Pixel 3"
+    "os_version": "9.0"
+    "app": "<replace with the APK path from the upload step>"
+    "name": "first_test"
+\`\`\``);
+    const envStep = createStep("Create/Update your support/env.rb file:", `\`\`\`ruby
+require 'rubygems'
+require 'appium_lib'
+
+# Load configuration from config.yml
+caps = Appium.load_appium_txt file: File.expand_path('./../config.yml', __FILE__)
+username = "${username}"
+password = "${accessKey}"
+
+# Create desired capabilities
+desired_caps = {
+  caps: caps,
+  appium_lib: {
+    server_url: "https://#{username}:#{password}@#{caps['server']}/wd/hub"
+  }
+}
+
+# Initialize Appium driver
+begin
+  $appium_driver = Appium::Driver.new(desired_caps, true)
+  $driver = $appium_driver.start_driver
+rescue Exception => e
+  puts e.message
+  Process.exit(0)
+end
+
+# Add cleanup hook
+at_exit do
+  $driver.quit if $driver
+end
+\`\`\``);
+    const runStep = createStep("Run the test:", `\`\`\`bash
+bundle exec cucumber
+\`\`\``);
+    return combineInstructions(configStep, envStep, runStep);
+}
+export function getRubySDKCommand(framework, username, accessKey) {
+    const { isWindows, getPlatformLabel } = PLATFORM_UTILS;
+    const envStep = createEnvStep(username, accessKey, isWindows, getPlatformLabel(), "Set your BrowserStack credentials as environment variables:");
+    const installStep = createStep("Install required Ruby gems:", `\`\`\`bash
+# Install Bundler if not already installed
+gem install bundler
+
+# Install Appium Ruby client library
+gem install appium_lib
+
+# Install Cucumber
+gem install cucumber
+\`\`\``);
+    const gemfileStep = createStep("Create a Gemfile for dependency management:", `\`\`\`ruby
+# Gemfile
+source 'https://rubygems.org'
+
+gem 'appium_lib'
+gem 'cucumber'
+\`\`\`
+
+Then run:
+\`\`\`bash
+bundle install
+\`\`\``);
+    return combineInstructions(envStep, installStep, gemfileStep);
+}

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

@@ -0,0 +1,58 @@
+export declare enum AppSDKSupportedLanguageEnum {
+    java = "java",
+    nodejs = "nodejs",
+    python = "python",
+    ruby = "ruby",
+    csharp = "csharp"
+}
+export type AppSDKSupportedLanguage = keyof typeof AppSDKSupportedLanguageEnum;
+export declare enum AppSDKSupportedFrameworkEnum {
+    appium = "appium"
+}
+export type AppSDKSupportedFramework = keyof typeof AppSDKSupportedFrameworkEnum;
+export declare enum AppSDKSupportedTestingFrameworkEnum {
+    testng = "testng",
+    junit5 = "junit5",
+    junit4 = "junit4",
+    selenide = "selenide",
+    jbehave = "jbehave",
+    serenity = "serenity",
+    cucumberTestng = "cucumberTestng",
+    cucumberJunit4 = "cucumberJunit4",
+    cucumberJunit5 = "cucumberJunit5",
+    webdriverio = "webdriverio",
+    nightwatch = "nightwatch",
+    jest = "jest",
+    mocha = "mocha",
+    cucumberJs = "cucumberJs",
+    robot = "robot",
+    pytest = "pytest",
+    behave = "behave",
+    lettuce = "lettuce",
+    rspec = "rspec",
+    cucumberRuby = "cucumberRuby",
+    nunit = "nunit",
+    mstest = "mstest",
+    xunit = "xunit",
+    specflow = "specflow",
+    reqnroll = "reqnroll"
+}
+export type AppSDKSupportedTestingFramework = keyof typeof AppSDKSupportedTestingFrameworkEnum;
+export declare enum AppSDKSupportedPlatformEnum {
+    android = "android",
+    ios = "ios"
+}
+export type AppSDKSupportedPlatform = keyof typeof AppSDKSupportedPlatformEnum;
+export interface AppSDKInstruction {
+    content: string;
+    type: "config" | "run" | "setup";
+}
+export declare const SUPPORTED_CONFIGURATIONS: {
+    appium: {
+        ruby: string[];
+        java: string[];
+        csharp: never[];
+        python: string[];
+        nodejs: string[];
+    };
+};

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

@@ -0,0 +1,63 @@
+// Shared types for App SDK utilities
+export var AppSDKSupportedLanguageEnum;
+(function (AppSDKSupportedLanguageEnum) {
+    AppSDKSupportedLanguageEnum["java"] = "java";
+    AppSDKSupportedLanguageEnum["nodejs"] = "nodejs";
+    AppSDKSupportedLanguageEnum["python"] = "python";
+    AppSDKSupportedLanguageEnum["ruby"] = "ruby";
+    AppSDKSupportedLanguageEnum["csharp"] = "csharp";
+})(AppSDKSupportedLanguageEnum || (AppSDKSupportedLanguageEnum = {}));
+export var AppSDKSupportedFrameworkEnum;
+(function (AppSDKSupportedFrameworkEnum) {
+    AppSDKSupportedFrameworkEnum["appium"] = "appium";
+})(AppSDKSupportedFrameworkEnum || (AppSDKSupportedFrameworkEnum = {}));
+export var AppSDKSupportedTestingFrameworkEnum;
+(function (AppSDKSupportedTestingFrameworkEnum) {
+    AppSDKSupportedTestingFrameworkEnum["testng"] = "testng";
+    AppSDKSupportedTestingFrameworkEnum["junit5"] = "junit5";
+    AppSDKSupportedTestingFrameworkEnum["junit4"] = "junit4";
+    AppSDKSupportedTestingFrameworkEnum["selenide"] = "selenide";
+    AppSDKSupportedTestingFrameworkEnum["jbehave"] = "jbehave";
+    AppSDKSupportedTestingFrameworkEnum["serenity"] = "serenity";
+    AppSDKSupportedTestingFrameworkEnum["cucumberTestng"] = "cucumberTestng";
+    AppSDKSupportedTestingFrameworkEnum["cucumberJunit4"] = "cucumberJunit4";
+    AppSDKSupportedTestingFrameworkEnum["cucumberJunit5"] = "cucumberJunit5";
+    AppSDKSupportedTestingFrameworkEnum["webdriverio"] = "webdriverio";
+    AppSDKSupportedTestingFrameworkEnum["nightwatch"] = "nightwatch";
+    AppSDKSupportedTestingFrameworkEnum["jest"] = "jest";
+    AppSDKSupportedTestingFrameworkEnum["mocha"] = "mocha";
+    AppSDKSupportedTestingFrameworkEnum["cucumberJs"] = "cucumberJs";
+    AppSDKSupportedTestingFrameworkEnum["robot"] = "robot";
+    AppSDKSupportedTestingFrameworkEnum["pytest"] = "pytest";
+    AppSDKSupportedTestingFrameworkEnum["behave"] = "behave";
+    AppSDKSupportedTestingFrameworkEnum["lettuce"] = "lettuce";
+    AppSDKSupportedTestingFrameworkEnum["rspec"] = "rspec";
+    AppSDKSupportedTestingFrameworkEnum["cucumberRuby"] = "cucumberRuby";
+    AppSDKSupportedTestingFrameworkEnum["nunit"] = "nunit";
+    AppSDKSupportedTestingFrameworkEnum["mstest"] = "mstest";
+    AppSDKSupportedTestingFrameworkEnum["xunit"] = "xunit";
+    AppSDKSupportedTestingFrameworkEnum["specflow"] = "specflow";
+    AppSDKSupportedTestingFrameworkEnum["reqnroll"] = "reqnroll";
+})(AppSDKSupportedTestingFrameworkEnum || (AppSDKSupportedTestingFrameworkEnum = {}));
+export var AppSDKSupportedPlatformEnum;
+(function (AppSDKSupportedPlatformEnum) {
+    AppSDKSupportedPlatformEnum["android"] = "android";
+    AppSDKSupportedPlatformEnum["ios"] = "ios";
+})(AppSDKSupportedPlatformEnum || (AppSDKSupportedPlatformEnum = {}));
+export const SUPPORTED_CONFIGURATIONS = {
+    appium: {
+        ruby: ["cucumberRuby"],
+        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/appium-sdk/utils.d.ts

@@ -0,0 +1,17 @@
+import { AppSDKSupportedTestingFramework } from "./index.js";
+import { SUPPORTED_CONFIGURATIONS } from "./types.js";
+export declare function isBrowserStackAppUrl(appPath: string): boolean;
+export declare function generateBuildName(baseName?: string): string;
+export declare function createError(message: string, context?: Record<string, any>): Error;
+export declare const PLATFORM_UTILS: {
+    isWindows: boolean;
+    isMac: boolean;
+    isAppleSilicon: boolean;
+    getPlatformLabel: () => "Windows" | "macOS";
+};
+export declare function getAppUploadInstruction(appPath: string, username: string, accessKey: string, detectedTestingFramework: AppSDKSupportedTestingFramework): Promise<string>;
+export type SupportedFramework = keyof typeof SUPPORTED_CONFIGURATIONS;
+type SupportedLanguage = keyof (typeof SUPPORTED_CONFIGURATIONS)[SupportedFramework];
+type SupportedTestingFramework = string;
+export declare function validateSupportforAppAutomate(framework: SupportedFramework, language: SupportedLanguage, testingFramework: SupportedTestingFramework): void;
+export {};

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

@@ -0,0 +1,64 @@
+import { uploadApp } from "../native-execution/appautomate.js";
+import { AppSDKSupportedTestingFrameworkEnum, createStep, } from "./index.js";
+import { SUPPORTED_CONFIGURATIONS } from "./types.js";
+export function isBrowserStackAppUrl(appPath) {
+    return appPath.startsWith("bs://");
+}
+export function generateBuildName(baseName = "app-automate") {
+    const timestamp = new Date().toISOString().slice(0, 19).replace(/[:-]/g, "");
+    return `${baseName}-${timestamp}`;
+}
+export function createError(message, context) {
+    const error = new Error(message);
+    if (context) {
+        error.context = context;
+    }
+    return error;
+}
+// Platform utilities for cross-platform support
+export const PLATFORM_UTILS = {
+    isWindows: process.platform === "win32",
+    isMac: process.platform === "darwin",
+    isAppleSilicon: process.platform === "darwin" && process.arch === "arm64",
+    getPlatformLabel: () => {
+        switch (process.platform) {
+            case "win32":
+                return "Windows";
+            case "darwin":
+                return "macOS";
+            default:
+                return "macOS";
+        }
+    },
+};
+export async function getAppUploadInstruction(appPath, username, accessKey, detectedTestingFramework) {
+    if (detectedTestingFramework ===
+        AppSDKSupportedTestingFrameworkEnum.nightwatch ||
+        detectedTestingFramework ===
+            AppSDKSupportedTestingFrameworkEnum.webdriverio ||
+        detectedTestingFramework ===
+            AppSDKSupportedTestingFrameworkEnum.cucumberRuby) {
+        const app_url = await uploadApp(appPath, username, accessKey);
+        if (app_url) {
+            return createStep("Updating app_path with app_url", `Replace the value of app_path in your configuration with: ${app_url}`);
+        }
+    }
+    return "";
+}
+export function validateSupportforAppAutomate(framework, language, testingFramework) {
+    const frameworks = Object.keys(SUPPORTED_CONFIGURATIONS);
+    if (!SUPPORTED_CONFIGURATIONS[framework]) {
+        throw new Error(`Unsupported framework '${framework}'. Supported frameworks: ${frameworks.join(", ")}`);
+    }
+    const languages = Object.keys(SUPPORTED_CONFIGURATIONS[framework]);
+    if (!SUPPORTED_CONFIGURATIONS[framework][language]) {
+        throw new Error(`Unsupported language '${language}' for framework '${framework}'. Supported languages: ${languages.join(", ")}`);
+    }
+    const testingFrameworks = SUPPORTED_CONFIGURATIONS[framework][language];
+    if (testingFrameworks.length === 0) {
+        throw new Error(`No testing frameworks are supported for language '${language}' and framework '${framework}'.`);
+    }
+    if (!testingFrameworks.includes(testingFramework)) {
+        throw new Error(`Unsupported testing framework '${testingFramework}' for language '${language}' and framework '${framework}'. Supported testing frameworks: ${testingFrameworks.join(", ")}`);
+    }
+}

package/dist/tools/appautomate-utils/{appautomate.d.ts → native-execution/appautomate.d.ts}

@@ -1,4 +1,4 @@
-import { BrowserStackConfig } from "../../lib/types.js";
+import { BrowserStackConfig } from "../../../lib/types.js";
 interface Device {
     device: string;
     display_name: string;

package/dist/tools/appautomate-utils/{appautomate.js → native-execution/appautomate.js}

@@ -1,7 +1,7 @@
 import fs from "fs";
 import FormData from "form-data";
-import { apiClient } from "../../lib/apiClient.js";
-import { customFuzzySearch } from "../../lib/fuzzy.js";
+import { apiClient } from "../../../lib/apiClient.js";
+import { customFuzzySearch } from "../../../lib/fuzzy.js";
 /**
  * Finds devices that exactly match the provided display name.
  * Uses fuzzy search first, and then filters for exact case-insensitive match.

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

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

@@ -0,0 +1,58 @@
+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
+        .string()
+        .describe("Path to your application file:\n" +
+        "If in development IDE directory:\n" +
+        "• For Android: 'gradle assembleDebug'\n" +
+        "• For iOS:\n" +
+        "  xcodebuild clean -scheme YOUR_SCHEME && \\\n" +
+        "  xcodebuild archive -scheme YOUR_SCHEME -configuration Release -archivePath build/app.xcarchive && \\\n" +
+        "  xcodebuild -exportArchive -archivePath build/app.xcarchive -exportPath build/ipa -exportOptionsPlist exportOptions.plist\n\n" +
+        "If in other directory, provide existing app path"),
+    testSuitePath: z
+        .string()
+        .describe("Path to your test suite file:\n" +
+        "If in development IDE directory:\n" +
+        "• For Android: 'gradle assembleAndroidTest'\n" +
+        "• For iOS:\n" +
+        "  xcodebuild test-without-building -scheme YOUR_SCHEME -destination 'generic/platform=iOS' && \\\n" +
+        "  cd ~/Library/Developer/Xcode/DerivedData/*/Build/Products/Debug-iphonesimulator/ && \\\n" +
+        "  zip -r Tests.zip *.xctestrun *-Runner.app\n\n" +
+        "If in other directory, provide existing test file path"),
+    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']]"),
+    project: z
+        .string()
+        .optional()
+        .default("BStack-AppAutomate-Suite")
+        .describe("Project name for organizing test runs on BrowserStack."),
+    detectedAutomationFramework: z
+        .nativeEnum(AppTestPlatform)
+        .describe("The automation framework used in the project, such as 'espresso' (Android) or 'xcuitest' (iOS)."),
+};