@loadmill/droid-cua 2.18.0 → 2.21.0

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

@@ -37,18 +37,25 @@ function normalizeBrowser(value) {
     }
     throw new Error("--browser must be one of: chrome, edge.");
 }
+const CLOUD_SOURCE_DISPLAY_NAMES = {
+    lambdatest: "LambdaTest",
+    "aws-device-farm": "AWS Device Farm",
+};
+function isCloudDeviceSource(deviceSource) {
+    return Object.hasOwn(CLOUD_SOURCE_DISPLAY_NAMES, deviceSource);
+}
 function normalizeDeviceSource(value) {
     if (value == null || value === "") {
         return "local";
     }
     if (typeof value !== "string") {
-        throw new Error("--device-source must be one of: local, lambdatest.");
+        throw new Error("--device-source must be one of: local, lambdatest, aws-device-farm.");
     }
     const normalized = value.trim().toLowerCase();
-    if (normalized === "local" || normalized === "lambdatest") {
+    if (normalized === "local" || isCloudDeviceSource(normalized)) {
         return normalized;
     }
-    throw new Error("--device-source must be one of: local, lambdatest.");
+    throw new Error("--device-source must be one of: local, lambdatest, aws-device-farm.");
 }
 function normalizeMobilePlatform(value, label) {
     if (!hasNonEmptyString(value)) {
@@ -72,31 +79,38 @@ function readNonEmptyCliValue(value) {
     }
     return null;
 }
-function assertNoLambdaTestFlags(args) {
-    const lambdaTestFlags = [
+function assertNoCloudFlags(args) {
+    const cloudFlags = [
         ["device-name", "--device-name"],
         ["os-version", "--os-version"],
         ["app", "--app"],
     ];
-    for (const [key, label] of lambdaTestFlags) {
+    for (const [key, label] of cloudFlags) {
         if (args[key] != null) {
-            throw new Error(`${label} can only be used with --device-source lambdatest.`);
+            throw new Error(`${label} can only be used with a cloud --device-source.`);
         }
     }
 }
-function normalizeLambdaTestAppPath(value) {
+function normalizeCloudAppPath(value, platform, deviceSource) {
     if (!hasNonEmptyString(value)) {
         return null;
     }
+    const displayName = CLOUD_SOURCE_DISPLAY_NAMES[deviceSource];
     const appPath = value.trim();
     const lower = appPath.toLowerCase();
-    if (lower.endsWith(".apk") || lower.endsWith(".ipa")) {
-        return appPath;
-    }
     if (lower.endsWith(".app")) {
-        throw new Error("LambdaTest real-device sessions require an .apk for Android or an .ipa for iOS. .app bundles are not supported.");
+        throw new Error(`${displayName} real-device sessions require an .apk for Android or an .ipa for iOS. .app bundles are not supported.`);
+    }
+    if (!lower.endsWith(".apk") && !lower.endsWith(".ipa")) {
+        throw new Error(`--app must point to an .apk or .ipa file for ${displayName} runs.`);
+    }
+    if (platform === "android" && !lower.endsWith(".apk")) {
+        throw new Error(`${displayName} Android sessions require an .apk build.`);
+    }
+    if (platform === "ios" && !lower.endsWith(".ipa")) {
+        throw new Error(`${displayName} iOS sessions require an .ipa build.`);
     }
-    throw new Error("--app must point to an .apk or .ipa file for LambdaTest runs.");
+    return appPath;
 }
 export function resolveHeadlessTarget(args = {}) {
     const target = normalizeTarget(args.target);
@@ -104,6 +118,9 @@ export function resolveHeadlessTarget(args = {}) {
     const avdName = hasNonEmptyString(args.avd) ? args.avd.trim() : null;
     const platform = normalizeMobilePlatform(args.platform, "--platform");
     const deviceSource = normalizeDeviceSource(args["device-source"]);
+    if (args["list-devices"] != null && deviceSource !== "aws-device-farm") {
+        throw new Error("--list-devices can only be used with --device-source aws-device-farm.");
+    }
     if (target === "web") {
         if (avdName || platform) {
             throw new Error("--avd and --platform cannot be used with --target web.");
@@ -111,7 +128,7 @@ export function resolveHeadlessTarget(args = {}) {
         if (deviceSource !== "local") {
             throw new Error("--device-source can only be used with --target mobile.");
         }
-        assertNoLambdaTestFlags(args);
+        assertNoCloudFlags(args);
         return {
             target,
             sessionMode,
@@ -122,6 +139,7 @@ export function resolveHeadlessTarget(args = {}) {
             deviceName: null,
             osVersion: null,
             appPath: null,
+            listDevices: false,
         };
     }
     if (args["session-mode"] != null) {
@@ -130,27 +148,42 @@ export function resolveHeadlessTarget(args = {}) {
     if (args.browser != null) {
         throw new Error("--browser can only be used with --target web.");
     }
+    // --list-devices only needs credentials — no device/app flags required.
+    if (args["list-devices"] != null) {
+        return {
+            target,
+            sessionMode: null,
+            browserFamily: null,
+            deviceSource,
+            avdName: null,
+            platform: null,
+            deviceName: null,
+            osVersion: null,
+            appPath: null,
+            listDevices: true,
+        };
+    }
     if (deviceSource === "local") {
-        assertNoLambdaTestFlags(args);
+        assertNoCloudFlags(args);
     }
-    if (deviceSource === "lambdatest") {
+    if (isCloudDeviceSource(deviceSource)) {
         const deviceName = hasNonEmptyString(args["device-name"]) ? args["device-name"].trim() : null;
         const osVersion = readNonEmptyCliValue(args["os-version"]);
-        const appPath = normalizeLambdaTestAppPath(args.app);
+        const appPath = normalizeCloudAppPath(args.app, platform, deviceSource);
         if (avdName) {
-            throw new Error("--avd cannot be used with --device-source lambdatest.");
+            throw new Error(`--avd cannot be used with --device-source ${deviceSource}.`);
         }
         if (!platform) {
-            throw new Error("--platform is required with --device-source lambdatest.");
+            throw new Error(`--platform is required with --device-source ${deviceSource}.`);
         }
         if (!deviceName) {
-            throw new Error("--device-name is required with --device-source lambdatest.");
+            throw new Error(`--device-name is required with --device-source ${deviceSource}.`);
         }
         if (!osVersion) {
-            throw new Error("--os-version is required with --device-source lambdatest.");
+            throw new Error(`--os-version is required with --device-source ${deviceSource}.`);
         }
         if (!appPath) {
-            throw new Error("--app is required with --device-source lambdatest.");
+            throw new Error(`--app is required with --device-source ${deviceSource}.`);
         }
         return {
             target,
@@ -162,6 +195,7 @@ export function resolveHeadlessTarget(args = {}) {
             deviceName,
             osVersion,
             appPath,
+            listDevices: false,
         };
     }
     return {
@@ -174,5 +208,6 @@ export function resolveHeadlessTarget(args = {}) {
         deviceName: null,
         osVersion: null,
         appPath: null,
+        listDevices: false,
     };
 }

package/build/src/commands/loadmill.js

@@ -2,7 +2,7 @@
  * Loadmill command handler
  */
 import { createLoadmillApiClient, executeLoadmillCommand, getApiToken } from "../integrations/loadmill/index.js";
-import { createResolvedLlmClient, resolveRuntimeConfigFromEnv, resolveRuntimeCredentialsFromEnv, } from "../core/runtime-config.js";
+import { createResolvedLlmClient, resolveEffectiveHelperModel, resolveRuntimeConfigFromEnv, resolveRuntimeCredentialsFromEnv, } from "../core/runtime-config.js";
 /**
  * Handle /loadmill command
  * @param {string} args - Command arguments (natural language command)
@@ -60,10 +60,17 @@ export async function handleLoadmill(args, session, context) {
             credentials: runtimeCredentials,
             clientName: "cli",
         });
+        const helperModel = runtimeConfig.llmProviderMode === "openai"
+            ? resolveEffectiveHelperModel({
+                llmProviderMode: runtimeConfig.llmProviderMode,
+                cuaModel: runtimeConfig.cuaModel,
+            })
+            : null;
         // Execute the command
         const result = await executeLoadmillCommand(command, {
             loadmillClient,
             openAiClient,
+            helperModel,
             onProgress: ({ message }) => {
                 addOutput({ type: 'info', text: `[Loadmill] ${message}` });
             }

package/build/src/core/execution-engine.js

@@ -185,6 +185,19 @@ export class ExecutionEngine {
             if (shouldStop()) {
                 return { stopped: true, sawExplicitScreenshotAction };
             }
+            if (context?.waitIfPaused) {
+                const pauseResult = await context.waitIfPaused({
+                    boundary: "before_action",
+                    refreshScreenOnResume: true,
+                    stepContext,
+                });
+                if (pauseResult?.status === "stopped" || shouldStop()) {
+                    return { stopped: true, sawExplicitScreenshotAction };
+                }
+                if (pauseResult?.refreshScreen) {
+                    return { refreshModelState: true, sawExplicitScreenshotAction };
+                }
+            }
             if (action.type === "screenshot") {
                 sawExplicitScreenshotAction = true;
                 continue;
@@ -223,6 +236,17 @@ export class ExecutionEngine {
         }
         return { stopped: false, sawExplicitScreenshotAction };
     }
+    async waitIfPaused(context = null, stepContext = null, boundary = "turn_boundary", refreshScreenOnResume = true) {
+        if (!context?.waitIfPaused) {
+            return { status: "running", refreshScreen: false };
+        }
+        const result = await context.waitIfPaused({
+            boundary,
+            refreshScreenOnResume,
+            stepContext,
+        });
+        return result ?? { status: "running", refreshScreen: false };
+    }
     async buildActionFollowUp(callId, pendingSafetyChecks, sawExplicitScreenshotAction, addOutput, eventMeta, context = null, stepContext = null) {
         const screenshotBase64 = await this.getScreenshotAsBase64(this.session.deviceId, this.session.deviceInfo);
         emitDesktopDebug("device.screenshot", "device", {
@@ -358,11 +382,21 @@ export class ExecutionEngine {
             instructionIndex: stepContext?.instructionIndex,
             ...extra
         });
+        let refreshBeforeNextComputerAction = false;
         while (true) {
             // Check for interruption before processing next batch of actions
             if (shouldStop()) {
+                summary.stopped = true;
+                return finalize();
+            }
+            const pauseResult = await this.waitIfPaused(context, stepContext, "before_model_output", true);
+            if (pauseResult.status === "stopped" || shouldStop()) {
+                summary.stopped = true;
                 return finalize();
             }
+            if (pauseResult.refreshScreen) {
+                refreshBeforeNextComputerAction = true;
+            }
             const items = response.output || [];
             const actionableItems = extractActionableOutputItems(items);
             const pendingSafetyChecks = collectPendingSafetyChecks(items);
@@ -385,8 +419,17 @@ export class ExecutionEngine {
                     currentScreenshot = toolResult.currentScreenshot;
                 }
                 if (shouldStop()) {
+                    summary.stopped = true;
+                    return finalize();
+                }
+                const toolPauseResult = await this.waitIfPaused(context, stepContext, "after_tool_call", true);
+                if (toolPauseResult.status === "stopped" || shouldStop()) {
+                    summary.stopped = true;
                     return finalize();
                 }
+                if (toolPauseResult.refreshScreen) {
+                    refreshBeforeNextComputerAction = true;
+                }
                 if (toolResult.kind === "fail") {
                     summary.failed = true;
                     summary.error = toolResult.error;
@@ -419,14 +462,39 @@ export class ExecutionEngine {
                 continue;
             }
             const { call_id, actions } = actionableItem;
+            if (refreshBeforeNextComputerAction) {
+                const followUp = await this.buildActionFollowUp(call_id, pendingSafetyChecks, true, addOutput, eventMeta, context, stepContext);
+                currentScreenshot = followUp.currentScreenshot ?? currentScreenshot;
+                response = await this.requestNextTurn(followUp.input, newResponseId, context, stepContext);
+                newResponseId = response.id;
+                refreshBeforeNextComputerAction = false;
+                continue;
+            }
             const actionBatchResult = await this.executeActionBatch(actions, currentScreenshot, shouldStop, context, stepContext, trackAction);
             if (actionBatchResult.stopped) {
+                summary.stopped = true;
                 return finalize();
             }
+            if (actionBatchResult.refreshModelState) {
+                const followUp = await this.buildActionFollowUp(call_id, pendingSafetyChecks, true, addOutput, eventMeta, context, stepContext);
+                currentScreenshot = followUp.currentScreenshot ?? currentScreenshot;
+                response = await this.requestNextTurn(followUp.input, newResponseId, context, stepContext);
+                newResponseId = response.id;
+                continue;
+            }
             const followUp = await this.buildActionFollowUp(call_id, pendingSafetyChecks, actionBatchResult.sawExplicitScreenshotAction, addOutput, eventMeta, context, stepContext);
             if (shouldStop()) {
+                summary.stopped = true;
                 return finalize();
             }
+            const followUpPauseResult = await this.waitIfPaused(context, stepContext, "after_action_follow_up", true);
+            if (followUpPauseResult.status === "stopped" || shouldStop()) {
+                summary.stopped = true;
+                return finalize();
+            }
+            if (followUpPauseResult.refreshScreen) {
+                refreshBeforeNextComputerAction = true;
+            }
             currentScreenshot = followUp.currentScreenshot ?? currentScreenshot;
             response = await this.requestNextTurn(followUp.input, newResponseId, context, stepContext);
             newResponseId = response.id;

package/build/src/core/report/run-log-model.js

@@ -32,6 +32,12 @@ export function mediaKindOf(line) {
     return "none";
 }
 export function isHiddenExecutionLogEvent(line) {
+    if (line.eventType === "run_paused")
+        return true;
+    // Connecting markers drive renderer state (isConnecting) but carry no
+    // user-facing content beyond the cloud progress lines already shown.
+    if (line.eventType === "run_connecting" || line.eventType === "run_connected")
+        return true;
     return mediaKindOf(line) === "hidden-debug";
 }
 export function isGalleryMediaEvent(line) {