botium-core 1.14.10 → 1.15.3

package/dist/botium-es.js

@@ -27,20 +27,20 @@ import yaml from 'yaml';
 import child_process from 'child_process';
 import socket from 'socket.io-client';
 import bottleneck from 'bottleneck';
-import request from 'request';
 import mustache from 'mustache';
 import mimeTypes from 'mime-types';
 import ioredis from 'ioredis';
+import undici from 'undici';
 import express from 'express';
 import bodyParser from 'body-parser';
 
 var name = "botium-core";
-var version$1 = "1.14.10";
+var version$1 = "1.15.3";
 var description = "The Selenium for Chatbots";
 var main = "index.js";
 var module = "dist/botium-es.js";
 var engines = {
-	node: ">=14.0.0"
+	node: ">=18.17"
 };
 var scripts = {
 	postinstall: "node ./report.js",
@@ -89,7 +89,6 @@ var dependencies = {
 	"promise-retry": "^2.0.1",
 	"promise.allsettled": "^1.0.7",
 	randomatic: "^3.1.1",
-	request: "^2.88.2",
 	rimraf: "^5.0.5",
 	"sanitize-filename": "^1.6.3",
 	slugify: "^1.6.6",
@@ -99,6 +98,7 @@ var dependencies = {
 	"swagger-jsdoc": "^6.2.8",
 	"swagger-ui-express": "^5.0.0",
 	tinyglobby: "^0.2.10",
+	undici: "^6.21.0",
 	uuid: "^9.0.1",
 	"word-error-rate": "0.0.7",
 	"write-yaml": "^1.0.0",
@@ -122,7 +122,7 @@ var devDependencies = {
 	"eslint-plugin-promise": "^6.1.1",
 	"eslint-plugin-standard": "^4.1.0",
 	mocha: "^10.3.0",
-	nock: "^13.5.1",
+	nock: "^14.0.0-beta.19",
 	"npm-check-updates": "^16.14.15",
 	nyc: "^15.1.0",
 	rollup: "2.79.1",
@@ -225,6 +225,7 @@ var Capabilities = {
   SIMPLEREST_HEADERS_TEMPLATE: 'SIMPLEREST_HEADERS_TEMPLATE',
   SIMPLEREST_BODY_TEMPLATE: 'SIMPLEREST_BODY_TEMPLATE',
   SIMPLEREST_BODY_RAW: 'SIMPLEREST_BODY_RAW',
+  SIMPLEREST_BODY_FROM_JSON: 'SIMPLEREST_BODY_FROM_JSON',
   SIMPLEREST_START_HOOK: 'SIMPLEREST_START_HOOK',
   SIMPLEREST_STOP_HOOK: 'SIMPLEREST_STOP_HOOK',
   SIMPLEREST_REQUEST_HOOK: 'SIMPLEREST_REQUEST_HOOK',
@@ -302,6 +303,8 @@ var Capabilities = {
   SCRIPTING_CSV_UTTERANCE_STARTROW_HEADER: 'SCRIPTING_CSV_UTTERANCE_STARTROW_HEADER',
   SCRIPTING_CSV_UTTERANCE_STOP_ON_EMPTY: 'SCRIPTING_CSV_UTTERANCE_STOP_ON_EMPTY',
   SCRIPTING_NORMALIZE_TEXT: 'SCRIPTING_NORMALIZE_TEXT',
+  SCRIPTING_NORMALIZE_TEXT_REMOVE_CHARACTERES: 'SCRIPTING_NORMALIZE_TEXT_REMOVE_CHARACTERES',
+  SCRIPTING_NORMALIZE_TEXT_REMOVE_REGEXP: 'SCRIPTING_NORMALIZE_TEXT_REMOVE_REGEXP',
   SCRIPTING_ENABLE_MEMORY: 'SCRIPTING_ENABLE_MEMORY',
   SCRIPTING_ENABLE_MULTIPLE_ASSERT_ERRORS: 'SCRIPTING_ENABLE_MULTIPLE_ASSERT_ERRORS',
   SCRIPTING_ENABLE_SKIP_ASSERT_ERRORS: 'SCRIPTING_ENABLE_SKIP_ASSERT_ERRORS',
@@ -400,6 +403,7 @@ Capabilities.SIMPLEREST_VERB;
 Capabilities.SIMPLEREST_HEADERS_TEMPLATE;
 Capabilities.SIMPLEREST_BODY_TEMPLATE;
 Capabilities.SIMPLEREST_BODY_RAW;
+Capabilities.SIMPLEREST_BODY_FROM_JSON;
 Capabilities.SIMPLEREST_START_HOOK;
 Capabilities.SIMPLEREST_STOP_HOOK;
 Capabilities.SIMPLEREST_REQUEST_HOOK;
@@ -472,6 +476,8 @@ Capabilities.SCRIPTING_CSV_UTTERANCE_STARTROW;
 Capabilities.SCRIPTING_CSV_UTTERANCE_STARTROW_HEADER;
 Capabilities.SCRIPTING_CSV_UTTERANCE_STOP_ON_EMPTY;
 Capabilities.SCRIPTING_NORMALIZE_TEXT;
+Capabilities.SCRIPTING_NORMALIZE_TEXT_REMOVE_CHARACTERES;
+Capabilities.SCRIPTING_NORMALIZE_TEXT_REMOVE_REGEXP;
 Capabilities.SCRIPTING_ENABLE_MEMORY;
 Capabilities.SCRIPTING_ENABLE_MULTIPLE_ASSERT_ERRORS;
 Capabilities.SCRIPTING_ENABLE_SKIP_ASSERT_ERRORS;
@@ -1544,7 +1550,31 @@ const {
   E_SCRIPTING_MEMORY_COLUMN_MODE: E_SCRIPTING_MEMORY_COLUMN_MODE$1
 } = Enums;
 const WHITE_SPACES_EXCEPT_SPACE_CHAR_AT_THE_END = /[\n\t\r]+$/;
-const normalizeText$1 = (str, doCleanup) => {
+const normalizeText$1 = (str, doCleanupOrCaps) => {
+  // TODO testlog
+  debug$m('yxc1', doCleanupOrCaps);
+  let basic;
+  let charactersRemove = false;
+  let regexpRemove = false;
+  if (lodash.isBoolean(doCleanupOrCaps) || lodash.isNil(doCleanupOrCaps)) {
+    debug$m('Normalize text: backward compatibility mode. Use caps instead of boolean flag');
+    basic = !!doCleanupOrCaps;
+  } else {
+    const caps = doCleanupOrCaps;
+    basic = !!caps[Capabilities.SCRIPTING_NORMALIZE_TEXT];
+    if (caps[Capabilities.SCRIPTING_NORMALIZE_TEXT_REMOVE_CHARACTERES]) {
+      charactersRemove = caps[Capabilities.SCRIPTING_NORMALIZE_TEXT_REMOVE_CHARACTERES];
+      if (lodash.isString(charactersRemove)) {
+        const splitted = charactersRemove.split(/(?<!\/),/).map(e => e.trim()).map(e => e.split('/,').join(',').split('//').join('/')).filter(c => c.length > 0);
+        charactersRemove = splitted.length ? splitted : [charactersRemove];
+      } else if (!lodash.isArray(charactersRemove)) {
+        charactersRemove = false;
+      }
+    }
+    if (caps[Capabilities.SCRIPTING_NORMALIZE_TEXT_REMOVE_REGEXP]) {
+      regexpRemove = new RegExp(caps[Capabilities.SCRIPTING_NORMALIZE_TEXT_REMOVE_REGEXP], 'ug');
+    }
+  }
   if (str && lodash.isArray(str)) {
     str = str.join(' ');
   } else if (str && !lodash.isString(str)) {
@@ -1554,21 +1584,31 @@ const normalizeText$1 = (str, doCleanup) => {
       str = `${str}`;
     }
   }
-  if (str && doCleanup) {
-    // remove html tags
-    str = str.replace(/<p[^>]*>/g, ' ');
-    str = str.replace(/<\/p>/g, ' ');
-    str = str.replace(/<br[^>]*>/g, ' ');
-    str = str.replace(/<[^>]*>/g, '');
-    /* eslint-disable no-control-regex */
-    // remove not printable characters
-    str = str.replace(/[\x00-\x1F\x7F]/g, ' ');
-    /* eslint-enable no-control-regex */
-    // replace html entities
-    str = str.replace(/&amp;/g, '&').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&#39;/g, '\'').replace(/&quot;/g, '"');
-    // replace two spaces with one
-    str = str.replace(/\s+/g, ' ');
-    str = str.split('\n').map(s => s.trim()).join('\n').trim();
+  if (str) {
+    if (basic) {
+      // remove html tags
+      str = str.replace(/<p[^>]*>/g, ' ');
+      str = str.replace(/<\/p>/g, ' ');
+      str = str.replace(/<br[^>]*>/g, ' ');
+      str = str.replace(/<[^>]*>/g, '');
+      /* eslint-disable no-control-regex */
+      // remove not printable characters
+      str = str.replace(/[\x00-\x1F\x7F]/g, ' ');
+      /* eslint-enable no-control-regex */
+      // replace html entities
+      str = str.replace(/&amp;/g, '&').replace(/&lt;/g, '<').replace(/&gt;/g, '>').replace(/&#39;/g, '\'').replace(/&quot;/g, '"');
+      // replace two spaces with one
+      str = str.replace(/\s+/g, ' ');
+      str = str.split('\n').map(s => s.trim()).join('\n').trim();
+    }
+    if (charactersRemove) {
+      for (const character of charactersRemove) {
+        str = str.split(character).join('');
+      }
+    }
+    if (regexpRemove) {
+      str = str.replace(regexpRemove, '');
+    }
   }
   return str;
 };
@@ -3306,7 +3346,8 @@ class Convo$6 {
                 scriptingMemory,
                 botMsg,
                 transcript,
-                transcriptStep
+                transcriptStep,
+                transcriptSteps
               });
               await this.scriptingEvents.onBotEnd({
                 convo: this,
@@ -3532,7 +3573,7 @@ class Convo$6 {
     return tomatch;
   }
   _checkNormalizeText(container, str) {
-    return normalizeText(str, !!container.caps[Capabilities.SCRIPTING_NORMALIZE_TEXT]);
+    return normalizeText(str, container.caps);
   }
   expandPartialConvos() {
     const _getIncludeLogicHookNames = convoStep => {
@@ -7595,7 +7636,7 @@ var BaseContainer_1 = class BaseContainer {
     try {
       await executeHook$1(this.caps, hook, Object.assign({
         container: this,
-        request
+        fetch
       }, args));
     } catch (err) {
       debug$7(`_RunCustomHook ${name} finished with error: ${err.message || util.inspect(err)}`);
@@ -7882,6 +7923,10 @@ const {
   v4: uuidv4
 } = uuid;
 const debug$4 = debug$o('botium-connector-simplerest');
+const {
+  ProxyAgent,
+  Agent
+} = undici;
 const {
   startProxy
 } = proxy;
@@ -7958,6 +8003,16 @@ var SimpleRestContainer_1 = class SimpleRestContainer {
     }
   }
   Build() {
+    const agentOptions = {
+      connect: {
+        rejectUnauthorized: !!this.caps[Capabilities.SIMPLEREST_STRICT_SSL] // Equivalent to strictSSL of request module
+      }
+    };
+    if (this.caps[Capabilities.SIMPLEREST_PROXY_URL]) {
+      this.dispatcher = new ProxyAgent(this.caps[Capabilities.SIMPLEREST_PROXY_URL], agentOptions);
+    } else {
+      this.dispatcher = new Agent(agentOptions);
+    }
     return this._buildInbound();
   }
   Start() {
@@ -8098,6 +8153,27 @@ var SimpleRestContainer_1 = class SimpleRestContainer {
   Clean() {
     return this._cleanInbound();
   }
+  _fetchify(requestOptions) {
+    requestOptions.signal = AbortSignal.timeout(requestOptions.timeout);
+    delete requestOptions.timeout;
+    if (requestOptions.body && !lodash.isString(requestOptions.body)) {
+      requestOptions.body = JSON.stringify(requestOptions.body);
+      if (!requestOptions.headers) requestOptions.headers = {};
+      if (!requestOptions.headers['Content-Type'] && !requestOptions.headers['content-type']) {
+        requestOptions.headers['Content-Type'] = 'application/json';
+      }
+    }
+    if (requestOptions.form) {
+      if (requestOptions.body) {
+        debug$4('Request.form and request.body are mutually exclusive');
+      }
+      requestOptions.body = new URLSearchParams(requestOptions.form).toString();
+      // it is set automatically by fetch
+      // requestOptions.headers['Content-Type'] = 'application/x-www-form-urlencoded'
+      delete requestOptions.form;
+    }
+    return requestOptions;
+  }
 
   // Separated just for better module testing
   async _processBodyAsync(body, headers, isFromUser, updateContext) {
@@ -8368,12 +8444,25 @@ var SimpleRestContainer_1 = class SimpleRestContainer {
       msg.sourceData = msg.sourceData || {};
       msg.sourceData.requestOptions = requestOptions;
       this.waitProcessQueue = [];
-      request(requestOptions, async (err, response, body) => {
-        if (err) {
-          return reject(new Error(`rest request failed: ${err.message}`));
-        } else {
-          if (response.statusCode >= 400) {
-            debug$4(`got error response: ${response.statusCode}/${response.statusMessage}`);
+      try {
+        fetch(requestOptions.uri, requestOptions).then(async bodyRaw => {
+          let body;
+          try {
+            if (bodyRaw.headers.get('content-type').includes('application/json')) {
+              try {
+                body = await bodyRaw.json();
+              } catch (err) {
+                body = await bodyRaw.text();
+                debug$4(`failed to parse body as text, using text instead: ${body}`);
+              }
+            } else {
+              body = await bodyRaw.text();
+            }
+          } catch (err) {
+            return reject(new Error(`cant parse body: ${err.message}`));
+          }
+          if (!bodyRaw.ok) {
+            debug$4(`got error response: ${bodyRaw.status}/${bodyRaw.statusText}`);
             if (debug$4.enabled && body) {
               debug$4(Utils.shortenJsonString(body));
             }
@@ -8381,38 +8470,42 @@ var SimpleRestContainer_1 = class SimpleRestContainer {
               const jsonBody = Utils.toJsonWeak(body);
               const errKey = Object.keys(jsonBody).find(k => k.startsWith('err') || k.startsWith('fail'));
               if (errKey) {
-                return reject(new BotiumError(`got error response: ${response.statusCode}/${response.statusMessage} - ${jsonBody[errKey]}`, {
+                return reject(new BotiumError(`got error response: ${bodyRaw.status}/${bodyRaw.statusText} - ${jsonBody[errKey]}`, {
                   message: Utils.shortenJsonString(body)
                 }));
               }
             }
-            return reject(new Error(`got error response: ${response.statusCode}/${response.statusMessage}`));
+            return reject(new Error(`got error response: ${bodyRaw.status}/${bodyRaw.statusText}`));
           }
           if (body) {
-            debug$4(`got response code: ${response.statusCode}, body: ${Utils.shortenJsonString(body)}, headers: ${Utils.shortenJsonString(response.headers)}`);
-            this._storeCookiesFromResponse(response);
-            try {
-              body = await this._parseResponseBody(body);
-            } catch (err) {
+            debug$4(`got response code: ${bodyRaw.status}/${bodyRaw.statusText}, body: ${Utils.shortenJsonString(body)}, headers: ${Utils.shortenJsonString(bodyRaw.headers)}`);
+            this._storeCookiesFromResponse(bodyRaw);
+            this._parseResponseBody(body).then(parsedBody => {
+              body = parsedBody;
+              if (body) {
+                this._processBodyAsync(body, bodyRaw.headers, isFromUser, updateContext).then(() => resolve(this)).then(() => this._emptyWaitProcessQueue());
+              } else {
+                debug$4('ignoring response body (no string and no JSON object)');
+                resolve(this);
+                this._emptyWaitProcessQueue();
+              }
+            }).catch(err => {
               debug$4(`ignoring not JSON formatted response body: ${err.message}`);
               resolve(this);
               this._emptyWaitProcessQueue();
-              return;
-            }
-            if (body) {
-              this._processBodyAsync(body, response.headers, isFromUser, updateContext).then(() => resolve(this)).then(() => this._emptyWaitProcessQueue());
-            } else {
-              debug$4('ignoring response body (no string and no JSON object)');
-              resolve(this);
-              this._emptyWaitProcessQueue();
-            }
+            });
           } else {
-            debug$4(`got response code: ${response.statusCode}, empty body`);
+            debug$4(`got response code: ${bodyRaw.status}/${bodyRaw.statusText}, empty body`);
             resolve(this);
             this._emptyWaitProcessQueue();
           }
-        }
-      });
+        }).catch(err => {
+          // rest request failed: fetch failed - Cause code: ECONNREFUSED - Cause message: connect ECONNREFUSED 127.0.0.1:3006
+          return reject(new Error(`rest request failed: ${err.message}${err.cause && err.cause.code ? ' - Cause code: ' + err.cause.code : ''}${err.cause && err.cause.message ? ' - Cause message: ' + err.cause.message : ''}`));
+        });
+      } catch (err) {
+        return reject(new Error(`rest request failed: ${err.message}`));
+      }
     }));
   }
   async _buildRequest(msg) {
@@ -8429,7 +8522,6 @@ var SimpleRestContainer_1 = class SimpleRestContainer {
     const requestOptions = {
       uri,
       method: this._getCapValue(Capabilities.SIMPLEREST_VERB) || this._getCapValue(Capabilities.SIMPLEREST_METHOD),
-      followAllRedirects: true,
       timeout
     };
     if (this.caps[Capabilities.SIMPLEREST_HEADERS_TEMPLATE]) {
@@ -8440,7 +8532,14 @@ var SimpleRestContainer_1 = class SimpleRestContainer {
         throw new Error(`composing headers from SIMPLEREST_HEADERS_TEMPLATE failed (${err.message})`);
       }
     }
-    if (this.caps[Capabilities.SIMPLEREST_BODY_TEMPLATE]) {
+    // It is possible to mix json, and non-json request messages. So it can happen that both
+    // SIMPLEREST_BODY_FROM_JSON and SIMPLEREST_BODY_TEMPLATE are set
+    if (this.caps[Capabilities.SIMPLEREST_BODY_FROM_JSON] && msg.sourceData && Object.keys(msg.sourceData).length > 0) {
+      requestOptions.body = msg.sourceData;
+      requestOptions.json = true;
+      if (!requestOptions.headers) requestOptions.headers = {};
+      requestOptions.headers['Content-Type'] = 'application/json';
+    } else if (this.caps[Capabilities.SIMPLEREST_BODY_TEMPLATE]) {
       const bodyRaw = this._getCapValue(Capabilities.SIMPLEREST_BODY_RAW);
       if (bodyRaw) {
         this.view.msg.messageText = nonEncodedMessage;
@@ -8453,6 +8552,10 @@ var SimpleRestContainer_1 = class SimpleRestContainer {
         if (requestOptions.json && (!requestOptions.body || Object.keys(requestOptions.body).length === 0)) {
           debug$4(`warning: requestOptions.body content seems to be empty - ${requestOptions.body} - capability: "${this.caps[Capabilities.SIMPLEREST_BODY_TEMPLATE]}"`);
         }
+        if (!bodyRaw) {
+          if (!requestOptions.headers) requestOptions.headers = {};
+          requestOptions.headers['Content-Type'] = 'application/json';
+        }
       } catch (err) {
         throw new Error(`composing body from SIMPLEREST_BODY_TEMPLATE failed (${err.message})`);
       }
@@ -8486,56 +8589,53 @@ var SimpleRestContainer_1 = class SimpleRestContainer {
       }
     }
     this._addRequestOptions(requestOptions);
+    this._fetchify(requestOptions);
     await executeHook(this.caps, this.requestHook, Object.assign({
       requestOptions
     }, this.view));
     this._addRequestCookies(requestOptions);
     return requestOptions;
   }
-  async _waitForUrlResponse(pingConfig, retries) {
+  async _waitForUrlResponse(httpConfig, retries) {
     const timeout = ms => new Promise(resolve => setTimeout(resolve, ms));
     let tries = 0;
     while (true) {
-      debug$4(`_waitForUrlResponse checking url ${pingConfig.uri} before proceed`);
+      debug$4(`_waitForUrlResponse checking url ${httpConfig.uri} before proceed`);
       if (tries > retries) {
         throw new Error(`Failed to ping bot after ${retries} retries`);
       }
       tries++;
-      const {
-        err,
-        response,
-        body
-      } = await this.bottleneck(() => new Promise(resolve => {
-        request(pingConfig, (err, response, body) => {
-          resolve({
-            err,
-            response,
-            body
-          });
-        });
-      }));
+      let bodyRaw;
+      let body;
+      let err;
+      try {
+        bodyRaw = await this.bottleneck(() => fetch(httpConfig.uri, httpConfig));
+        body = await (httpConfig.json ? bodyRaw.json() : bodyRaw.text());
+      } catch (e) {
+        err = e;
+      }
       if (err) {
-        debug$4(`_waitForUrlResponse error on url check ${pingConfig.uri}: ${err}`);
+        debug$4(`_waitForUrlResponse error on url check ${httpConfig.uri}: ${err}`);
         if (tries <= retries) {
-          await timeout(pingConfig.timeout);
+          await timeout(httpConfig.timeout);
         }
-      } else if (response.statusCode >= 400) {
-        debug$4(`_waitForUrlResponse on url check ${pingConfig.uri} got error response: ${response.statusCode}/${response.statusMessage}`);
+      } else if (!bodyRaw.ok) {
+        debug$4(`_waitForUrlResponse on url check ${httpConfig.uri} got error response: ${bodyRaw.status}/${bodyRaw.statusText}`);
         if (debug$4.enabled && body) {
           debug$4(Utils.shortenJsonString(body));
         }
         if (tries <= retries) {
-          await timeout(pingConfig.timeout);
+          await timeout(httpConfig.timeout);
         }
       } else {
-        debug$4(`_waitForUrlResponse success on url check ${pingConfig.uri}: ${response.statusCode}/${response.statusMessage}`);
-        this._storeCookiesFromResponse(response);
+        debug$4(`_waitForUrlResponse success on url check ${httpConfig.uri}: ${bodyRaw.status}/${bodyRaw.statusText}`);
+        this._storeCookiesFromResponse(bodyRaw);
         if (debug$4.enabled && body) {
-          debug$4(`body: ${Utils.shortenJsonString(body)}, headers: ${Utils.shortenJsonString(response.headers)}`);
+          debug$4(`body: ${Utils.shortenJsonString(body)}, headers: ${Utils.shortenJsonString(bodyRaw.headers)}`);
         }
         return {
           body,
-          headers: response.headers
+          headers: bodyRaw.headers
         };
       }
     }
@@ -8687,7 +8787,6 @@ var SimpleRestContainer_1 = class SimpleRestContainer {
       const pollConfig = {
         method: verb,
         uri,
-        followAllRedirects: true,
         timeout
       };
       if (this.caps[Capabilities.SIMPLEREST_POLL_HEADERS]) {
@@ -8703,12 +8802,17 @@ var SimpleRestContainer_1 = class SimpleRestContainer {
         try {
           pollConfig.body = this._getMustachedCap(Capabilities.SIMPLEREST_POLL_BODY, !bodyRaw);
           pollConfig.json = !bodyRaw;
+          if (!bodyRaw) {
+            if (!pollConfig.headers) pollConfig.headers = {};
+            pollConfig.headers['Content-Type'] = 'application/json';
+          }
         } catch (err) {
           debug$4(`_runPolling: composing body from SIMPLEREST_POLL_BODY failed (${err.message})`);
           return;
         }
       }
       this._addRequestOptions(pollConfig);
+      this._fetchify(pollConfig);
       try {
         await executeHook(this.caps, this.pollRequestHook, Object.assign({
           requestOptions: pollConfig
@@ -8718,34 +8822,34 @@ var SimpleRestContainer_1 = class SimpleRestContainer {
         return;
       }
       this._addRequestCookies(pollConfig);
-      request(pollConfig, async (err, response, body) => {
-        if (err) {
-          debug$4(`_runPolling: rest request failed: ${err.message}, request: ${JSON.stringify(pollConfig)}`);
-        } else {
-          if (response.statusCode >= 400) {
-            debug$4(`_runPolling: got error response: ${response.statusCode}/${response.statusMessage}, request: ${JSON.stringify(pollConfig)}`);
-            if (debug$4.enabled && body) {
-              debug$4(Utils.shortenJsonString(body));
-            }
-          } else if (body) {
-            debug$4(`_runPolling: got response code: ${response.statusCode}, body: ${Utils.shortenJsonString(body)}, headers: ${Utils.shortenJsonString(response.headers)}`);
-            this._storeCookiesFromResponse(response);
-            try {
-              body = await this._parseResponseBody(body);
-            } catch (err) {
-              debug$4(`_runPolling: ignoring not JSON formatted response body: ${err.message}`);
-              return;
-            }
-            if (body) {
-              setTimeout(() => this._processBodyAsync(body, response.headers, true, !!this.caps[Capabilities.SIMPLEREST_POLL_UPDATE_CONTEXT]), 0);
-            } else {
-              debug$4('_runPolling: ignoring response body (no string and no JSON object)');
-            }
+      try {
+        const bodyRaw = await fetch(pollConfig.uri, pollConfig);
+        let body = await (pollConfig.json ? bodyRaw.json() : bodyRaw.text());
+        if (!bodyRaw.ok) {
+          debug$4(`_runPolling: got error response: ${bodyRaw.status}/${bodyRaw.statusText}, request: ${JSON.stringify(pollConfig)}`);
+          if (debug$4.enabled && body) {
+            debug$4(Utils.shortenJsonString(body));
+          }
+        } else if (body) {
+          debug$4(`_runPolling: got response code: ${bodyRaw.status}/${bodyRaw.statusText}, body: ${Utils.shortenJsonString(body)}, headers: ${Utils.shortenJsonString(bodyRaw.headers)}`);
+          this._storeCookiesFromResponse(bodyRaw);
+          try {
+            body = await this._parseResponseBody(body);
+          } catch (err) {
+            debug$4(`_runPolling: ignoring not JSON formatted response body: ${err.message}`);
+            return;
+          }
+          if (body) {
+            setTimeout(() => this._processBodyAsync(body, bodyRaw.headers, true, !!this.caps[Capabilities.SIMPLEREST_POLL_UPDATE_CONTEXT]), 0);
           } else {
-            debug$4(`_runPolling: got response code: ${response.statusCode}, empty body`);
+            debug$4('_runPolling: ignoring response body (no string and no JSON object)');
           }
+        } else {
+          debug$4(`_runPolling: got response code: ${bodyRaw.status}/${bodyRaw.statusText}, empty body`);
         }
-      });
+      } catch (err) {
+        debug$4(`_runPolling: rest request failed: ${err.message}, request: ${JSON.stringify(pollConfig)}`);
+      }
     }
   }
   async _startPolling() {
@@ -8768,7 +8872,6 @@ var SimpleRestContainer_1 = class SimpleRestContainer {
     const httpConfig = {
       method: verb,
       uri,
-      followAllRedirects: true,
       timeout
     };
     if (this.caps[`${capPrefix}_HEADERS`]) {
@@ -8788,6 +8891,7 @@ var SimpleRestContainer_1 = class SimpleRestContainer {
       }
     }
     this._addRequestOptions(httpConfig);
+    this._fetchify(httpConfig);
     await executeHook(this.caps, this.requestHooks[capPrefix], Object.assign({
       requestOptions: httpConfig
     }, this.view));
@@ -8798,9 +8902,8 @@ var SimpleRestContainer_1 = class SimpleRestContainer {
     return response;
   }
   _addRequestOptions(httpConfig) {
-    httpConfig.strictSSL = !!this.caps[Capabilities.SIMPLEREST_STRICT_SSL];
-    if (this.caps[Capabilities.SIMPLEREST_PROXY_URL]) {
-      httpConfig.proxy = this.caps[Capabilities.SIMPLEREST_PROXY_URL];
+    if (this.dispatcher) {
+      httpConfig.dispatcher = this.dispatcher;
     }
     if (this.caps[Capabilities.SIMPLEREST_EXTRA_OPTIONS]) {
       lodash.merge(httpConfig, this.caps[Capabilities.SIMPLEREST_EXTRA_OPTIONS]);
@@ -8814,23 +8917,21 @@ var SimpleRestContainer_1 = class SimpleRestContainer {
     if (!requestOptions.headers) {
       requestOptions.headers = {};
     }
-    requestOptions.headers.Cookie = requestOptions.headers.Cookie ? `${requestOptions.headers.Cookie}; ${this.cookies[url.host]}` : this.cookies[url.host];
+    if (this.cookies[url.host]) {
+      requestOptions.headers.Cookie = requestOptions.headers.Cookie ? `${requestOptions.headers.Cookie}; ${this.cookies[url.host]}` : this.cookies[url.host];
+    }
   }
   _storeCookiesFromResponse(response) {
     if (!this.caps[Capabilities.SIMPLEREST_COOKIE_REPLICATION] || !response) {
       return;
     }
-    const responseCookies = response.headers['set-cookie'];
+    const responseCookies = response.headers.get('set-cookie');
     if (!responseCookies) {
       return;
     }
-    const host = lodash.get(response, 'request.uri.host');
-    let cookie;
-    responseCookies.forEach(cookieString => {
-      cookie = cookie ? `${cookie}; ${cookieString}` : cookieString;
-    });
-    if (cookie) {
-      this.cookies[host] = cookie;
+    const host = response?.url ? new URL(response.url).host : null;
+    if (host) {
+      this.cookies[host] = responseCookies;
     }
   }
 };