@applitools/nml-client 1.11.12 → 1.11.14

package/CHANGELOG.md

@@ -1,5 +1,36 @@
 # Changelog
 
+## [1.11.14](https://github.com/Applitools-Dev/sdk/compare/js/nml-client@1.11.13...js/nml-client@1.11.14) (2026-01-11)
+
+
+### Bug Fixes
+
+* nml broker retry mechanism | FLD-3968 FLD-3963 FLD-3950 ([#3430](https://github.com/Applitools-Dev/sdk/issues/3430)) ([42617e0](https://github.com/Applitools-Dev/sdk/commit/42617e021f43a89f8a8f2cb914f489ac8d215714))
+
+
+### Dependencies
+
+* @applitools/driver bumped to 1.24.4
+  #### Bug Fixes
+
+  * scrolling element fallback logic | FLD-3959 ([#3442](https://github.com/Applitools-Dev/sdk/issues/3442)) ([36348b4](https://github.com/Applitools-Dev/sdk/commit/36348b46e6a127c99d4ccfa58bf386a8e414fb40))
+* @applitools/spec-driver-webdriver bumped to 1.5.4
+
+* @applitools/core-base bumped to 1.31.1
+  #### Bug Fixes
+
+  * per-API key heartbeat management | FLD-3889 ([#3406](https://github.com/Applitools-Dev/sdk/issues/3406)) ([5d7f380](https://github.com/Applitools-Dev/sdk/commit/5d7f38037f17006dcc923c4a3dc925e8dded25d8))
+
+## [1.11.13](https://github.com/Applitools-Dev/sdk/compare/js/nml-client@1.11.12...js/nml-client@1.11.13) (2025-12-14)
+
+
+### Dependencies
+
+* @applitools/core-base bumped to 1.31.0
+  #### Features
+
+  * Baseline branch fallback list | FLD-3837 ([#3373](https://github.com/Applitools-Dev/sdk/issues/3373)) ([e94bb10](https://github.com/Applitools-Dev/sdk/commit/e94bb10ad6b49322a56e4ce6dfde560b237e9ac0))
+
 ## [1.11.12](https://github.com/Applitools-Dev/sdk/compare/js/nml-client@1.11.11...js/nml-client@1.11.12) (2025-12-01)
 
 

package/dist/server/req-broker.js

@@ -26,6 +26,24 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.makeReqBroker = void 0;
 const req_1 = __importStar(require("@applitools/req"));
 const utils = __importStar(require("@applitools/utils"));
+function isInvalidBrokerMessage(result) {
+    try {
+        const parsedResult = JSON.parse(result);
+        // Bare empty arrays indicate result is not ready yet
+        if (Array.isArray(parsedResult) && parsedResult.length === 0)
+            return true;
+        // Check objects with empty payload arrays
+        if (parsedResult && typeof parsedResult === 'object' && !Array.isArray(parsedResult)) {
+            const { payload } = parsedResult;
+            if (Array.isArray(payload) && payload.length === 0)
+                return true;
+        }
+        return false;
+    }
+    catch {
+        return true; // unparsable response is equivalent to empty one
+    }
+}
 function makeReqBroker({ settings, logger }) {
     return (0, req_1.makeReq)({
         method: 'POST',
@@ -63,34 +81,106 @@ function handleLogs({ logger: defaultLogger } = {}) {
         },
     };
 }
+/**
+ * Creates a custom fetch function that buffers polling responses to work around node-fetch clone bug.
+ *
+ * node-fetch 3.x has a bug where cloning a response after reading its body results in
+ * empty clones. Since polling requests use retry validation that reads the body AND
+ * have afterResponse hooks that also read the body, we need to buffer BEFORE retry
+ * validation runs. We do this by wrapping the fetch function itself.
+ *
+ * See: js/packages/nml-client/docs/NODE_FETCH_CLONE_BUG.md for full investigation details
+ */
+function makeBufferingFetch() {
+    return async (input, init) => {
+        // Use globalReq to fetch, forwarding all options (proxy, headers, etc.)
+        // Pass init directly to preserve proxy settings and other options
+        const response = await (0, req_1.default)(input, init);
+        // Buffer the body once
+        const bufferedBody = await response.text();
+        // Create fresh Response with buffered string (not stream)
+        const bufferedResponse = new req_1.Response(bufferedBody, {
+            status: response.status,
+            statusText: response.statusText,
+            headers: response.headers,
+        });
+        // Monkey-patch .text() and .json() to return from buffered string
+        // WITHOUT consuming the Response body. This is critical because:
+        // 1. Retry validation calls .text() to check for empty payloads
+        // 2. Then hooks/caller call .json() to parse the result
+        // 3. Calling .text() normally consumes the body, breaking .json()
+        bufferedResponse.text = async () => bufferedBody;
+        bufferedResponse.json = async () => JSON.parse(bufferedBody);
+        // Also patch .clone() to return responses with the same monkey-patched methods
+        const originalClone = bufferedResponse.clone.bind(bufferedResponse);
+        bufferedResponse.clone = () => {
+            const cloned = originalClone();
+            cloned.text = async () => bufferedBody;
+            cloned.json = async () => JSON.parse(bufferedBody);
+            return cloned;
+        };
+        return bufferedResponse;
+    };
+}
 function handleLongRequests({ req, logger: defaultLogger }) {
     return {
         async afterResponse({ request, response, options }) {
+            var _a;
             if (response.status === 200) {
+                let attemptCount = 0;
+                const MAX_ATTEMPTS = 1500;
+                const logger = (_a = options === null || options === void 0 ? void 0 : options.logger) !== null && _a !== void 0 ? _a : defaultLogger;
+                // Use custom fetch that buffers responses to work around node-fetch clone bug
+                const bufferingFetch = makeBufferingFetch();
                 return req(request.url + '-response', {
                     proxy: options === null || options === void 0 ? void 0 : options.proxy,
-                    retry: {
-                        // 1500 attempts x 200 ms = 5 minutes
-                        limit: 1500,
-                        timeout: 200,
-                        statuses: [404],
-                    },
+                    fetch: bufferingFetch,
+                    retry: [
+                        {
+                            // 1500 attempts x 200 ms = 5 minutes
+                            limit: MAX_ATTEMPTS,
+                            timeout: 200,
+                            statuses: [404],
+                        },
+                        {
+                            limit: MAX_ATTEMPTS,
+                            timeout: 200,
+                            validate: async ({ response }) => {
+                                if (!response || response.status !== 200)
+                                    return false;
+                                try {
+                                    const body = await response.clone().text();
+                                    const isInvalid = isInvalidBrokerMessage(body);
+                                    if (isInvalid) {
+                                        logger === null || logger === void 0 ? void 0 : logger.log(`Broker polling request "${options === null || options === void 0 ? void 0 : options.name}" received empty response, retrying (attempt ${attemptCount + 1}/${MAX_ATTEMPTS})`);
+                                    }
+                                    return isInvalid;
+                                }
+                                catch (error) {
+                                    return false;
+                                }
+                            },
+                        },
+                    ],
                     hooks: [
                         {
                             beforeRequest({ request, options: beforeOptions }) {
-                                var _a;
-                                const logger = (_a = options === null || options === void 0 ? void 0 : options.logger) !== null && _a !== void 0 ? _a : defaultLogger;
-                                logger === null || logger === void 0 ? void 0 : logger.log(`Broker polling request "${options === null || options === void 0 ? void 0 : options.name}" will be sent to the address "[${request.method}]${request.url}" with body`, beforeOptions === null || beforeOptions === void 0 ? void 0 : beforeOptions.body);
+                                attemptCount++;
+                                logger === null || logger === void 0 ? void 0 : logger.log(`Broker polling request "${options === null || options === void 0 ? void 0 : options.name}" attempt #${attemptCount}/${MAX_ATTEMPTS} will be sent to the address "[${request.method}]${request.url}" with body`, beforeOptions === null || beforeOptions === void 0 ? void 0 : beforeOptions.body);
                             },
                             async afterResponse({ request, response }) {
-                                var _a;
-                                const logger = (_a = options === null || options === void 0 ? void 0 : options.logger) !== null && _a !== void 0 ? _a : defaultLogger;
-                                logger === null || logger === void 0 ? void 0 : logger.log(`Broker polling request "${options === null || options === void 0 ? void 0 : options.name}" that was sent to the address "[${request.method}]${request.url}" respond with ${response.statusText}(${response.status})`, response.status !== 200 ? `and body ${JSON.stringify(await response.clone().text())}` : '');
+                                try {
+                                    const body = await response.clone().text();
+                                    logger === null || logger === void 0 ? void 0 : logger.log(`Broker polling request "${options === null || options === void 0 ? void 0 : options.name}" attempt #${attemptCount}/${MAX_ATTEMPTS} that was sent to the address "[${request.method}]${request.url}" respond with ${response.statusText}(${response.status}) with body ${JSON.stringify(body)}`);
+                                }
+                                catch (error) {
+                                    logger === null || logger === void 0 ? void 0 : logger.log(`Broker polling request "${options === null || options === void 0 ? void 0 : options.name}" attempt #${attemptCount}/${MAX_ATTEMPTS} that was sent to the address "[${request.method}]${request.url}" respond with ${response.statusText}(${response.status})`);
+                                }
                             },
                             afterError({ request, error }) {
                                 var _a;
                                 const logger = (_a = options === null || options === void 0 ? void 0 : options.logger) !== null && _a !== void 0 ? _a : defaultLogger;
-                                logger === null || logger === void 0 ? void 0 : logger.error(`Broker polling request "${options === null || options === void 0 ? void 0 : options.name}" that was sent to the address "[${request.method}]${request.url}" failed with error`, error);
+                                logger === null || logger === void 0 ? void 0 : logger.error(`Broker polling request "${options === null || options === void 0 ? void 0 : options.name}" attempt #${attemptCount}/${MAX_ATTEMPTS} that was sent to the address "[${request.method}]${request.url}" failed with error`, error);
                             },
                         },
                     ],
@@ -105,21 +195,22 @@ function handleUnexpectedResponse() {
             if (response.status !== 200) {
                 throw new Error(`Something went wrong when communicating with the mobile application, please try running your test again (error code: ${response.status})`);
             }
-            else {
-                const body = await response.text();
-                const result = JSON.parse(body);
-                if (result === null || result === void 0 ? void 0 : result.payload) {
-                    const error = utils.types.isArray(result.payload)
-                        ? result.payload.find(payload => payload.error)
-                        : result.payload.error;
-                    if (error) {
-                        const nmlError = new Error(`There was a problem when interacting with the mobile application. The provided error message was "${error.message}" and had a stack trace of "${error.stack}"`);
-                        nmlError.nextPath = result.nextPath;
-                        throw nmlError;
-                    }
+            const body = await response.clone().text();
+            if (!body) {
+                return response;
+            }
+            const result = JSON.parse(body);
+            if (result === null || result === void 0 ? void 0 : result.payload) {
+                const error = utils.types.isArray(result.payload)
+                    ? result.payload.find(payload => payload.error)
+                    : result.payload.error;
+                if (error) {
+                    const nmlError = new Error(`There was a problem when interacting with the mobile application. The provided error message was "${error.message}" and had a stack trace of "${error.stack}"`);
+                    nmlError.nextPath = result.nextPath;
+                    throw nmlError;
                 }
-                return { response, body };
             }
+            return response;
         },
     };
 }

package/dist/server/requests.js

@@ -81,7 +81,7 @@ function makeNMLRequests({ settings, logger: mainLogger, }) {
         brokerUrl = result.nextPath;
     }
     async function takeScreenshots({ settings, logger = mainLogger, }) {
-        var _a, _b;
+        var _a;
         logger = logger.extend(mainLogger, { tags: [`nml-request-${utils.general.shortid()}`] });
         logger.log('Request "takeScreenshots" called with settings', settings);
         const { localEnvironment, renderEnvironments, environmentSettings } = await (0, get_environments_info_1.getNMLEnvironmentsInfo)({
@@ -114,32 +114,35 @@ function makeNMLRequests({ settings, logger: mainLogger, }) {
             let screenshots;
             if (Number(result.protocolVersion) >= 2) {
                 logger.log(`Request "takeScreenshots" was performed on applitools lib v${result.nmlVersion} through protocol v${result.protocolVersion} on device`, result.payload.debugInfo);
-                if ((_b = result.payload.result) === null || _b === void 0 ? void 0 : _b.some((res) => res.error)) {
-                    const errors = result.payload.result.filter((res) => res.error);
-                    let errMessage = 'There were problems in taking screenshots for';
-                    if (localEnvironment) {
-                        errMessage += ` local environment ${JSON.stringify(localEnvironment)}:\n`;
-                        errMessage += `\t ${JSON.stringify(errors)}`;
-                    }
-                    else {
-                        errMessage += ' environments:';
-                        errMessage += ` \n\t ${errors
-                            .map((err, index) => `Environment ${JSON.stringify(renderEnvironments[index])}: ${JSON.stringify(err)}`)
-                            .join('\n\t')}`;
+                // Note: Payload-level errors (payload.error) are already handled by req-broker.ts afterResponse hook
+                if (localEnvironment) {
+                    if (result.payload.result[0].error) {
+                        throw new Error(`There was a problem in taking screenshot for local environment ${JSON.stringify(localEnvironment)}. The provided error message was "${result.payload.result[0].error.message}" and had a stack trace of "${result.payload.result[0].error.stack}"`);
                     }
-                    throw new Error(errMessage);
+                    screenshots = [
+                        {
+                            image: result.payload.result[0].result.screenshotUrl,
+                            calculateRegions: result.payload.result[0].result.selectorRegions,
+                            dom: result.payload.result[0].result.dom,
+                            environment: localEnvironment,
+                        },
+                    ];
+                }
+                else {
+                    screenshots = renderEnvironments.map((environment, index) => {
+                        if (result.payload.result[index].error) {
+                            throw new Error(`There was a problem in taking screenshot for environment ${JSON.stringify(environment)}. The provided error message was "${result.payload.result[index].error.message}" and had a stack trace of "${result.payload.result[index].error.stack}"`);
+                        }
+                        return {
+                            image: result.payload.result[index].result.screenshotUrl,
+                            calculateRegions: result.payload.result[index].result.selectorRegions,
+                            dom: result.payload.result[index].result.dom,
+                            environment,
+                        };
+                    });
                 }
-                screenshots = renderEnvironments.map((environment, index) => {
-                    return {
-                        image: result.payload.result[index].result.screenshotUrl,
-                        calculateRegions: result.payload.result[index].result.selectorRegions,
-                        dom: result.payload.result[index].result.dom,
-                        environment: localEnvironment || environment,
-                    };
-                });
-                if (localEnvironment && renderEnvironments.length > 1) {
-                    logger.warn(`Local environment detected with ${renderEnvironments.length} rendered environment(s). Using local environment ${JSON.stringify(localEnvironment)} and ignoring rendered environments: ${JSON.stringify(renderEnvironments)}. Note - this warning shouldn't appear in normal usage.`);
-                    screenshots = [screenshots[0]];
+                if (localEnvironment && renderEnvironments.length > 0) {
+                    logger.warn(`Local environment detected with ${renderEnvironments.length} rendered environment(s). Using local environment and ignoring rendered environments: ${JSON.stringify(renderEnvironments)}. Note - this warning shouldn't appear in normal usage.`);
                 }
             }
             else {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@applitools/nml-client",
-  "version": "1.11.12",
+  "version": "1.11.14",
   "description": "Client to integrate the SDKs to the Native Mobile Library (NML)",
   "homepage": "https://applitools.com",
   "bugs": {
@@ -41,8 +41,8 @@
     "@applitools/utils": "1.14.1"
   },
   "devDependencies": {
-    "@applitools/core-base": "1.30.1",
-    "@applitools/spec-driver-webdriver": "^1.5.3",
+    "@applitools/core-base": "1.31.1",
+    "@applitools/spec-driver-webdriver": "^1.5.4",
     "@applitools/test-server": "^1.3.5",
     "@applitools/test-utils": "^1.5.17",
     "@types/node": "^12.20.55",
@@ -50,7 +50,7 @@
     "webdriver": "^7.31.1"
   },
   "peerDependencies": {
-    "@applitools/core-base": "1.30.1"
+    "@applitools/core-base": "1.31.1"
   },
   "engines": {
     "node": ">=12.13.0"

package/types/server/req-broker.d.ts

@@ -1,6 +1,6 @@
 import type { BrokerServerSettings } from '../types';
-import { type Logger } from '@applitools/logger';
-import { type Req, type Options } from '@applitools/req';
+import type { Logger } from '@applitools/logger';
+import type { Req, Options } from '@applitools/req';
 export type ReqBrokerOptions = Options & {
     name: string;
     body: {