botium-core 1.14.10 → 1.15.3

package/dist/botium-cjs.js

@@ -31,10 +31,10 @@ var yaml = require('yaml');
 var child_process = require('child_process');
 var socket = require('socket.io-client');
 var bottleneck = require('bottleneck');
-var request = require('request');
 var mustache = require('mustache');
 var mimeTypes = require('mime-types');
 var ioredis = require('ioredis');
+var undici = require('undici');
 var express = require('express');
 var bodyParser = require('body-parser');
 
@@ -69,20 +69,20 @@ var yaml__default = /*#__PURE__*/_interopDefaultLegacy(yaml);
 var child_process__default = /*#__PURE__*/_interopDefaultLegacy(child_process);
 var socket__default = /*#__PURE__*/_interopDefaultLegacy(socket);
 var bottleneck__default = /*#__PURE__*/_interopDefaultLegacy(bottleneck);
-var request__default = /*#__PURE__*/_interopDefaultLegacy(request);
 var mustache__default = /*#__PURE__*/_interopDefaultLegacy(mustache);
 var mimeTypes__default = /*#__PURE__*/_interopDefaultLegacy(mimeTypes);
 var ioredis__default = /*#__PURE__*/_interopDefaultLegacy(ioredis);
+var undici__default = /*#__PURE__*/_interopDefaultLegacy(undici);
 var express__default = /*#__PURE__*/_interopDefaultLegacy(express);
 var bodyParser__default = /*#__PURE__*/_interopDefaultLegacy(bodyParser);
 
 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$1 = "dist/botium-es.js";
 var engines = {
-	node: ">=14.0.0"
+	node: ">=18.17"
 };
 var scripts = {
 	postinstall: "node ./report.js",
@@ -131,7 +131,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",
@@ -141,6 +140,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",
@@ -164,7 +164,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",
@@ -267,6 +267,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',
@@ -344,6 +345,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',
@@ -442,6 +445,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;
@@ -514,6 +518,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;
@@ -1586,7 +1592,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__default["default"].isBoolean(doCleanupOrCaps) || lodash__default["default"].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__default["default"].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__default["default"].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__default["default"].isArray(str)) {
     str = str.join(' ');
   } else if (str && !lodash__default["default"].isString(str)) {
@@ -1596,21 +1626,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;
 };
@@ -3348,7 +3388,8 @@ class Convo$6 {
                 scriptingMemory,
                 botMsg,
                 transcript,
-                transcriptStep
+                transcriptStep,
+                transcriptSteps
               });
               await this.scriptingEvents.onBotEnd({
                 convo: this,
@@ -3574,7 +3615,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 => {
@@ -7637,7 +7678,7 @@ var BaseContainer_1 = class BaseContainer {
     try {
       await executeHook$1(this.caps, hook, Object.assign({
         container: this,
-        request: request__default["default"]
+        fetch
       }, args));
     } catch (err) {
       debug$7(`_RunCustomHook ${name} finished with error: ${err.message || util__default["default"].inspect(err)}`);
@@ -7924,6 +7965,10 @@ const {
   v4: uuidv4
 } = uuid__default["default"];
 const debug$4 = debug__default["default"]('botium-connector-simplerest');
+const {
+  ProxyAgent,
+  Agent
+} = undici__default["default"];
 const {
   startProxy
 } = proxy;
@@ -8000,6 +8045,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() {
@@ -8140,6 +8195,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__default["default"].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) {
@@ -8410,12 +8486,25 @@ var SimpleRestContainer_1 = class SimpleRestContainer {
       msg.sourceData = msg.sourceData || {};
       msg.sourceData.requestOptions = requestOptions;
       this.waitProcessQueue = [];
-      request__default["default"](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));
             }
@@ -8423,38 +8512,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) {
@@ -8471,7 +8564,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]) {
@@ -8482,7 +8574,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;
@@ -8495,6 +8594,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})`);
       }
@@ -8528,56 +8631,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__default["default"](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
         };
       }
     }
@@ -8729,7 +8829,6 @@ var SimpleRestContainer_1 = class SimpleRestContainer {
       const pollConfig = {
         method: verb,
         uri,
-        followAllRedirects: true,
         timeout
       };
       if (this.caps[Capabilities.SIMPLEREST_POLL_HEADERS]) {
@@ -8745,12 +8844,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
@@ -8760,34 +8864,34 @@ var SimpleRestContainer_1 = class SimpleRestContainer {
         return;
       }
       this._addRequestCookies(pollConfig);
-      request__default["default"](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() {
@@ -8810,7 +8914,6 @@ var SimpleRestContainer_1 = class SimpleRestContainer {
     const httpConfig = {
       method: verb,
       uri,
-      followAllRedirects: true,
       timeout
     };
     if (this.caps[`${capPrefix}_HEADERS`]) {
@@ -8830,6 +8933,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));
@@ -8840,9 +8944,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__default["default"].merge(httpConfig, this.caps[Capabilities.SIMPLEREST_EXTRA_OPTIONS]);
@@ -8856,23 +8959,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__default["default"].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;
     }
   }
 };