@loadmill/droid-cua 2.29.0 → 2.31.0

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

@@ -1,3 +1,4 @@
+import { CLOUD_BROWSER_FAMILIES, CLOUD_BROWSER_VERSION_ALIASES, LOCAL_BROWSER_FAMILIES, } from "../browser/cloud-browser-catalog.js";
 function normalizeTarget(value) {
     if (value == null || value === "") {
         return "mobile";
@@ -24,18 +25,31 @@ function normalizeSessionMode(value) {
     }
     throw new Error("--session-mode must be one of: persistent, fresh.");
 }
-function normalizeBrowser(value) {
+function normalizeBrowser(value, allowedFamilies) {
     if (value == null || value === "") {
         return "chrome";
     }
     if (typeof value !== "string") {
-        throw new Error("--browser must be one of: chrome, edge.");
+        throw new Error(`--browser must be one of: ${allowedFamilies.join(", ")}.`);
     }
     const normalized = value.trim().toLowerCase();
-    if (normalized === "chrome" || normalized === "edge") {
+    if (allowedFamilies.includes(normalized)) {
         return normalized;
     }
-    throw new Error("--browser must be one of: chrome, edge.");
+    throw new Error(`--browser must be one of: ${allowedFamilies.join(", ")}.`);
+}
+function normalizeCloudBrowserVersion(value) {
+    if (value == null || value === "") {
+        return "latest";
+    }
+    if (typeof value !== "string") {
+        throw new Error(`--browser-version must be one of: ${CLOUD_BROWSER_VERSION_ALIASES.join(", ")}.`);
+    }
+    const normalized = value.trim().toLowerCase();
+    if (CLOUD_BROWSER_VERSION_ALIASES.includes(normalized)) {
+        return normalized;
+    }
+    throw new Error(`--browser-version must be one of: ${CLOUD_BROWSER_VERSION_ALIASES.join(", ")}.`);
 }
 const CLOUD_SOURCE_DISPLAY_NAMES = {
     lambdatest: "LambdaTest",
@@ -80,25 +94,48 @@ function readNonEmptyCliValue(value) {
     }
     return null;
 }
-const ARTIFACT_KINDS = ["video", "deviceLog", "appiumLog"];
-function normalizeArtifactKinds(value) {
+export const MOBILE_ARTIFACT_KINDS = ["video", "deviceLog", "appiumLog"];
+export const WEB_ARTIFACT_KINDS = ["video", "seleniumLog"];
+const UNRESOLVED_POOL_ARTIFACT_KINDS = [...MOBILE_ARTIFACT_KINDS, "seleniumLog"];
+const ARTIFACT_KINDS_BY_POOL = {
+    mobile: MOBILE_ARTIFACT_KINDS,
+    web: WEB_ARTIFACT_KINDS,
+};
+export function artifactKindsForPool(pool) {
+    const kinds = ARTIFACT_KINDS_BY_POOL[pool];
+    if (!kinds) {
+        throw new Error(`Unknown Loadmill Cloud pool: ${pool}. Expected "mobile" or "web".`);
+    }
+    return [...kinds];
+}
+export function scopeArtifactKindsToPool(kinds, pool) {
+    const allowed = artifactKindsForPool(pool);
+    return kinds.filter((kind) => allowed.includes(kind));
+}
+function allowedArtifactKindsForTarget(target, poolKnown) {
+    if (!poolKnown) {
+        return UNRESOLVED_POOL_ARTIFACT_KINDS;
+    }
+    return target === "web" ? WEB_ARTIFACT_KINDS : MOBILE_ARTIFACT_KINDS;
+}
+function normalizeArtifactKinds(value, allowedKinds) {
     if (value == null || value === "") {
         return null;
     }
     if (typeof value !== "string") {
-        throw new Error(`--artifacts must be a comma-separated list of: ${ARTIFACT_KINDS.join(", ")}, or all.`);
+        throw new Error(`--artifacts must be a comma-separated list of: ${allowedKinds.join(", ")}, or all.`);
     }
     const raw = value.trim();
     if (!raw) {
         return null;
     }
     if (raw.toLowerCase() === "all") {
-        return [...ARTIFACT_KINDS];
+        return [...allowedKinds];
     }
     const kinds = [...new Set(raw.split(",").map((kind) => kind.trim()).filter(Boolean))];
-    const invalid = kinds.filter((kind) => !ARTIFACT_KINDS.includes(kind));
+    const invalid = kinds.filter((kind) => !allowedKinds.includes(kind));
     if (invalid.length > 0) {
-        throw new Error(`--artifacts has invalid kind(s): ${invalid.join(", ")}. Must be one of: ${ARTIFACT_KINDS.join(", ")}, or all.`);
+        throw new Error(`--artifacts has invalid kind(s): ${invalid.join(", ")}. Must be one of: ${allowedKinds.join(", ")}, or all.`);
     }
     return kinds;
 }
@@ -144,9 +181,10 @@ function normalizeCloudAppPath(value, platform, deviceSource) {
 export function shouldWaitForLoadmillCloudCompletion(targetConfig) {
     return Array.isArray(targetConfig?.artifacts) && targetConfig.artifacts.length > 0;
 }
+const MOBILE_ONLY_CLOUD_SOURCES = new Set(["lambdatest", "aws-device-farm"]);
 export function resolveHeadlessTarget(args = {}) {
     const target = normalizeTarget(args.target);
-    const sessionMode = normalizeSessionMode(args["session-mode"]);
+    const targetGiven = hasNonEmptyString(args.target);
     const avdName = hasNonEmptyString(args.avd) ? args.avd.trim() : null;
     const platform = normalizeMobilePlatform(args.platform, "--platform");
     // The mtc_ prefix on --cloud-session-id is loadmill-cloud's; when no
@@ -164,14 +202,44 @@ export function resolveHeadlessTarget(args = {}) {
         if (avdName || platform) {
             throw new Error("--avd and --platform cannot be used with --target web.");
         }
-        if (deviceSource !== "local") {
-            throw new Error("--device-source can only be used with --target mobile.");
+        if (MOBILE_ONLY_CLOUD_SOURCES.has(deviceSource)) {
+            throw new Error(`--device-source ${deviceSource} can only be used with --target mobile.`);
+        }
+        if (hasNonEmptyString(args["device-name"])) {
+            throw new Error("--device-name cannot be used with --target web.");
+        }
+        if (readNonEmptyCliValue(args["os-version"]) != null) {
+            throw new Error("--os-version cannot be used with --target web.");
+        }
+        if (hasNonEmptyString(args.app)) {
+            throw new Error("--app cannot be used with --target web.");
+        }
+        if (deviceSource === "loadmill-cloud") {
+            if (args["session-mode"] != null) {
+                throw new Error("--session-mode can only be used with --device-source local.");
+            }
+            return {
+                target,
+                sessionMode: null,
+                browserFamily: normalizeBrowser(args.browser, CLOUD_BROWSER_FAMILIES),
+                browserVersion: normalizeCloudBrowserVersion(args["browser-version"]),
+                deviceSource: "loadmill-cloud",
+                avdName: null,
+                platform: null,
+                deviceName: null,
+                osVersion: null,
+                appPath: null,
+                cloudSessionId: readNonEmptyCliValue(args["cloud-session-id"]),
+                artifacts: normalizeArtifactKinds(args.artifacts, WEB_ARTIFACT_KINDS),
+                listDevices: false,
+            };
         }
         assertNoCloudFlags(args);
         return {
             target,
-            sessionMode,
-            browserFamily: normalizeBrowser(args.browser),
+            sessionMode: normalizeSessionMode(args["session-mode"]),
+            browserFamily: normalizeBrowser(args.browser, LOCAL_BROWSER_FAMILIES),
+            browserVersion: null,
             deviceSource: "local",
             avdName: null,
             platform: null,
@@ -195,6 +263,7 @@ export function resolveHeadlessTarget(args = {}) {
             target,
             sessionMode: null,
             browserFamily: null,
+            browserVersion: null,
             deviceSource,
             avdName: null,
             platform: null,
@@ -215,7 +284,7 @@ export function resolveHeadlessTarget(args = {}) {
         const cloudSessionId = readNonEmptyCliValue(args["cloud-session-id"]);
         const isReconnect = deviceSource === "loadmill-cloud" && Boolean(cloudSessionId);
         const appPath = normalizeCloudAppPath(args.app, platform, deviceSource);
-        const artifacts = normalizeArtifactKinds(args.artifacts);
+        const artifacts = normalizeArtifactKinds(args.artifacts, allowedArtifactKindsForTarget(target, targetGiven || !isReconnect));
         if (artifacts && deviceSource !== "loadmill-cloud") {
             throw new Error("--artifacts can only be used with --device-source loadmill-cloud.");
         }
@@ -241,6 +310,7 @@ export function resolveHeadlessTarget(args = {}) {
             target,
             sessionMode: null,
             browserFamily: null,
+            browserVersion: null,
             deviceSource,
             avdName: null,
             platform,
@@ -256,6 +326,7 @@ export function resolveHeadlessTarget(args = {}) {
         target,
         sessionMode: null,
         browserFamily: null,
+        browserVersion: null,
         deviceSource,
         avdName,
         platform,

package/build/src/cli/headless-test-source-label.js

@@ -0,0 +1,4 @@
+const INLINE_SOURCE_PATTERN = /^\/dev\/(fd\/\d+|stdin)$/;
+export function formatHeadlessTestSourceLabel(sourcePath) {
+    return INLINE_SOURCE_PATTERN.test(sourcePath) ? "(inline instructions)" : sourcePath;
+}

package/build/src/cli/loadmill-cloud-device-connect-summary.js

@@ -0,0 +1,6 @@
+export function buildLoadmillCloudDeviceConnectSummaryLines({ deviceInfo }) {
+    return [
+        `Using real resolution: ${deviceInfo.device_width}x${deviceInfo.device_height}`,
+        `Model sees resolution: ${deviceInfo.scaled_width}x${deviceInfo.scaled_height}`,
+    ];
+}

package/build/src/cli/loadmill-cloud-session.js

@@ -0,0 +1,26 @@
+export async function withLoadmillCloudSession({ credentials, connect, teardown, run = null }) {
+    const targetId = await connect(credentials);
+    if (typeof run !== "function") {
+        return targetId;
+    }
+    try {
+        return await run(targetId);
+    }
+    finally {
+        await teardown();
+    }
+}
+export function createBrowserSessionTeardown({ disconnect, releaseSession }) {
+    return async () => {
+        try {
+            await disconnect();
+        }
+        catch (error) {
+            const message = error instanceof Error ? error.message : String(error);
+            console.error(`[loadmill-cloud] browser disconnect failed: ${message}`);
+        }
+        finally {
+            await releaseSession();
+        }
+    };
+}

package/build/src/core/context-optimization.js

@@ -1,5 +1,5 @@
 export const DEFAULT_CONTEXT_OPTIMIZATION_ENABLED = true;
-export const DEFAULT_CONTEXT_OPTIMIZATION_THRESHOLD = 30000;
+export const DEFAULT_CONTEXT_OPTIMIZATION_THRESHOLD = 60000;
 export const MIN_CONTEXT_OPTIMIZATION_THRESHOLD = 10000;
 export const MAX_CONTEXT_OPTIMIZATION_THRESHOLD = 900000;
 export const CONTEXT_OPTIMIZATION_ENABLED_ENV = "DROID_CUA_CONTEXT_OPTIMIZATION_ENABLED";

package/build/src/core/droid-version.js

@@ -0,0 +1,25 @@
+import { existsSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+export function getDroidVersion(moduleUrl = import.meta.url) {
+    try {
+        let directory = path.dirname(fileURLToPath(moduleUrl));
+        while (true) {
+            const packagePath = path.join(directory, "package.json");
+            if (existsSync(packagePath)) {
+                const packageJson = JSON.parse(readFileSync(packagePath, "utf8"));
+                if (packageJson.name === "@loadmill/droid-cua") {
+                    return typeof packageJson.version === "string" ? packageJson.version : null;
+                }
+            }
+            const parent = path.dirname(directory);
+            if (parent === directory) {
+                return null;
+            }
+            directory = parent;
+        }
+    }
+    catch {
+        return null;
+    }
+}

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

@@ -503,6 +503,15 @@ export class ExecutionEngine {
     }
     emitResponseOutputItems(items, addOutput, eventMeta, options = {}) {
         for (const item of items) {
+            if (item.type === "compaction") {
+                addOutput({
+                    type: "info",
+                    text: "Optimized context",
+                    eventType: "system_message",
+                    ...eventMeta({ payload: { event: "context.optimized" } }),
+                });
+                continue;
+            }
             if (item.type === "reasoning") {
                 for (const entry of item.summary) {
                     if (entry.type !== "summary_text")

package/build/src/core/runtime-config.js

@@ -123,7 +123,7 @@ export function resolveRuntimeCredentials({ openAiApiKey = null, loadmillApiToke
         loadmillBaseUrl: normalizeLoadmillSiteBaseUrl(loadmillBaseUrl),
     };
 }
-export function resolveRuntimeConfig({ llmProviderMode = null, cuaModel = null, explainMode = false, stepDelayMs = undefined, contextOptimizationEnabled = undefined, contextOptimizationThreshold = undefined, promptCustomizations = null, appContext = null, } = {}) {
+export function resolveRuntimeConfig({ llmProviderMode = null, cuaModel = null, explainMode = true, stepDelayMs = undefined, contextOptimizationEnabled = undefined, contextOptimizationThreshold = undefined, promptCustomizations = null, appContext = null, } = {}) {
     const normalizedCuaModel = typeof cuaModel === "string" && LOADMILL_MODEL_ALIAS_SET.has(cuaModel)
         ? cuaModel
         : resolveCuaModel(cuaModel);
@@ -133,7 +133,7 @@ export function resolveRuntimeConfig({ llmProviderMode = null, cuaModel = null,
             ? "loadmill"
             : normalizedProviderMode,
         cuaModel: normalizedCuaModel,
-        explainMode: explainMode === true,
+        explainMode: explainMode !== false,
         stepDelayMs: normalizeStepDelayMs(Number(stepDelayMs)),
         contextOptimizationEnabled: normalizeContextOptimizationEnabled(contextOptimizationEnabled),
         contextOptimizationThreshold: normalizeContextOptimizationThreshold(contextOptimizationThreshold),

package/build/src/desktop-shared/connection-predicates.js

@@ -0,0 +1,52 @@
+const CLOUD_CONNECTION_SOURCES = new Set(["browserstack", "lambdatest", "aws-device-farm", "loadmill-cloud"]);
+/**
+ * True when a desktop connection needs the cloud-session lifecycle
+ * (provisioning, heartbeat, release) regardless of whether it targets a
+ * device or a browser.
+ *
+ * @param {{ source?: string | null }} connection
+ * @returns {boolean}
+ */
+export function needsCloudSessionManagement(connection) {
+    return CLOUD_CONNECTION_SOURCES.has(connection?.source);
+}
+/**
+ * True when a desktop connection should route through the browser engine
+ * hooks (screenshot/action/platform) instead of the device ones.
+ *
+ * @param {{ platform?: string | null }} connection
+ * @returns {boolean}
+ */
+export function usesBrowserEngineHooks(connection) {
+    return connection?.platform === "browser";
+}
+/**
+ * True when a desktop connection needs the Android tool-environment
+ * refresh, which only applies to Android device connections.
+ *
+ * @param {{ platform?: string | null }} connection
+ * @returns {boolean}
+ */
+export function needsAndroidToolEnvRefresh(connection) {
+    return connection?.platform === "android";
+}
+/**
+ * The status/outcome pair a desktop provisioning failure must report so the
+ * remote Loadmill classification and the local JUnit history agree.
+ *
+ * @returns {{ status: "error", outcome: "error" }}
+ */
+export function resolveProvisioningFailureReporting() {
+    return { status: "error", outcome: "error" };
+}
+/**
+ * Builds a `connectToBrowser` engine hook that refuses to relaunch a
+ * browser mid-run instead of silently starting a local one.
+ *
+ * @returns {() => Promise<never>}
+ */
+export function createRefuseReconnectConnectToBrowser() {
+    return async () => {
+        throw new Error("Cloud session disconnected; automatic CLI reconnect is not supported yet.");
+    };
+}

package/build/src/device/cloud/cloud-appium-client.js

@@ -9,14 +9,34 @@ export class CloudAppiumClient {
     }
     async request(method, path, body = null) {
         const authHeader = this.provider.getAuthHeader(this.creds);
-        const response = await fetch(`${this.provider.getHubUrl()}${path}`, {
+        const requestOptions = {
             method,
             headers: {
                 ...(authHeader ? { Authorization: authHeader } : {}),
                 ...(body ? { "Content-Type": "application/json" } : {})
             },
             body: body ? JSON.stringify(body) : undefined
-        });
+        };
+        try {
+            return await this._sendRequest(path, requestOptions);
+        }
+        catch (error) {
+            if (error.message !== "Invalid pre-signed URL" || typeof this.provider.refreshWebdriverEndpoint !== "function") {
+                throw error;
+            }
+            try {
+                await this.provider.refreshWebdriverEndpoint();
+            }
+            catch (refreshError) {
+                throw new Error(`Failed to refresh the expired cloud WebDriver endpoint: ${refreshError.message}`, {
+                    cause: error
+                });
+            }
+            return this._sendRequest(path, requestOptions);
+        }
+    }
+    async _sendRequest(path, requestOptions) {
+        const response = await fetch(`${this.provider.getHubUrl()}${path}`, requestOptions);
         const text = await response.text();
         const payload = text ? JSON.parse(text) : {};
         if (!response.ok) {

package/build/src/device/cloud/loadmill-cloud/adapter.js

@@ -4,13 +4,9 @@ import { reportCloudNote, reportCloudPhase, reportCloudPhaseCloseText, reportClo
 import { LoadmillCloudControlPlaneClient } from "./control-plane-client.js";
 import { downloadArtifacts } from "./artifact-downloader.js";
 import { formatBytes } from "./format-bytes.js";
+import { ARTIFACT_READY_STATUSES, TERMINAL_STATUSES } from "./run-status.js";
 import { timingLog } from "./timing.js";
 const RESUMABLE_STATUSES = new Set(["PROVISIONED", "CONNECTED", "RUNNING"]);
-const TERMINAL_STATUSES = new Set(["COMPLETED", "CANCELLED", "ERROR"]);
-// Artifacts are readable from DF while a run is still tearing down
-// (STOPPING), not just once it reaches a true terminal state. Mirrors the
-// server's ARTIFACT_READY_STATES.
-const ARTIFACT_READY_STATUSES = new Set(["STOPPING", ...TERMINAL_STATUSES]);
 const SLOT_HELD_STATUSES = new Set(["PREPARING", "PROVISIONED", "CONNECTED", "RUNNING"]);
 const ARTIFACT_POLL_BUDGET_MS = 3 * 60_000;
 const ARTIFACT_POLL_INTERVAL_MS = 5_000;
@@ -25,7 +21,11 @@ function deviceCacheKey(creds) {
 }
 let activeRun = null;
 function makeClient(creds) {
-    return new LoadmillCloudControlPlaneClient({ bearerToken: creds.bearerToken, baseUrl: creds.baseUrl });
+    return new LoadmillCloudControlPlaneClient({
+        bearerToken: creds.bearerToken,
+        baseUrl: creds.baseUrl,
+        pool: "mobile",
+    });
 }
 function mapDevice(device) {
     return {
@@ -189,11 +189,9 @@ async function pollForArtifacts(client, sessionId, kinds, { budgetMs, intervalMs
         }
         catch (error) {
             const retryable = (error?.status === 409 && error?.code === "artifacts_not_ready") ||
-                (error?.status === 502 && error?.code === "mobile_testing_artifacts_failed");
+                (error?.status >= 500 && error?.status < 600);
             if (retryable) {
-                timingLog(error.status === 409
-                    ? `poll #${pollNumber}: 409 artifacts_not_ready`
-                    : `poll #${pollNumber}: 502 mobile_testing_artifacts_failed`);
+                timingLog(`poll #${pollNumber}: ${error.status} ${error.code ?? "unknown"}`);
             }
             else {
                 throw error;
@@ -218,7 +216,11 @@ function formatDownloadDetail(fileName, bytesWritten, totalBytes) {
     }
     return `downloading ${fileName} — ${formatBytes(bytesWritten)}`;
 }
-async function fetchAndDownloadArtifacts({ client, sessionId, kinds }) {
+export function formatArtifactRetryCommand({ client, sessionId, kinds }) {
+    const targetFlag = client?.pool === "web" ? "--target web " : "";
+    return `droid-cua ${targetFlag}--cloud-session-id ${sessionId} --artifacts ${kinds.join(",")}`;
+}
+export async function fetchAndDownloadArtifacts({ client, sessionId, kinds }) {
     reportCloudPhase("artifact list");
     const { artifacts, missingKinds, elapsedMs } = await pollForArtifacts(client, sessionId, kinds, {
         budgetMs: ARTIFACT_POLL_BUDGET_MS,
@@ -256,11 +258,14 @@ async function fetchAndDownloadArtifacts({ client, sessionId, kinds }) {
         reportCloudPrint(`Artifacts saved to ${destDir}`);
     }
     if (missingKinds.length > 0) {
-        reportCloudNote(`WARNING: artifacts not ready for: ${missingKinds.join(", ")}. Retry later with: droid-cua --cloud-session-id ${sessionId} --artifacts ${kinds.join(",")}`);
+        reportCloudNote(`WARNING: artifacts not ready for: ${missingKinds.join(", ")}. Retry later with: ${formatArtifactRetryCommand({ client, sessionId, kinds })}`);
     }
     return { downloadedKinds: summary.map((item) => item.kind), missingKinds };
 }
 async function uploadAppIfNeeded(client, sessionId, { app, platform, signal }) {
+    if (!app) {
+        return null;
+    }
     const fileName = path.basename(app);
     const sha256 = await hashFile(app);
     reportCloudPhase("register app");
@@ -470,6 +475,17 @@ export const loadmillCloudAdapter = {
         }
         return activeRun.webdriverEndpoint;
     },
+    async refreshWebdriverEndpoint() {
+        if (!activeRun) {
+            throw new Error("Loadmill Cloud cannot refresh the webdriver endpoint without an active session.");
+        }
+        const result = await activeRun.client.refreshWebdriverEndpoint(activeRun.sessionId);
+        if (!result?.webdriverEndpoint || typeof result.webdriverEndpoint !== "string") {
+            throw new Error("Loadmill Cloud endpoint refresh returned no webdriver endpoint.");
+        }
+        activeRun.webdriverEndpoint = result.webdriverEndpoint;
+        return activeRun.webdriverEndpoint;
+    },
     getAuthHeader() {
         // Presigned hub URL carries its own auth; no header needed.
         return "";

package/build/src/device/cloud/loadmill-cloud/artifact-downloader.js

@@ -4,9 +4,9 @@ import { mkdir } from "node:fs/promises";
 import { Readable, Transform } from "node:stream";
 import { pipeline } from "node:stream/promises";
 import { isTimingEnabled, timingLog } from "./timing.js";
-// Mirrors the server-side caps: per-artifact 1 GiB (video/deviceLog/appiumLog),
+// Mirrors the server-side caps: per-artifact 1 GiB (video/deviceLog/appiumLog/seleniumLog),
 // 4 GiB cumulative across a single download batch.
-export const ARTIFACT_KINDS = ["video", "deviceLog", "appiumLog"];
+export const ARTIFACT_KINDS = ["video", "deviceLog", "appiumLog", "seleniumLog"];
 export const PER_ARTIFACT_CAP_BYTES = 1 * 1024 * 1024 * 1024;
 export const CUMULATIVE_CAP_BYTES = 4 * 1024 * 1024 * 1024;
 export const DOWNLOAD_TIMEOUT_MS = 10 * 60 * 1000;
@@ -14,6 +14,7 @@ const KIND_DEFAULT_FILENAMES = {
     video: "video.mp4",
     deviceLog: "device.log",
     appiumLog: "appium.log",
+    seleniumLog: "selenium.log",
 };
 function normalizeKinds(kinds) {
     if (kinds == null || kinds === "all") {
@@ -24,8 +25,11 @@ function normalizeKinds(kinds) {
     }
     return [kinds];
 }
-function deriveFileName(kind, url) {
+function deriveFileName(kind, url, indexForKind = 0) {
     const defaultName = KIND_DEFAULT_FILENAMES[kind] || `${kind}.bin`;
+    const suffix = indexForKind > 0 ? `-${indexForKind + 1}` : "";
+    const stemOf = (name) => (name.includes(".") ? name.slice(0, name.lastIndexOf(".")) : name);
+    const extOf = (name) => (name.includes(".") ? name.slice(name.lastIndexOf(".")) : "");
     try {
         const parsed = new URL(url);
         const base = path.basename(parsed.pathname);
@@ -33,14 +37,13 @@ function deriveFileName(kind, url) {
         // Allows extensions like ".logcat" (6 chars) — DF's device-log artifact
         // URLs use that extension and must not be forced to the ".log" default.
         if (/^\.[a-zA-Z0-9]{1,8}$/.test(ext)) {
-            const stem = defaultName.includes(".") ? defaultName.slice(0, defaultName.lastIndexOf(".")) : defaultName;
-            return `${stem}${ext}`;
+            return `${stemOf(defaultName)}${suffix}${ext}`;
         }
     }
     catch {
         // Not a parseable URL — fall back to the default name below.
     }
-    return defaultName;
+    return `${stemOf(defaultName)}${suffix}${extOf(defaultName)}`;
 }
 // Truncates the stream in-place at `cap` bytes: chunks past the cap are
 // dropped (not pushed downstream), so the write stream stops growing while
@@ -118,7 +121,10 @@ perArtifactCapBytes = PER_ARTIFACT_CAP_BYTES, cumulativeCapBytes = CUMULATIVE_CA
     await mkdir(destDir, { recursive: true });
     const summary = [];
     let cumulativeBytes = 0;
+    const kindIndexCounters = new Map();
     for (const artifact of filtered) {
+        const indexForKind = kindIndexCounters.get(artifact.kind) ?? 0;
+        kindIndexCounters.set(artifact.kind, indexForKind + 1);
         if (cumulativeBytes >= cumulativeCapBytes) {
             onNote?.(`WARNING: ${artifact.kind} skipped — cumulative artifact cap (${cumulativeCapBytes} bytes) reached`);
             continue;
@@ -127,7 +133,7 @@ perArtifactCapBytes = PER_ARTIFACT_CAP_BYTES, cumulativeCapBytes = CUMULATIVE_CA
         if (typeof artifact.bytes === "number" && artifact.bytes > perArtifactCap) {
             onNote?.(`WARNING: ${artifact.kind} is ${artifact.bytes} bytes, exceeds the ${perArtifactCap} byte cap and will be truncated`);
         }
-        const fileName = deriveFileName(artifact.kind, artifact.presignedGetUrl);
+        const fileName = deriveFileName(artifact.kind, artifact.presignedGetUrl, indexForKind);
         const filePath = path.join(destDir, fileName);
         const downloadStartedAt = Date.now();
         timingLog(`download start: kind=${artifact.kind} url=${artifact.presignedGetUrl}`);

package/build/src/device/cloud/loadmill-cloud/control-plane-client.js

@@ -1,7 +1,11 @@
 import { randomUUID } from "node:crypto";
 import { readFile } from "node:fs/promises";
 const DEFAULT_BASE_URL = "https://app.loadmill.com";
-const MOBILE_TESTING_PATH = "/mobile-testing-cloud/v1";
+const POOL_API_PATHS = {
+    mobile: "/mobile-testing-cloud/v1",
+    web: "/web-testing-cloud/v1",
+};
+const DEFAULT_POOL = "mobile";
 const LOADMILL_CLIENT_HEADER_VALUE = "cli";
 const DEFAULT_REQUEST_TIMEOUT_MS = 30_000;
 // The binary PUT carries the actual app file (tens to low-hundreds of MB) and needs a
@@ -13,7 +17,14 @@ const POLL_FALLBACK_INTERVAL_MS = 3_000;
 const SSE_RETRY_INTERVAL_MS = 5_000;
 // Server sends a `: ping` keepalive every 25s; treat total silence this long as a wedged connection.
 const SSE_IDLE_TIMEOUT_MS = 60_000;
-// This control plane mounts at /mobile-testing-cloud/v1, not under /api — do not append /api.
+export function apiPathForPool(pool) {
+    const apiPath = POOL_API_PATHS[pool];
+    if (!apiPath) {
+        throw new Error(`Unknown Loadmill Cloud pool: ${pool}. Expected "mobile" or "web".`);
+    }
+    return apiPath;
+}
+// Each pool's control plane mounts at its own top-level path, not under /api — do not append /api.
 function normalizeApiBaseUrl(rawBaseUrl) {
     const candidate = (rawBaseUrl || DEFAULT_BASE_URL).trim();
     if (!candidate) {
@@ -67,20 +78,23 @@ async function buildResponseError(response) {
 }
 export class LoadmillCloudControlPlaneClient {
     /**
-     * @param {{ bearerToken: string, baseUrl?: string, requestTimeoutMs?: number, uploadTimeoutMs?: number }} [options]
+     * @param {{ bearerToken: string, baseUrl?: string, pool?: "mobile" | "web", apiPath?: string, requestTimeoutMs?: number, uploadTimeoutMs?: number }} [options]
      */
-    constructor({ bearerToken, baseUrl, requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS, uploadTimeoutMs = DEFAULT_UPLOAD_TIMEOUT_MS, } = {}) {
+    constructor({ bearerToken, baseUrl, pool = DEFAULT_POOL, apiPath, requestTimeoutMs = DEFAULT_REQUEST_TIMEOUT_MS, uploadTimeoutMs = DEFAULT_UPLOAD_TIMEOUT_MS, } = {}) {
         if (!bearerToken || typeof bearerToken !== "string" || !bearerToken.trim()) {
             throw new Error("LoadmillCloudControlPlaneClient requires a bearerToken.");
         }
+        const poolApiPath = apiPathForPool(pool);
         this.bearerToken = bearerToken.trim();
         this.baseUrl = normalizeApiBaseUrl(baseUrl);
+        this.pool = pool;
+        this.apiPath = apiPath ?? poolApiPath;
         this.requestTimeoutMs = requestTimeoutMs;
         this.uploadTimeoutMs = uploadTimeoutMs;
         this._heartbeatTimer = null;
     }
     _url(pathSuffix) {
-        return `${this.baseUrl}${MOBILE_TESTING_PATH}${pathSuffix}`;
+        return `${this.baseUrl}${this.apiPath}${pathSuffix}`;
     }
     _authHeaders(extra = {}) {
         return {
@@ -136,6 +150,9 @@ export class LoadmillCloudControlPlaneClient {
         });
     }
     async registerApp(sessionId, { sha256, platform, fileName }) {
+        if (this.pool === "web") {
+            throw new Error("Loadmill Cloud web runs do not register an app — the web control plane has no /runs/:sessionId/app route.");
+        }
         return this._request(`/runs/${encodeURIComponent(sessionId)}/app`, {
             method: "POST",
             body: { sha256, platform, fileName },
@@ -176,6 +193,9 @@ export class LoadmillCloudControlPlaneClient {
     async heartbeat(sessionId, { signal } = {}) {
         return this._request(`/runs/${encodeURIComponent(sessionId)}/heartbeat`, { method: "POST", signal });
     }
+    async refreshWebdriverEndpoint(sessionId) {
+        return this._request(`/runs/${encodeURIComponent(sessionId)}/endpoint/refresh`, { method: "POST" });
+    }
     async getRunState(sessionId) {
         return this._request(`/runs/${encodeURIComponent(sessionId)}`);
     }

package/build/src/device/cloud/loadmill-cloud/errors.js

@@ -1,10 +1,25 @@
 export const LOADMILL_CLOUD_USAGE_LIMIT_ERROR_CODES = new Set([
     "mobile_testing_day_minute_quota_exceeded",
     "mobile_testing_week_minute_quota_exceeded",
+    "mobile_testing_month_minute_quota_exceeded",
     "mobile_testing_fixed_budget_minute_quota_exceeded",
     "mobile_testing_concurrency_exceeded",
     "mobile_testing_rate_limit_exceeded",
+    "loadmill_cloud_web_day_minute_quota_exceeded",
+    "loadmill_cloud_web_week_minute_quota_exceeded",
+    "loadmill_cloud_web_month_minute_quota_exceeded",
+    "loadmill_cloud_web_fixed_budget_minute_quota_exceeded",
+    "loadmill_cloud_web_concurrency_exceeded",
+    "loadmill_cloud_web_rate_limit_exceeded",
 ]);
+export const LOADMILL_CLOUD_NOT_ENTITLED_ERROR_CODES = new Set([
+    "mobile_testing_cloud_not_allowed",
+    "loadmill_cloud_web_not_allowed",
+]);
+const LOADMILL_CLOUD_NOT_ENTITLED_PRODUCT_NAMES = {
+    mobile_testing_cloud_not_allowed: "Loadmill Cloud mobile testing",
+    loadmill_cloud_web_not_allowed: "Loadmill Cloud web testing",
+};
 export function isLoadmillCloudUsageLimitError(err) {
     if (!err || typeof err !== "object") {
         return false;
@@ -14,3 +29,13 @@ export function isLoadmillCloudUsageLimitError(err) {
     }
     return err.status === 429 && err.type === "rate_limit_error";
 }
+export function isLoadmillCloudNotEntitledError(err) {
+    if (!err || typeof err !== "object") {
+        return false;
+    }
+    return typeof err.code === "string" && LOADMILL_CLOUD_NOT_ENTITLED_ERROR_CODES.has(err.code);
+}
+export function formatLoadmillCloudNotEntitledMessage(err) {
+    const product = LOADMILL_CLOUD_NOT_ENTITLED_PRODUCT_NAMES[err?.code] ?? "Loadmill Cloud";
+    return `Your team is not entitled to ${product}. Contact Loadmill support to enable it.`;
+}