@loadmill/droid-cua 2.19.0 → 2.21.0

package/README.md

@@ -160,6 +160,24 @@ LAMBDATEST_USERNAME=... LAMBDATEST_ACCESS_KEY=... droid-cua \
   --app ./app/build/outputs/apk/debug/app-debug.apk \
   --instructions tests/login.dcua \
   --config ci/droid-cua.json
+
+# List AWS Device Farm remote-access devices
+AWS_DEVICE_FARM_ACCESS_KEY_ID=... \
+AWS_DEVICE_FARM_SECRET_ACCESS_KEY=... \
+AWS_DEVICE_FARM_PROJECT_ARN=... \
+droid-cua --device-source aws-device-farm --list-devices
+
+# Headless AWS Device Farm real-device run
+AWS_DEVICE_FARM_ACCESS_KEY_ID=... \
+AWS_DEVICE_FARM_SECRET_ACCESS_KEY=... \
+AWS_DEVICE_FARM_PROJECT_ARN=... \
+droid-cua \
+  --device-source aws-device-farm \
+  --platform android \
+  --device-name "Google Pixel 10 Pro" \
+  --os-version "16" \
+  --app ./app/build/outputs/apk/debug/app-debug.apk \
+  --instructions tests/login.dcua
 ```
 
 Example headless config:
@@ -194,6 +212,7 @@ Supported CLI options include:
 - `--device-name`
 - `--os-version`
 - `--app`
+- `--list-devices`
 - `--browser`
 - `--instructions`
 - `--config`
@@ -246,6 +265,20 @@ LambdaTest CLI runs:
 - The CLI uploads the app to LambdaTest for each run and closes the cloud session when the run finishes or fails.
 - Each CLI LambdaTest run gets a unique LambdaTest build name so repeated local runs are easy to distinguish in the LambdaTest UI.
 
+AWS Device Farm CLI runs:
+- Use `--device-source aws-device-farm` with `--platform`, `--device-name`, `--os-version`, `--app`, and `--instructions`.
+- Set `AWS_DEVICE_FARM_ACCESS_KEY_ID`, `AWS_DEVICE_FARM_SECRET_ACCESS_KEY`, and `AWS_DEVICE_FARM_PROJECT_ARN` in the environment (an IAM user with Device Farm access and the ARN of a Device Farm project in `us-west-2`).
+- `--device-source aws-device-farm --list-devices` prints the remote-access device catalog (name, platform, OS) so you can pick valid `--device-name`/`--os-version` values, then exits.
+- Android runs require an `.apk`; iOS runs require an `.ipa`. `.app` bundles are not supported.
+- Re-running with the same app binary skips the upload: uploads are cached by checksum and reused for up to 30 days (Device Farm's upload retention).
+- Device provisioning takes ~1 minute; the CLI shows live progress while it waits.
+- The session is stopped when the run finishes, fails, or is interrupted with Ctrl-C — billing stops as soon as the stop is requested, so the CLI does not wait for the session to fully wind down.
+
+AWS Device Farm in the desktop app:
+- Open **Integrations → AWS Device Farm** and enter an AWS Access Key ID + Secret Access Key. The keys are validated on connect, a `droid-cua` Device Farm project is created automatically (the IAM user needs the minimal Device Farm policy, including `ListProjects`/`CreateProject`), and the remote-access device catalog loads. Credentials are stored in plaintext `desktop-config.json`, the same as BrowserStack/LambdaTest.
+- On the Devices page, pick AWS Device Farm as the source, choose a device + an uploaded `.apk`/`.ipa`, and start a Design/Run session. Provisioning takes ~1 minute and live progress flows into the device log.
+- **Pause caveat:** a Device Farm session paused for more than 5 minutes may be ended by AWS and need reconnecting.
+
 Minimal GitHub Actions shape:
 ```yaml
 jobs:
@@ -273,6 +306,25 @@ jobs:
           LAMBDATEST_ACCESS_KEY: ${{ secrets.LAMBDATEST_ACCESS_KEY }}
 ```
 
+The same shape works for AWS Device Farm — swap the run step and env:
+```yaml
+      - run: |
+          droid-cua \
+            --device-source aws-device-farm \
+            --platform android \
+            --device-name "Google Pixel 10 Pro" \
+            --os-version "16" \
+            --app ./app/build/outputs/apk/debug/app-debug.apk \
+            --instructions tests/login.dcua \
+            --config ci/droid-cua.json \
+            --debug
+        env:
+          OPENAI_API_KEY: ${{ secrets.OPENAI_API_KEY }}
+          AWS_DEVICE_FARM_ACCESS_KEY_ID: ${{ secrets.AWS_DEVICE_FARM_ACCESS_KEY_ID }}
+          AWS_DEVICE_FARM_SECRET_ACCESS_KEY: ${{ secrets.AWS_DEVICE_FARM_SECRET_ACCESS_KEY }}
+          AWS_DEVICE_FARM_PROJECT_ARN: ${{ secrets.AWS_DEVICE_FARM_PROJECT_ARN }}
+```
+
 Example without a config file:
 ```sh
 droid-cua \

package/build/index.js

@@ -24,8 +24,11 @@ import { listHeadlessInstructionFiles, resolveHeadlessInstructionsTarget } from
 import { runHeadlessInstructionRuns } from "./src/cli/headless-runner.js";
 import { planScenarioRuns } from "./src/cli/scenario-planner.js";
 import { resolveLambdaTestCredentials, uploadLambdaTestCliApp } from "./src/cli/lambdatest-app-upload.js";
+import { resolveAwsDeviceFarmCredentials, uploadAwsDeviceFarmCliApp } from "./src/cli/aws-device-farm-app-upload.js";
+import { createStatusLine } from "./src/cli/cloud-status-line.js";
 import { createLoadmillApiClient } from "./src/integrations/loadmill/client.js";
 import { getCloudProviderAdapter } from "./src/device/cloud/registry.js";
+import { setCloudProgressListener } from "./src/device/cloud/progress.js";
 dotenv.config();
 const args = minimist(process.argv.slice(2));
 const targetConfig = resolveHeadlessTarget(args);
@@ -131,12 +134,27 @@ async function resolveLambdaTestDashboardUrl(credentials, sessionId, { attempts
     return null;
 }
 async function main() {
+    if (targetConfig.listDevices) {
+        const credentials = resolveAwsDeviceFarmCredentials(process.env);
+        const adapter = getCloudProviderAdapter("aws-device-farm");
+        const devices = await adapter.getAvailableDevices(credentials);
+        for (const device of devices) {
+            console.log(`${device.name} — ${device.platform} ${device.osVersion}`);
+        }
+        console.log(`\n${devices.length} remote-access devices available.`);
+        console.log(`Run with: --device-name "<name>" --os-version "<osVersion>"`);
+        process.exit(0);
+    }
     const isHeadlessInstructionsRun = Boolean(instructionsFile);
     const isBrowserTarget = targetConfig.target === "web";
     const isLambdaTestTarget = targetConfig.deviceSource === "lambdatest";
+    const isAwsDeviceFarmTarget = targetConfig.deviceSource === "aws-device-farm";
+    const isCloudTarget = isLambdaTestTarget || isAwsDeviceFarmTarget;
     let lambdaTestSessionConnected = false;
     let lambdaTestSessionUrl = null;
     let lambdaTestCredentials = null;
+    let awsSessionConnected = false;
+    let awsDeviceFarmStatusLine = null;
     const headlessDebug = createHeadlessDebugArtifacts({
         cwd: process.cwd(),
         enabled: isHeadlessInstructionsRun && debugMode
@@ -149,8 +167,8 @@ async function main() {
     if (isBrowserTarget && !isHeadlessInstructionsRun) {
         throw new Error("--target web is only supported with --instructions headless execution.");
     }
-    if (isLambdaTestTarget && !isHeadlessInstructionsRun) {
-        throw new Error("--device-source lambdatest is only supported with --instructions headless execution.");
+    if (isCloudTarget && !isHeadlessInstructionsRun) {
+        throw new Error(`--device-source ${targetConfig.deviceSource} is only supported with --instructions headless execution.`);
     }
     if (!isHeadlessInstructionsRun && args.scenario != null) {
         throw new Error("--scenario can only be used with --instructions headless execution.");
@@ -206,7 +224,7 @@ async function main() {
         }
     }
     // If no device specified, show interactive selection menu
-    if (!isBrowserTarget && !isLambdaTestTarget && !avdName && !platform) {
+    if (!isBrowserTarget && !isCloudTarget && !avdName && !platform) {
         const selection = await selectDevice();
         platform = selection.platform;
         avdName = selection.deviceName;
@@ -268,6 +286,85 @@ async function main() {
         console.log(`Using real resolution: ${deviceInfo.device_width}x${deviceInfo.device_height}`);
         console.log(`Model sees resolution: ${deviceInfo.scaled_width}x${deviceInfo.scaled_height}`);
     }
+    else if (isAwsDeviceFarmTarget) {
+        const awsCredentials = resolveAwsDeviceFarmCredentials(process.env);
+        awsDeviceFarmStatusLine = createStatusLine();
+        const statusLine = awsDeviceFarmStatusLine;
+        setCloudProgressListener((event) => statusLine.handleEvent(event));
+        console.log(`Uploading app to AWS Device Farm: ${path.resolve(targetConfig.appPath)}`);
+        statusLine.start("Uploading app to AWS Device Farm");
+        const upload = await uploadAwsDeviceFarmCliApp({
+            appPath: targetConfig.appPath,
+            platform: targetConfig.platform,
+            credentials: awsCredentials,
+        });
+        statusLine.stop();
+        console.log(`Uploaded app to AWS Device Farm: ${upload.appRef}`);
+        // A leaked metered session bills idle time until the provider's 5-minute
+        // timeout and holds one of the account's two concurrency slots. Register the
+        // Ctrl-C handler BEFORE provisioning so an interrupt during the ~1min
+        // PREPARING poll aborts the connect and lets AWS cleanup finish before exit.
+        const provisioningAbortController = new AbortController();
+        let awsSigintHandled = false;
+        let awsInterruptRequested = false;
+        process.once("SIGINT", async () => {
+            if (awsSigintHandled)
+                return;
+            awsSigintHandled = true;
+            awsInterruptRequested = true;
+            console.log("\nStopping AWS Device Farm session...");
+            provisioningAbortController.abort(new Error("Stopped by user"));
+            if (!awsSessionConnected) {
+                process.exitCode = 130;
+                return;
+            }
+            await disconnectDevice({ waitForCompletion: false });
+            process.exit(130);
+        });
+        try {
+            statusLine.start("Provisioning AWS Device Farm device");
+            targetId = await connectToDevice({
+                source: "aws-device-farm",
+                providerId: "aws-device-farm",
+                platform: targetConfig.platform,
+                deviceName: targetConfig.deviceName,
+                osVersion: targetConfig.osVersion,
+                appRef: upload.appRef,
+                credentials: awsCredentials,
+                sessionName: `droid-cua-cli-${new Date().toISOString()}`,
+                signal: provisioningAbortController.signal,
+            }, null, { log: (message) => statusLine.update(message) });
+            awsSessionConnected = true;
+            if (awsInterruptRequested) {
+                try {
+                    await disconnectDevice({ waitForCompletion: false });
+                }
+                finally {
+                    statusLine.stop();
+                    awsSessionConnected = false;
+                    process.exitCode = 130;
+                }
+                return;
+            }
+            deviceInfo = await getDeviceInfo(targetId);
+            statusLine.stop();
+        }
+        catch (error) {
+            statusLine.stop();
+            if (awsSessionConnected) {
+                await disconnectDevice({ waitForCompletion: false });
+                awsSessionConnected = false;
+            }
+            if (awsInterruptRequested) {
+                process.exitCode = 130;
+                return;
+            }
+            throw error;
+        }
+        console.log(`Connected to AWS Device Farm device "${targetConfig.deviceName}" (${targetId})`);
+        console.log(`Using real resolution: ${deviceInfo.device_width}x${deviceInfo.device_height}`);
+        console.log(`Model sees resolution: ${deviceInfo.scaled_width}x${deviceInfo.scaled_height}`);
+    }
     else {
         targetId = await connectToDevice(avdName, platform);
         deviceInfo = await getDeviceInfo(targetId);
@@ -334,7 +431,7 @@ async function main() {
                 recordScreenshots,
                 screenshotDir,
                 isBrowserTarget,
-                isLambdaTestTarget,
+                isCloudTarget,
                 report: reportConfig
             });
             exitCode = result.exitCode;
@@ -358,6 +455,14 @@ async function main() {
                     console.log(`LambdaTest session id: ${targetId}`);
                 }
             }
+            if (awsSessionConnected) {
+                console.log("Ending AWS Device Farm session...");
+                awsDeviceFarmStatusLine.start("Ending AWS Device Farm session");
+                await disconnectDevice({ waitForCompletion: false });
+                awsDeviceFarmStatusLine.stop();
+                awsSessionConnected = false;
+                console.log("AWS Device Farm session ended.");
+            }
         }
         if (exitCode !== null) {
             process.exit(exitCode);

package/build/src/browser/playwright/welcome-page.js

@@ -79,6 +79,25 @@ function buildWelcomePageHtml() {
 
       .subhead { margin-top: 22px; font-size: 18px; line-height: 1.65; }
 
+      .return-action {
+        margin-top: 30px;
+        display: inline-flex;
+        align-items: center;
+        justify-content: center;
+        min-height: 46px;
+        padding: 0 22px;
+        border-radius: 999px;
+        background: #0f172a;
+        color: #ffffff;
+        font-size: 15px;
+        font-weight: 700;
+        text-decoration: none;
+        box-shadow: 0 14px 30px rgba(15, 23, 42, 0.18);
+      }
+
+      .return-action:hover { background: #1e293b; }
+      .return-action:focus-visible { outline: 3px solid rgba(79, 70, 229, 0.34); outline-offset: 3px; }
+
       .divider {
         width: 48px;
         height: 2px;
@@ -121,6 +140,7 @@ function buildWelcomePageHtml() {
         </div>
         <h1>Test Browser Ready</h1>
         <p class="subhead">This is the browser the Loadmill Droid CUA agent will drive when you start a test.</p>
+        <a class="return-action" href="droid-cua://focus">Return to the Droid app</a>
         <div class="divider" role="presentation"></div>
         <p class="pointer">Switch back to Loadmill Droid CUA to design or run a test — you should keep this window in the background.</p>
         <p class="tip">

package/build/src/cli/aws-device-farm-app-upload.js

@@ -0,0 +1,76 @@
+import path from "path";
+import { stat } from "fs/promises";
+import { awsDeviceFarmAdapter } from "../device/cloud/aws-device-farm/adapter.js";
+import { resolveUploadedApp } from "../device/cloud/aws-device-farm/upload-cache.js";
+function trimNullableString(value) {
+    if (typeof value !== "string") {
+        return null;
+    }
+    const trimmed = value.trim();
+    return trimmed || null;
+}
+export function resolveAwsDeviceFarmCredentials(env = process.env) {
+    const username = trimNullableString(env.AWS_DEVICE_FARM_ACCESS_KEY_ID);
+    const accessKey = trimNullableString(env.AWS_DEVICE_FARM_SECRET_ACCESS_KEY);
+    const projectArn = trimNullableString(env.AWS_DEVICE_FARM_PROJECT_ARN);
+    if (!username || !accessKey || !projectArn) {
+        throw new Error("AWS_DEVICE_FARM_ACCESS_KEY_ID, AWS_DEVICE_FARM_SECRET_ACCESS_KEY and AWS_DEVICE_FARM_PROJECT_ARN are required for --device-source aws-device-farm.");
+    }
+    return {
+        username,
+        accessKey,
+        projectArn,
+    };
+}
+export function validateAwsDeviceFarmAppPath(appPath, platform) {
+    const normalizedPlatform = trimNullableString(platform)?.toLowerCase();
+    if (normalizedPlatform !== "android" && normalizedPlatform !== "ios") {
+        throw new Error("--platform must be one of: android, ios.");
+    }
+    const normalizedAppPath = trimNullableString(appPath);
+    if (!normalizedAppPath) {
+        throw new Error("--app is required with --device-source aws-device-farm.");
+    }
+    const resolvedPath = path.resolve(normalizedAppPath);
+    const extension = path.extname(resolvedPath).toLowerCase();
+    if (extension === ".app") {
+        throw new Error("AWS Device Farm real-device sessions require an .apk for Android or an .ipa for iOS. .app bundles are not supported.");
+    }
+    if (normalizedPlatform === "android" && extension !== ".apk") {
+        throw new Error("AWS Device Farm Android sessions require an .apk build.");
+    }
+    if (normalizedPlatform === "ios" && extension !== ".ipa") {
+        throw new Error("AWS Device Farm iOS sessions require an .ipa build.");
+    }
+    return resolvedPath;
+}
+export async function uploadAwsDeviceFarmCliApp({ appPath, platform, credentials, adapter = awsDeviceFarmAdapter, } = {}) {
+    const resolvedPath = validateAwsDeviceFarmAppPath(appPath, platform);
+    let fileStats;
+    try {
+        fileStats = await stat(resolvedPath);
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : "App file is unavailable.";
+        throw new Error(`App file is unavailable: ${message}`);
+    }
+    if (!fileStats.isFile()) {
+        throw new Error("Selected app path is not a file.");
+    }
+    // sha256+projectArn upload cache — re-runs of the same binary reuse the
+    // existing upload ARN instead of re-uploading (Device Farm has no
+    // server-side dedup; uploads age out after ~30 days).
+    const { app: uploadedRef } = await resolveUploadedApp({
+        adapter,
+        credentials,
+        appPath: resolvedPath,
+    });
+    if (!uploadedRef?.remotePath || typeof uploadedRef.remotePath !== "string") {
+        throw new Error("AWS Device Farm did not return a valid app reference.");
+    }
+    return {
+        appRef: uploadedRef.remotePath,
+        appPath: resolvedPath,
+        uploadedRef,
+    };
+}

package/build/src/cli/cloud-status-line.js

@@ -0,0 +1,98 @@
+const SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"];
+/**
+ * Heroku-style volatile status line for long-running cloud-provider steps.
+ * On a TTY each progress update overwrites the previous one (spinner + step
+ * name + elapsed + latest detail) and the whole line is cleared when the step
+ * finishes. On a non-TTY (CI, piped output) it degrades to plain log lines,
+ * printed only when the detail changes. Feed it cloud progress events via
+ * handleEvent: "phase" events time named sub-steps and "note" events keep
+ * persistent info; both are printed (prefixed with `indent`) when the step
+ * finishes.
+ */
+export function createStatusLine({ stream = process.stderr, indent = "" } = {}) {
+    const tty = stream.isTTY;
+    let active = false;
+    let timer = null;
+    let frame = 0;
+    let stepName = "";
+    let detail = "";
+    let startedAt = 0;
+    let lastPrintedDetail = "";
+    let entries = [];
+    let currentPhase = null;
+    const render = () => {
+        frame = (frame + 1) % SPINNER_FRAMES.length;
+        const seconds = Math.floor((Date.now() - startedAt) / 1000);
+        const line = `${SPINNER_FRAMES[frame]} ${stepName} (${seconds}s)${detail ? ` — ${detail}` : ""}`;
+        stream.write(`\r\x1b[2K${line}`);
+    };
+    const closePhase = () => {
+        if (currentPhase) {
+            currentPhase.ms = Date.now() - currentPhase.startedAt;
+            currentPhase = null;
+        }
+    };
+    return {
+        start(name) {
+            active = true;
+            stepName = name;
+            detail = "";
+            lastPrintedDetail = "";
+            entries = [];
+            currentPhase = null;
+            startedAt = Date.now();
+            if (tty) {
+                // First frame is deferred so any line the caller just printed lands
+                // on its own row before this step starts drawing.
+                timer = setInterval(render, 120);
+            }
+        },
+        update(message) {
+            if (!active) {
+                return;
+            }
+            detail = message;
+            if (tty) {
+                render();
+            }
+            else if (message !== lastPrintedDetail) {
+                lastPrintedDetail = message;
+                console.log(`… ${stepName}: ${message}`);
+            }
+        },
+        handleEvent(event) {
+            if (!active) {
+                return;
+            }
+            if (event.kind === "phase") {
+                closePhase();
+                currentPhase = { kind: "phase", name: event.message, startedAt: Date.now(), ms: 0 };
+                entries.push(currentPhase);
+            }
+            else if (event.kind === "note") {
+                entries.push({ kind: "note", text: event.message });
+            }
+            this.update(event.message);
+        },
+        stop() {
+            active = false;
+            if (timer) {
+                clearInterval(timer);
+                timer = null;
+            }
+            if (tty) {
+                stream.write("\r\x1b[2K");
+            }
+            closePhase();
+            for (const entry of entries) {
+                if (entry.kind === "phase") {
+                    stream.write(`${indent}\x1b[32m✔\x1b[0m ${entry.name} \x1b[90m(${entry.ms}ms)\x1b[0m\n`);
+                }
+                else {
+                    stream.write(`${indent}\x1b[34mℹ\x1b[0m ${entry.text}\n`);
+                }
+            }
+            entries = [];
+        }
+    };
+}

package/build/src/cli/headless-runner.js

@@ -56,7 +56,7 @@ function emitCliAppContextDebug(runId, appContext, appContextText) {
         });
     }
 }
-function buildHeadlessEngineOptions({ runtimeContext, headlessConfig, executionPrompt, screenshotRecorder, recordScreenshots, screenshotDir, isBrowserTarget, isLambdaTestTarget, secrets = null }) {
+function buildHeadlessEngineOptions({ runtimeContext, headlessConfig, executionPrompt, screenshotRecorder, recordScreenshots, screenshotDir, isBrowserTarget, isCloudTarget, secrets = null }) {
     const executionEngineOptions = {
         toolCapabilities: {
             assert: true,
@@ -95,14 +95,14 @@ function buildHeadlessEngineOptions({ runtimeContext, headlessConfig, executionP
         engineOptions.handleModelAction = (browserSessionId, action, scale, actionContext) => handleBrowserModelAction(browserSessionId, action, scale, actionContext);
         engineOptions.getCurrentPlatform = getBrowserCurrentPlatform;
     }
-    else if (isLambdaTestTarget) {
+    else if (isCloudTarget) {
         engineOptions.connectToDevice = async () => {
-            throw new Error("LambdaTest cloud session disconnected; automatic CLI reconnect is not supported yet.");
+            throw new Error("Cloud session disconnected; automatic CLI reconnect is not supported yet.");
         };
     }
     return engineOptions;
 }
-async function runHeadlessTest({ runId, testPath, testName, instructions, session, deviceInfo, headlessConfig, appContext, testDataContext = "", runtimeContext, headlessDebug, recordScreenshots, screenshotDir, isBrowserTarget, isLambdaTestTarget, secrets = null, report = null, isBatchRun = false }) {
+async function runHeadlessTest({ runId, testPath, testName, instructions, session, deviceInfo, headlessConfig, appContext, testDataContext = "", runtimeContext, headlessDebug, recordScreenshots, screenshotDir, isBrowserTarget, isCloudTarget, secrets = null, report = null, isBatchRun = false }) {
     let executionMode = null;
     const reportEnabled = Boolean(report?.enabled);
     const collectedEvents = [];
@@ -146,7 +146,7 @@ async function runHeadlessTest({ runId, testPath, testName, instructions, sessio
             recordScreenshots,
             screenshotDir,
             isBrowserTarget,
-            isLambdaTestTarget,
+            isCloudTarget,
             secrets
         });
         const engine = new ExecutionEngine(session, engineOptions);
@@ -156,6 +156,7 @@ async function runHeadlessTest({ runId, testPath, testName, instructions, sessio
             addOutput,
             openAiClient: runtimeContext.openAiClient,
             loadmillClient: runtimeContext.loadmillClient,
+            runtimeConfig: runtimeContext.config,
             runtimeCredentials: runtimeContext.credentials,
             // Inline screenshots as data URLs so the HTML report is self-contained.
             ...(reportEnabled ? { includeScreenshotDataUrl: true } : {}),
@@ -223,7 +224,7 @@ async function runHeadlessTest({ runId, testPath, testName, instructions, sessio
         throw error;
     }
 }
-export async function runHeadlessInstructionRuns({ runs, instructionsTarget, session, deviceInfo, headlessConfig, appContext, runtimeContext, headlessDebug, secrets = null, recordScreenshots, screenshotDir, isBrowserTarget, isLambdaTestTarget, report = null, runHeadlessTestImpl = runHeadlessTest }) {
+export async function runHeadlessInstructionRuns({ runs, instructionsTarget, session, deviceInfo, headlessConfig, appContext, runtimeContext, headlessDebug, secrets = null, recordScreenshots, screenshotDir, isBrowserTarget, isCloudTarget, report = null, runHeadlessTestImpl = runHeadlessTest }) {
     const isBatchRun = instructionsTarget?.type === "directory" || instructionsTarget?.type === "scenario";
     if (instructionsTarget?.type === "scenario") {
         console.log(`\nRunning ${runs.length} scenario case${runs.length === 1 ? "" : "s"}\n`);
@@ -259,7 +260,7 @@ export async function runHeadlessInstructionRuns({ runs, instructionsTarget, ses
                 recordScreenshots,
                 screenshotDir: testScreenshotDir,
                 isBrowserTarget,
-                isLambdaTestTarget,
+                isCloudTarget,
                 report,
                 isBatchRun
             });