botium-core 1.13.19 → 1.14.1

package/dist/botium-cjs.js

@@ -15,7 +15,6 @@ var lodash = require('lodash');
 var boolean$1 = require('boolean');
 var events = require('events');
 var debug$n = require('debug');
-var vm2 = require('vm2');
 var isClass = require('is-class');
 var crypto = require('crypto');
 var globby = require('globby');
@@ -25,7 +24,6 @@ var uuid = require('uuid');
 var jsonpath = require('jsonpath');
 var isJson$1 = require('is-json');
 var wordErrorRate = require('word-error-rate');
-var esprima = require('esprima');
 var markdownIt = require('markdown-it');
 var xlsx = require('xlsx');
 var sync = require('csv-parse/sync');
@@ -55,7 +53,6 @@ var lodash__default = /*#__PURE__*/_interopDefaultLegacy(lodash);
 var boolean__default = /*#__PURE__*/_interopDefaultLegacy(boolean$1);
 var events__default = /*#__PURE__*/_interopDefaultLegacy(events);
 var debug__default = /*#__PURE__*/_interopDefaultLegacy(debug$n);
-var vm2__default = /*#__PURE__*/_interopDefaultLegacy(vm2);
 var isClass__default = /*#__PURE__*/_interopDefaultLegacy(isClass);
 var crypto__default = /*#__PURE__*/_interopDefaultLegacy(crypto);
 var globby__default = /*#__PURE__*/_interopDefaultLegacy(globby);
@@ -65,7 +62,6 @@ var uuid__default = /*#__PURE__*/_interopDefaultLegacy(uuid);
 var jsonpath__default = /*#__PURE__*/_interopDefaultLegacy(jsonpath);
 var isJson__default = /*#__PURE__*/_interopDefaultLegacy(isJson$1);
 var wordErrorRate__default = /*#__PURE__*/_interopDefaultLegacy(wordErrorRate);
-var esprima__default = /*#__PURE__*/_interopDefaultLegacy(esprima);
 var markdownIt__default = /*#__PURE__*/_interopDefaultLegacy(markdownIt);
 var xlsx__default = /*#__PURE__*/_interopDefaultLegacy(xlsx);
 var sync__default = /*#__PURE__*/_interopDefaultLegacy(sync);
@@ -81,7 +77,7 @@ var express__default = /*#__PURE__*/_interopDefaultLegacy(express);
 var bodyParser__default = /*#__PURE__*/_interopDefaultLegacy(bodyParser);
 
 var name = "botium-core";
-var version$1 = "1.13.19";
+var version$1 = "1.14.1";
 var description = "The Selenium for Chatbots";
 var main = "index.js";
 var module$1 = "dist/botium-es.js";
@@ -99,7 +95,6 @@ var scripts = {
 	link: "npm link botium-connector-dialogflow botium-connector-webdriverio botium-connector-directline3 botium-connector-watson botium-connector-alexa-smapi botium-connector-echo",
 	test: "cross-env NODE_PATH=\"./test/plugins/plugindir/fromfolder:./test/plugins/plugindir/fromfile:./test/security/resources\" mocha \"./test/**/*.spec.js\"",
 	"coverage:report": "nyc report --reporter=lcov npm test",
-	"license-checker": "license-checker > LICENSES-3RDPARTY.txt",
 	"update-dependencies": "npm-check-updates --reject globby,rollup -u --timeout 120000"
 };
 var repository = {
@@ -113,14 +108,13 @@ var bugs = {
 };
 var homepage = "https://www.botium.ai";
 var dependencies = {
-	"@babel/runtime": "^7.21.5",
-	async: "^3.2.4",
+	"@babel/runtime": "^7.23.2",
+	async: "^3.2.5",
 	"body-parser": "^1.20.2",
 	boolean: "^3.2.0",
 	bottleneck: "^2.19.5",
-	"csv-parse": "^5.3.10",
+	"csv-parse": "^5.5.2",
 	debug: "^4.3.4",
-	esprima: "^4.0.1",
 	express: "^4.18.2",
 	globby: "11.0.4",
 	ioredis: "^5.3.2",
@@ -128,52 +122,49 @@ var dependencies = {
 	"is-json": "^2.0.1",
 	jsonpath: "^1.1.1",
 	lodash: "^4.17.21",
-	"markdown-it": "^13.0.1",
+	"markdown-it": "^13.0.2",
 	"mime-types": "^2.1.35",
 	mkdirp: "^3.0.1",
 	moment: "^2.29.4",
 	"moment-timezone": "^0.5.43",
 	mustache: "^4.2.0",
 	"promise-retry": "^2.0.1",
-	"promise.allsettled": "^1.0.6",
+	"promise.allsettled": "^1.0.7",
 	randomatic: "^3.1.1",
 	request: "^2.88.2",
-	rimraf: "^5.0.0",
+	rimraf: "^5.0.5",
 	"sanitize-filename": "^1.6.3",
 	slugify: "^1.6.6",
-	"socket.io": "^4.6.1",
-	"socket.io-client": "^4.6.1",
+	"socket.io": "^4.7.2",
+	"socket.io-client": "^4.7.2",
 	"socketio-auth": "^0.1.1",
 	"swagger-jsdoc": "^6.2.8",
-	"swagger-ui-express": "^4.6.3",
-	uuid: "^9.0.0",
-	vm2: "^3.9.17",
+	"swagger-ui-express": "^5.0.0",
+	uuid: "^9.0.1",
 	"word-error-rate": "0.0.7",
 	"write-yaml": "^1.0.0",
 	xlsx: "^0.18.5",
 	xregexp: "^5.1.1",
-	yaml: "^2.2.2"
+	yaml: "^2.3.4"
 };
 var devDependencies = {
-	"@babel/core": "^7.21.8",
-	"@babel/node": "^7.20.7",
-	"@babel/plugin-transform-runtime": "^7.21.4",
-	"@babel/preset-env": "^7.21.5",
-	chai: "^4.3.7",
+	"@babel/core": "^7.23.3",
+	"@babel/node": "^7.22.19",
+	"@babel/plugin-transform-runtime": "^7.23.3",
+	"@babel/preset-env": "^7.23.3",
+	chai: "^4.3.10",
 	"chai-as-promised": "^7.1.1",
 	"cross-env": "^7.0.3",
-	eslint: "^8.40.0",
-	"eslint-config-standard": "^17.0.0",
-	"eslint-plugin-import": "^2.27.5",
-	"eslint-plugin-mocha": "^10.1.0",
-	"eslint-plugin-n": "^15.7.0",
+	eslint: "^8.53.0",
+	"eslint-config-standard": "^17.1.0",
+	"eslint-plugin-import": "^2.29.0",
+	"eslint-plugin-mocha": "^10.2.0",
+	"eslint-plugin-n": "^16.3.1",
 	"eslint-plugin-promise": "^6.1.1",
 	"eslint-plugin-standard": "^4.1.0",
-	"license-checker": "^25.0.1",
-	"license-compatibility-checker": "^0.3.5",
 	mocha: "^10.2.0",
-	nock: "^13.3.1",
-	"npm-check-updates": "^16.10.12",
+	nock: "^13.3.8",
+	"npm-check-updates": "^16.14.6",
 	nyc: "^15.1.0",
 	rollup: "2.79.1",
 	"rollup-plugin-babel": "^4.4.0",
@@ -222,6 +213,7 @@ var Capabilities = {
   TESTSESSIONNAME: 'TESTSESSIONNAME',
   TESTCASENAME: 'TESTCASENAME',
   TEMPDIR: 'TEMPDIR',
+  SAFEDIR: 'SAFEDIR',
   CLEANUPTEMPDIR: 'CLEANUPTEMPDIR',
   WAITFORBOTTIMEOUT: 'WAITFORBOTTIMEOUT',
   CONTAINERMODE: 'CONTAINERMODE',
@@ -231,7 +223,7 @@ var Capabilities = {
   BOTIUMGRIDURL: 'BOTIUMGRIDURL',
   BOTIUMAPITOKEN: 'BOTIUMAPITOKEN',
   BOTIUMGRIDSLOT: 'BOTIUMGRIDSLOT',
-  // Simple Reset Bot Settings
+  // Simple Rest Bot Settings
   SIMPLEREST_PING_URL: 'SIMPLEREST_PING_URL',
   SIMPLEREST_PING_VERB: 'SIMPLEREST_PING_VERB',
   SIMPLEREST_PING_BODY: 'SIMPLEREST_PING_BODY',
@@ -396,6 +388,7 @@ Capabilities.PROJECTNAME;
 Capabilities.TESTSESSIONNAME;
 Capabilities.TESTCASENAME;
 Capabilities.TEMPDIR;
+Capabilities.SAFEDIR;
 Capabilities.CLEANUPTEMPDIR;
 Capabilities.WAITFORBOTTIMEOUT;
 Capabilities.CONTAINERMODE;
@@ -914,140 +907,6 @@ function getCjsExportFromNamespace (n) {
 	return n && n['default'] || n;
 }
 
-const BotiumError$7 = class BotiumError extends Error {
-  /**
-   *
-   * @param message
-   * @param context A JSON with struct
-   * {
-   *   type: 'some free text to identity the exception type',
-   *   source: 'source of the event',
-   *   ...
-   */
-  constructor(message, context, supressChildCheck) {
-    super(message.message || message);
-    if (!supressChildCheck && _getChildErrorsFromContext(context)) {
-      throw Error('Create BotiumError with child errors using the fromList() method!');
-    }
-    // Saving class name in the property of our custom error as a shortcut.
-    this.name = this.constructor.name;
-
-    // Capturing stack trace, excluding constructor call from it.
-    Error.captureStackTrace(this, this.constructor);
-    this.context = context || {};
-    this.context.message = message.message || message;
-  }
-  isAsserterError() {
-    if (this.context) {
-      const errArr = lodash__default["default"].isArray(this.context) ? this.context : [this.context];
-      const hasNotAsserterError = errArr.findIndex(errDetail => {
-        if (errDetail.type === 'list') {
-          if (errDetail.errors) {
-            return errDetail.errors.findIndex(e => e.type !== 'asserter') >= 0;
-          } else {
-            return true;
-          }
-        } else {
-          return errDetail.type !== 'asserter';
-        }
-      }) >= 0;
-      if (hasNotAsserterError) return false;
-      return true;
-    } else {
-      return false;
-    }
-  }
-  prettify(includeJson) {
-    const lines = [];
-    if (this.context) {
-      const errArr = lodash__default["default"].isArray(this.context) ? this.context : [this.context];
-      errArr.forEach(errDetail => {
-        lines.push('########################################');
-        if (errDetail.type === 'asserter') {
-          const segments = [];
-          segments.push(`ASSERTION FAILED in ${errDetail.source}${errDetail.subtype ? ` (${errDetail.subtype})` : ''}`);
-          errDetail.cause && errDetail.cause.expected && !errDetail.cause.not && segments.push(` - Expected: ${JSON.stringify(errDetail.cause.expected)} `);
-          errDetail.cause && errDetail.cause.expected && errDetail.cause.not && segments.push(` - NOT Expected: ${JSON.stringify(errDetail.cause.expected)} `);
-          errDetail.cause && errDetail.cause.actual && segments.push(` - Actual: ${JSON.stringify(errDetail.cause.actual)}`);
-          errDetail.cause && !errDetail.cause.actual && segments.push(' - Actual: empty');
-          lines.push(segments.join(''));
-          errDetail.input && errDetail.input.messageText && lines.push(`INPUT: ${errDetail.input.messageText}`);
-        } else if (errDetail.message) {
-          lines.push(`${errDetail.message}`);
-        }
-        if (errDetail.transcript && errDetail.transcript.length > 0) {
-          lines.push('------------ TRANSCRIPT ----------------------------');
-          errDetail.transcript.forEach(transcriptStep => {
-            if (transcriptStep.actual) {
-              lines.push(transcriptStep.actual.prettify());
-            }
-          });
-        }
-        if (includeJson) {
-          lines.push('------------ JSON CONTENT ----------------------------');
-          try {
-            const jsonOutput = JSON.stringify(errDetail);
-            lines.push(jsonOutput);
-          } catch (jsonErr) {
-            lines.push(`JSON Output not possible: ${jsonErr.message}`);
-          }
-        }
-      });
-    }
-    if (lines.length > 0) {
-      return lines.join('\r\n');
-    } else {
-      return null;
-    }
-  }
-};
-const _getChildErrorsFromContext = context => {
-  if (context && context.errors && lodash__default["default"].isArray(context.errors)) {
-    return context.errors;
-  }
-  return false;
-};
-const botiumErrorFromErr$2 = (message, err) => {
-  if (err instanceof BotiumError$7) {
-    return new BotiumError$7(message, err.context, true);
-  } else {
-    return new BotiumError$7(message, {
-      err
-    }, true);
-  }
-};
-const botiumErrorFromList$2 = (errors, {
-  type = 'list',
-  source = 'BotiumError',
-  flat = true
-}) => {
-  const message = errors.map(err => err.message || err.toString()).join(',\n');
-  let children = [];
-  for (const error of errors) {
-    if (error instanceof BotiumError$7) {
-      const childErrors = flat && _getChildErrorsFromContext(error.context);
-      if (childErrors && childErrors.length) {
-        children = children.concat(childErrors);
-      } else if (error.context) {
-        children.push(error.context);
-      }
-    } else {
-      children.push(error);
-    }
-  }
-  const result = new BotiumError$7(message, {
-    errors: children,
-    type,
-    source
-  }, true);
-  return result;
-};
-var BotiumError_1 = {
-  BotiumError: BotiumError$7,
-  botiumErrorFromErr: botiumErrorFromErr$2,
-  botiumErrorFromList: botiumErrorFromList$2
-};
-
 const LOGIC_HOOK_INCLUDE$1 = 'INCLUDE';
 var LogicHookConsts = {
   LOGIC_HOOK_INCLUDE: LOGIC_HOOK_INCLUDE$1,
@@ -1234,13 +1093,7 @@ LogicHookConsts.DEFAULT_ASSERTERS;
 LogicHookConsts.DEFAULT_LOGIC_HOOKS;
 LogicHookConsts.DEFAULT_USER_INPUTS;
 
-const {
-  NodeVM: NodeVM$2
-} = vm2__default["default"];
 const debug$m = debug__default["default"]('botium-core-asserterUtils');
-const {
-  BotiumError: BotiumError$6
-} = BotiumError_1;
 const {
   DEFAULT_ASSERTERS,
   DEFAULT_LOGIC_HOOKS,
@@ -1362,21 +1215,7 @@ var LogicHookUtils_1 = class LogicHookUtils {
         }, this.caps, args);
       }
     }
-    const _checkUnsafe = () => {
-      if (!this.caps[Capabilities.SECURITY_ALLOW_UNSAFE]) {
-        throw new BotiumError$6('Security Error. Using unsafe component is not allowed', {
-          type: 'security',
-          subtype: 'allow unsafe',
-          source: path__default["default"].basename(__filename),
-          cause: {
-            src: !!src,
-            ref,
-            args,
-            hookType
-          }
-        });
-      }
-    };
+    const allowUnsafe = !!this.caps[Capabilities.SECURITY_ALLOW_UNSAFE];
     if (!src) {
       const packageName = `botium-${hookType}-${ref}`;
       try {
@@ -1397,10 +1236,10 @@ var LogicHookUtils_1 = class LogicHookUtils {
             ...this.buildScriptContext
           }, this.caps, args);
         } else {
-          throw new Error(`${packageName} class or function or PluginClass field expected`);
+          throw new Error('Either class or function or PluginClass field expected');
         }
       } catch (err) {
-        throw new Error(`Failed to fetch hook ${ref} ${hookType} from guessed package ${packageName} - ${err.message}`);
+        throw new Error(`Logic Hook specification ${ref} ${hookType} (${packageName}) invalid: ${err.message}`);
       }
     }
     if (isClass__default["default"](src)) {
@@ -1411,7 +1250,7 @@ var LogicHookUtils_1 = class LogicHookUtils {
           ...this.buildScriptContext
         }, this.caps, args);
       } catch (err) {
-        throw new Error(`Failed to load package ${ref} from provided class - ${err.message}`);
+        throw new Error(`Logic Hook specification ${ref} from class invalid: ${err.message}`);
       }
     }
     if (lodash__default["default"].isFunction(src)) {
@@ -1421,7 +1260,7 @@ var LogicHookUtils_1 = class LogicHookUtils {
           ...this.buildScriptContext
         }, this.caps, args);
       } catch (err) {
-        throw new Error(`Failed to load package ${ref} from provided function - ${err.message}`);
+        throw new Error(`Logic Hook specification ${ref} from function invalid: ${err.message}`);
       }
     }
     if (lodash__default["default"].isObject(src) && !lodash__default["default"].isString(src)) {
@@ -1431,26 +1270,15 @@ var LogicHookUtils_1 = class LogicHookUtils {
             const script = src[key];
             if (lodash__default["default"].isFunction(script)) {
               return script(args);
-            } else if (lodash__default["default"].isString(script)) {
-              try {
-                const vm = new NodeVM$2({
-                  eval: false,
-                  require: false,
-                  sandbox: args
-                });
-                return vm.run(script);
-              } catch (err) {
-                throw new Error(`Script ${key} is not valid - ${err.message || err}`);
-              }
             } else {
-              throw new Error(`Script "${key}" is not valid - only functions and javascript code accepted`);
+              throw new Error(`Script ${key} is not valid - only functions accepted`);
             }
           };
           return result;
         }, {});
         return hookObject;
       } catch (err) {
-        throw new Error(`Failed to load package ${ref} ${hookType} from provided src function - ${err.message}`);
+        throw new Error(`Logic Hook specification ${ref} ${hookType} from provided src (${util__default["default"].inspect(src)}) invalid: ${err.message}`);
       }
     }
     if (lodash__default["default"].isString(src)) {
@@ -1461,8 +1289,8 @@ var LogicHookUtils_1 = class LogicHookUtils {
       }];
       if (src.indexOf('/') >= 0) {
         tryLoads.push({
-          tryLoadPackageName: src.substr(0, src.lastIndexOf('/')),
-          tryLoadAsserterByName: src.substr(src.lastIndexOf('/') + 1)
+          tryLoadPackageName: src.substring(0, src.lastIndexOf('/')),
+          tryLoadAsserterByName: src.substring(src.lastIndexOf('/') + 1)
         });
       }
       const tryLoadFromSource = (tryRequire, tryAsserterName) => {
@@ -1500,28 +1328,33 @@ var LogicHookUtils_1 = class LogicHookUtils {
             ...this.buildScriptContext
           }, this.caps, args);
         } else {
-          throw new Error(`${src} class or function expected`);
+          throw new Error('Expected class or function');
         }
       };
       for (const tryLoad of tryLoads) {
-        const tryLoadFile = path__default["default"].resolve(process.cwd(), tryLoad.tryLoadPackageName);
-        if (fs__default["default"].existsSync(tryLoadFile)) {
-          _checkUnsafe();
+        if (this.caps.SAFEDIR) {
+          const tryLoadFile = path__default["default"].resolve(this.caps.SAFEDIR, tryLoad.tryLoadPackageName);
+          if (tryLoadFile.startsWith(path__default["default"].resolve(this.caps.SAFEDIR))) {
+            if (fs__default["default"].existsSync(tryLoadFile)) {
+              try {
+                return tryLoadFromSource(tryLoadFile, tryLoad.tryLoadAsserterByName);
+              } catch (err) {
+                loadErr.push(`Logic Hook specification ${ref} ${hookType} from "${src}" invalid: ${err.message} `);
+              }
+            }
+          }
+        }
+        if (allowUnsafe || tryLoad.tryLoadPackageName.startsWith('botium-')) {
           try {
-            return tryLoadFromSource(tryLoadFile, tryLoad.tryLoadAsserterByName);
+            return tryLoadFromSource(tryLoad.tryLoadPackageName, tryLoad.tryLoadAsserterByName);
           } catch (err) {
-            loadErr.push(`Failed to fetch ${ref} ${hookType} from ${src} - ${err.message} `);
+            loadErr.push(`Logic Hook specification ${ref} ${hookType} from "${src}" invalid: ${err.message} `);
           }
         }
-        try {
-          return tryLoadFromSource(tryLoad.tryLoadPackageName, tryLoad.tryLoadAsserterByName);
-        } catch (err) {
-          loadErr.push(`Failed to fetch ${ref} ${hookType} from ${src} - ${err.message} `);
-        }
       }
       loadErr.forEach(debug$m);
     }
-    throw new Error(`Failed to fetch ${ref} ${hookType}, no idea how to load ...`);
+    throw new Error(`Logic Hook specification ${ref} ${hookType} from "${util__default["default"].inspect(src)}" invalid : no loader available`);
   }
 };
 
@@ -2328,19 +2161,150 @@ var helper = {
   toPercent: toPercent$1
 };
 
+const BotiumError$4 = class BotiumError extends Error {
+  /**
+   *
+   * @param message
+   * @param context A JSON with struct
+   * {
+   *   type: 'some free text to identity the exception type',
+   *   source: 'source of the event',
+   *   ...
+   */
+  constructor(message, context, supressChildCheck) {
+    super(message.message || message);
+    if (!supressChildCheck && _getChildErrorsFromContext(context)) {
+      throw Error('Create BotiumError with child errors using the fromList() method!');
+    }
+    // Saving class name in the property of our custom error as a shortcut.
+    this.name = this.constructor.name;
+
+    // Capturing stack trace, excluding constructor call from it.
+    Error.captureStackTrace(this, this.constructor);
+    this.context = context || {};
+    this.context.message = message.message || message;
+  }
+  isAsserterError() {
+    if (this.context) {
+      const errArr = lodash__default["default"].isArray(this.context) ? this.context : [this.context];
+      const hasNotAsserterError = errArr.findIndex(errDetail => {
+        if (errDetail.type === 'list') {
+          if (errDetail.errors) {
+            return errDetail.errors.findIndex(e => e.type !== 'asserter') >= 0;
+          } else {
+            return true;
+          }
+        } else {
+          return errDetail.type !== 'asserter';
+        }
+      }) >= 0;
+      if (hasNotAsserterError) return false;
+      return true;
+    } else {
+      return false;
+    }
+  }
+  prettify(includeJson) {
+    const lines = [];
+    if (this.context) {
+      const errArr = lodash__default["default"].isArray(this.context) ? this.context : [this.context];
+      errArr.forEach(errDetail => {
+        lines.push('########################################');
+        if (errDetail.type === 'asserter') {
+          const segments = [];
+          segments.push(`ASSERTION FAILED in ${errDetail.source}${errDetail.subtype ? ` (${errDetail.subtype})` : ''}`);
+          errDetail.cause && errDetail.cause.expected && !errDetail.cause.not && segments.push(` - Expected: ${JSON.stringify(errDetail.cause.expected)} `);
+          errDetail.cause && errDetail.cause.expected && errDetail.cause.not && segments.push(` - NOT Expected: ${JSON.stringify(errDetail.cause.expected)} `);
+          errDetail.cause && errDetail.cause.actual && segments.push(` - Actual: ${JSON.stringify(errDetail.cause.actual)}`);
+          errDetail.cause && !errDetail.cause.actual && segments.push(' - Actual: empty');
+          lines.push(segments.join(''));
+          errDetail.input && errDetail.input.messageText && lines.push(`INPUT: ${errDetail.input.messageText}`);
+        } else if (errDetail.message) {
+          lines.push(`${errDetail.message}`);
+        }
+        if (errDetail.transcript && errDetail.transcript.length > 0) {
+          lines.push('------------ TRANSCRIPT ----------------------------');
+          errDetail.transcript.forEach(transcriptStep => {
+            if (transcriptStep.actual) {
+              lines.push(transcriptStep.actual.prettify());
+            }
+          });
+        }
+        if (includeJson) {
+          lines.push('------------ JSON CONTENT ----------------------------');
+          try {
+            const jsonOutput = JSON.stringify(errDetail);
+            lines.push(jsonOutput);
+          } catch (jsonErr) {
+            lines.push(`JSON Output not possible: ${jsonErr.message}`);
+          }
+        }
+      });
+    }
+    if (lines.length > 0) {
+      return lines.join('\r\n');
+    } else {
+      return null;
+    }
+  }
+};
+const _getChildErrorsFromContext = context => {
+  if (context && context.errors && lodash__default["default"].isArray(context.errors)) {
+    return context.errors;
+  }
+  return false;
+};
+const botiumErrorFromErr$2 = (message, err) => {
+  if (err instanceof BotiumError$4) {
+    return new BotiumError$4(message, err.context, true);
+  } else {
+    return new BotiumError$4(message, {
+      err
+    }, true);
+  }
+};
+const botiumErrorFromList$2 = (errors, {
+  type = 'list',
+  source = 'BotiumError',
+  flat = true
+}) => {
+  const message = errors.map(err => err.message || err.toString()).join(',\n');
+  let children = [];
+  for (const error of errors) {
+    if (error instanceof BotiumError$4) {
+      const childErrors = flat && _getChildErrorsFromContext(error.context);
+      if (childErrors && childErrors.length) {
+        children = children.concat(childErrors);
+      } else if (error.context) {
+        children.push(error.context);
+      }
+    } else {
+      children.push(error);
+    }
+  }
+  const result = new BotiumError$4(message, {
+    errors: children,
+    type,
+    source
+  }, true);
+  return result;
+};
+var BotiumError_1 = {
+  BotiumError: BotiumError$4,
+  botiumErrorFromErr: botiumErrorFromErr$2,
+  botiumErrorFromList: botiumErrorFromList$2
+};
+
 const debug$k = debug__default["default"]('botium-core-ScriptingMemory');
 const {
   v1: uuidv1
 } = uuid__default["default"];
-const {
-  NodeVM: NodeVM$1
-} = vm2__default["default"];
 const {
   quoteRegexpString: quoteRegexpString$1,
   toString: toString$2
 } = helper;
 const {
-  BotiumError: BotiumError$5
+  BotiumError: BotiumError$3
 } = BotiumError_1;
 
 // If they got parameter, then it will be a string always.
@@ -2497,28 +2461,6 @@ const SCRIPTING_FUNCTIONS_RAW = {
       if (root && root.length > 0) return root[0];else return '';
     },
     numberOfArguments: 1
-  },
-  $func: {
-    handler: (caps, code) => {
-      if (code == null) {
-        throw Error('func function used without args!');
-      }
-      try {
-        const vm = new NodeVM$1({
-          eval: false,
-          require: false,
-          env: caps[Capabilities.SECURITY_ALLOW_UNSAFE] ? process.env : {},
-          sandbox: {
-            caps,
-            moment: moment__default["default"]
-          }
-        });
-        return vm.run(`module.exports = (${code})`);
-      } catch (err) {
-        throw Error(`func function execution failed - ${err}`);
-      }
-    },
-    numberOfArguments: 1
   }
 };
 const SCRIPTING_FUNCTIONS$1 = lodash__default["default"].mapValues(SCRIPTING_FUNCTIONS_RAW, (funcOrStruct, name) => {
@@ -2527,7 +2469,7 @@ const SCRIPTING_FUNCTIONS$1 = lodash__default["default"].mapValues(SCRIPTING_FUN
   return {
     handler: (caps, ...rest) => {
       if (!caps[Capabilities.SECURITY_ALLOW_UNSAFE] && funcOrStruct.unsafe) {
-        throw new BotiumError$5(`Security Error. Using unsafe scripting memory function ${name} is not allowed`, {
+        throw new BotiumError$3(`Security Error. Using unsafe scripting memory function ${name} is not allowed`, {
           type: 'security',
           subtype: 'allow unsafe',
           source: path__default["default"].basename(__filename),
@@ -2667,7 +2609,7 @@ ScriptingMemory.SCRIPTING_FUNCTIONS;
 
 const debug$j = debug__default["default"]('botium-core-Convo');
 const {
-  BotiumError: BotiumError$4,
+  BotiumError: BotiumError$2,
   botiumErrorFromErr: botiumErrorFromErr$1,
   botiumErrorFromList: botiumErrorFromList$1
 } = BotiumError_1;
@@ -2969,6 +2911,8 @@ class Convo$6 {
       let botMsg = null;
       let waitForBotSays = true;
       let skipTranscriptStep = false;
+      let conditionalGroupId = null;
+      let conditionMetInGroup = false;
       for (let i = 0; i < this.conversation.length; i++) {
         const convoStep = this.conversation[i];
         const currentStepIndex = i;
@@ -3091,7 +3035,6 @@ class Convo$6 {
               throw failErr;
             }
           } else if (convoStep.sender === 'bot') {
-            const previousWaitForBotSays = waitForBotSays;
             if (waitForBotSays) {
               botMsg = null;
             } else {
@@ -3148,24 +3091,40 @@ class Convo$6 {
               throw failErr;
             }
             if (convoStep.conditional) {
-              const nextConvoStep = this.conversation[i + 1];
-              if (!previousWaitForBotSays) {
-                skipTranscriptStep = true;
-              }
               waitForBotSays = false;
+              let endOfConditionalGroup = false;
+              conditionalGroupId = convoStep.logicHooks.find(lh => lh.name.startsWith('CONDITIONAL_STEP')).args[1];
+              const nextConvoStep = this.conversation[i + 1];
               if (!nextConvoStep || nextConvoStep.sender !== 'bot' || !nextConvoStep.logicHooks || !nextConvoStep.logicHooks.some(lh => lh.name.toUpperCase().startsWith('CONDITIONAL_STEP'))) {
-                waitForBotSays = true;
+                endOfConditionalGroup = true;
               } else {
-                const conditionalLogicHook = convoStep.logicHooks.find(lh => lh.name.startsWith('CONDITIONAL_STEP'));
                 const nextConditionalLogicHook = nextConvoStep.logicHooks.find(lh => lh.name.startsWith('CONDITIONAL_STEP'));
-                waitForBotSays = conditionalLogicHook.args[1] !== nextConditionalLogicHook.args[1];
+                endOfConditionalGroup = conditionalGroupId !== nextConditionalLogicHook.args[1];
               }
-              if (convoStep.conditional.skip) {
+              if (convoStep.conditional.skip || conditionMetInGroup) {
+                skipTranscriptStep = true;
+                if (endOfConditionalGroup && !conditionMetInGroup && !convoStep.optional) {
+                  const failErr = new BotiumError$2(`${this.header.name}/${convoStep.stepTag}: Non of the conditions are met in ${conditionalGroupId ? `'${conditionalGroupId}' ` : ''}condition group`);
+                  debug$j(failErr);
+                  throw failErr;
+                }
+                if (endOfConditionalGroup) {
+                  waitForBotSays = !convoStep.optional;
+                  conditionalGroupId = undefined;
+                  conditionMetInGroup = false;
+                }
                 continue;
+              } else {
+                conditionMetInGroup = true;
+                if (endOfConditionalGroup) {
+                  waitForBotSays = !convoStep.optional;
+                  conditionalGroupId = undefined;
+                  conditionMetInGroup = false;
+                }
               }
             }
             if (!botMsg || !botMsg.messageText && !botMsg.media && !botMsg.buttons && !botMsg.cards && !botMsg.sourceData && !botMsg.nlp) {
-              const failErr = new BotiumError$4(`${this.header.name}/${convoStep.stepTag}: bot says nothing`);
+              const failErr = new BotiumError$2(`${this.header.name}/${convoStep.stepTag}: bot says nothing`);
               debug$j(failErr);
               try {
                 this.scriptingEvents.fail && this.scriptingEvents.fail(failErr, lastMeConvoStep);
@@ -3251,7 +3210,7 @@ class Convo$6 {
               try {
                 this.scriptingEvents.fail && this.scriptingEvents.fail(failErr, lastMeConvoStep);
               } catch (failErr) {}
-              if (container.caps[Capabilities.SCRIPTING_ENABLE_MULTIPLE_ASSERT_ERRORS] && err instanceof BotiumError$4) {
+              if (container.caps[Capabilities.SCRIPTING_ENABLE_MULTIPLE_ASSERT_ERRORS] && err instanceof BotiumError$2) {
                 assertErrors.push(err);
               } else {
                 throw failErr;
@@ -3267,7 +3226,7 @@ class Convo$6 {
               }
             }
           } else {
-            const failErr = new BotiumError$4(`${this.header.name}/${convoStep.stepTag}: invalid sender - ${util__default["default"].inspect(convoStep.sender)}`);
+            const failErr = new BotiumError$2(`${this.header.name}/${convoStep.stepTag}: invalid sender - ${util__default["default"].inspect(convoStep.sender)}`);
             debug$j(failErr);
             try {
               this.scriptingEvents.fail && this.scriptingEvents.fail(failErr);
@@ -3276,7 +3235,7 @@ class Convo$6 {
           }
         } catch (err) {
           if (lastMeConvoStep) {
-            if (err instanceof BotiumError$4 && err.context) {
+            if (err instanceof BotiumError$2 && err.context) {
               err.context.input = new ConvoStep$1(lastMeConvoStep);
               err.context.transcript = [...transcriptSteps, {
                 ...transcriptStep
@@ -3289,7 +3248,7 @@ class Convo$6 {
             }
           }
           transcriptStep.err = err;
-          if (err instanceof BotiumError$4 && container.caps[Capabilities.SCRIPTING_ENABLE_SKIP_ASSERT_ERRORS]) {
+          if (err instanceof BotiumError$2 && container.caps[Capabilities.SCRIPTING_ENABLE_SKIP_ASSERT_ERRORS]) {
             if (!err.isAsserterError()) {
               throw err;
             }
@@ -3322,10 +3281,10 @@ class Convo$6 {
     if (expected === null || expected === undefined) return;
     if (lodash__default["default"].isArray(expected)) {
       if (!lodash__default["default"].isArray(result)) {
-        throw new BotiumError$4(`${this.header.name}/${convoStep.stepTag}: bot response expected array, got "${result}"`);
+        throw new BotiumError$2(`${this.header.name}/${convoStep.stepTag}: bot response expected array, got "${result}"`);
       }
       if (expected.length !== result.length) {
-        throw new BotiumError$4(`${this.header.name}/${convoStep.stepTag}: bot response expected array length ${expected.length}, got ${result.length}`);
+        throw new BotiumError$2(`${this.header.name}/${convoStep.stepTag}: bot response expected array length ${expected.length}, got ${result.length}`);
       }
       for (let i = 0; i < expected.length; i++) {
         this._compareObject(container, scriptingMemory, convoStep, result[i], expected[i]);
@@ -3335,7 +3294,7 @@ class Convo$6 {
         if (Object.prototype.hasOwnProperty.call(result, key)) {
           this._compareObject(container, scriptingMemory, convoStep, result[key], expected[key]);
         } else {
-          throw new BotiumError$4(`${this.header.name}/${convoStep.stepTag}: bot response "${result}" missing expected property: ${key}`);
+          throw new BotiumError$2(`${this.header.name}/${convoStep.stepTag}: bot response "${result}" missing expected property: ${key}`);
         }
       });
     } else {
@@ -3464,14 +3423,14 @@ class Convo$6 {
         includeLogicHooks.forEach(includeLogicHook => {
           const alreadyThereAt = parentPConvos.indexOf(includeLogicHook);
           if (alreadyThereAt >= 0) {
-            throw new BotiumError$4(`Partial convos are included circular. "${includeLogicHook}" is referenced by "/${parentPConvos.slice(0, alreadyThereAt).join('/')}" and by "/${parentPConvos.join('/')}" `);
+            throw new BotiumError$2(`Partial convos are included circular. "${includeLogicHook}" is referenced by "/${parentPConvos.slice(0, alreadyThereAt).join('/')}" and by "/${parentPConvos.join('/')}" `);
           }
           if (!partialConvos || Object.keys(partialConvos).length === 0) {
-            throw new BotiumError$4(`Cant find partial convo with name ${includeLogicHook} (There are no partial convos)`);
+            throw new BotiumError$2(`Cant find partial convo with name ${includeLogicHook} (There are no partial convos)`);
           }
           const partialConvo = partialConvos[includeLogicHook];
           if (!partialConvo) {
-            throw new BotiumError$4(`Cant find partial convo with name ${includeLogicHook} (available partial convos: ${Object.keys(partialConvos).join(',')})`);
+            throw new BotiumError$2(`Cant find partial convo with name ${includeLogicHook} (available partial convos: ${Object.keys(partialConvos).join(',')})`);
           }
           _getEffectiveConversationRecursive(partialConvo.conversation, [...parentPConvos, includeLogicHook], result, true);
           debug$j(`Partial convo ${includeLogicHook} included`);
@@ -3806,44 +3765,21 @@ var JsonToJson = {
   precompile: precompile$2
 };
 
-const {
-  NodeVM
-} = vm2__default["default"];
 const debug$h = debug__default["default"]('botium-core-HookUtils');
-const {
-  BotiumError: BotiumError$3
-} = BotiumError_1;
-const executeHook$2 = async (caps, hook, args) => {
-  return executeHookSync$1(caps, hook, args);
+const executeHook$2 = async (caps, hook, ...args) => {
+  return executeHookSync$1(caps, hook, ...args);
 };
-const executeHookSync$1 = (caps, hook, args) => {
+const executeHookSync$1 = (caps, hook, ...args) => {
   if (!hook) {
     return;
   }
   if (lodash__default["default"].isFunction(hook)) {
     try {
-      return hook(args);
+      return hook(...args);
     } catch (err) {
       throw new Error(`Calling Hook function failed: ${err.message}`);
     }
   }
-  if (lodash__default["default"].isString(hook)) {
-    try {
-      const vm = new NodeVM({
-        eval: false,
-        require: false,
-        sandbox: args
-      });
-      const r = vm.run(hook);
-      if (lodash__default["default"].isFunction(r)) {
-        return r(args);
-      } else {
-        return r;
-      }
-    } catch (err) {
-      throw new Error(`Calling Hook Javascript code failed: ${err.message}`);
-    }
-  }
   throw new Error(`Unknown hook ${typeof hook}`);
 };
 const getHook$3 = (caps, data) => {
@@ -3856,46 +3792,40 @@ const getHook$3 = (caps, data) => {
     return data;
   }
   if (lodash__default["default"].isString(data)) {
-    let resultWithRequire;
-    let tryLoadFile = path__default["default"].resolve(process.cwd(), data);
-    if (fs__default["default"].existsSync(tryLoadFile)) {
-      try {
-        resultWithRequire = commonjsRequire(tryLoadFile);
-      } catch (err) {}
-    } else {
-      tryLoadFile = data;
-      try {
-        resultWithRequire = commonjsRequire(data);
-      } catch (err) {}
-    }
-    if (resultWithRequire) {
-      if (!allowUnsafe) {
-        throw new BotiumError$3('Security Error. Using unsafe custom hook with require is not allowed', {
-          type: 'security',
-          subtype: 'allow unsafe',
-          source: path__default["default"].basename(__filename),
-          cause: {
-            SECURITY_ALLOW_UNSAFE: caps[Capabilities.SECURITY_ALLOW_UNSAFE],
-            hookData: data
+    if (caps.SAFEDIR) {
+      const tryLoadFile = path__default["default"].resolve(caps.SAFEDIR, data);
+      if (tryLoadFile.startsWith(path__default["default"].resolve(caps.SAFEDIR))) {
+        if (fs__default["default"].existsSync(tryLoadFile)) {
+          try {
+            const resultWithRequire = commonjsRequire(tryLoadFile);
+            if (lodash__default["default"].isFunction(resultWithRequire)) {
+              debug$h(`found hook, type: safedir, in ${tryLoadFile}`);
+              return resultWithRequire;
+            } else {
+              throw new Error(`Expected function from hook specification "${util__default["default"].inspect(data)}", got: "${util__default["default"].inspect(resultWithRequire)}"`);
+            }
+          } catch (err) {
+            debug$h(`Failed loading hook, type: safedir, from ${tryLoadFile} failed: ${err.message || err}`);
           }
-        });
-      }
-      if (lodash__default["default"].isFunction(resultWithRequire)) {
-        debug$h(`found hook, type: require, in ${tryLoadFile}`);
-        return resultWithRequire;
-      } else {
-        throw new Error(`Cant load hook ${tryLoadFile} because it is not a function`);
+        }
       }
     }
-    try {
-      esprima__default["default"].parseScript(data);
-    } catch (err) {
-      throw new Error(`Cant load hook, syntax is not valid - ${util__default["default"].inspect(err)}`);
+    if (allowUnsafe || data.startsWith('botium-')) {
+      const tryLoadFile = data;
+      try {
+        const resultWithRequire = commonjsRequire(tryLoadFile);
+        if (lodash__default["default"].isFunction(resultWithRequire)) {
+          debug$h(`found hook, type: require, in ${tryLoadFile}`);
+          return resultWithRequire;
+        } else {
+          throw new Error(`Expected function from hook specification "${util__default["default"].inspect(data)}", got: "${util__default["default"].inspect(resultWithRequire)}"`);
+        }
+      } catch (err) {
+        debug$h(`Failed loading hook, type: require, from ${tryLoadFile} failed: ${err.message || err}`);
+      }
     }
-    debug$h('Found hook, type: JavaScript as String');
-    return data;
   }
-  throw new Error(`Not valid hook ${util__default["default"].inspect(data)}`);
+  throw new Error(`Hook specification "${util__default["default"].inspect(data)}" invalid: no loader available`);
 };
 var HookUtils = {
   getHook: getHook$3,
@@ -5391,7 +5321,7 @@ const {
   ConvoStep
 } = Convo_1;
 const {
-  BotiumError: BotiumError$2,
+  BotiumError: BotiumError$1,
   botiumErrorFromList,
   botiumErrorFromErr
 } = BotiumError_1;
@@ -5667,7 +5597,7 @@ var ScriptingProvider_1 = class ScriptingProvider {
             const werArgs = this.caps[Capabilities.SCRIPTING_MATCHING_MODE_ARGS];
             const threshold = [',', '.'].find(p => `${werArgs[0]}`.includes(p)) ? parseFloat(werArgs[0]) : parseInt(werArgs[0]) / 100;
             const message = `${stepTag}: Word Error Rate (${toPercent(wer)}) higher than accepted (${toPercent(threshold)})`;
-            throw new BotiumError$2(message, {
+            throw new BotiumError$1(message, {
               type: 'asserter',
               source: asserterType,
               params: {
@@ -5689,7 +5619,7 @@ var ScriptingProvider_1 = class ScriptingProvider {
             message += ' expected to match ';
             message += tomatch && tomatch.length > 1 ? 'one of ' : '';
             message += `${tomatch.map(e => e ? '"' + e + '"' : '<any response>').join(', ')}`;
-            throw new BotiumError$2(message, {
+            throw new BotiumError$1(message, {
               type: 'asserter',
               source: asserterType,
               params: {
@@ -5722,7 +5652,7 @@ var ScriptingProvider_1 = class ScriptingProvider {
             const werArgs = this.caps[Capabilities.SCRIPTING_MATCHING_MODE_ARGS];
             const threshold = [',', '.'].find(p => `${werArgs[0]}`.includes(p)) ? parseFloat(werArgs[0]) : parseInt(werArgs[0]) / 100;
             const message = `${stepTag}: Word Error Rate (${toPercent(wer)}) lower than accepted (${toPercent(threshold)})`;
-            throw new BotiumError$2(message, {
+            throw new BotiumError$1(message, {
               type: 'asserter',
               source: asserterType,
               params: {
@@ -5744,7 +5674,7 @@ var ScriptingProvider_1 = class ScriptingProvider {
             message += ' expected NOT to match ';
             message += nottomatch && nottomatch.length > 1 ? 'one of ' : '';
             message += `${nottomatch.map(e => e ? '"' + e + '"' : '<any response>').join(', ')}`;
-            throw new BotiumError$2(message, {
+            throw new BotiumError$1(message, {
               type: 'asserter',
               source: asserterType,
               params: {
@@ -5794,7 +5724,7 @@ var ScriptingProvider_1 = class ScriptingProvider {
         if (asserter[notAsserterType]) {
           return p(this.retryHelperAsserter, () => asserter[notAsserterType](params));
         } else {
-          return pnot(this.retryHelperAsserter, () => asserter[asserterType](params), new BotiumError$2(`${convoStep.stepTag}: Expected asserter ${asserter.name || asserterSpec.name} with args "${params.args}" to fail`, {
+          return pnot(this.retryHelperAsserter, () => asserter[asserterType](params), new BotiumError$1(`${convoStep.stepTag}: Expected asserter ${asserter.name || asserterSpec.name} with args "${params.args}" to fail`, {
             type: 'asserter',
             source: asserter.name || asserterSpec.name,
             params: {
@@ -6189,7 +6119,7 @@ var ScriptingProvider_1 = class ScriptingProvider {
       return !entry.header.name;
     });
     if (aggregatedNoNames.length) {
-      throw new BotiumError$2('Scripting Memory Definition(s) without name', {
+      throw new BotiumError$1('Scripting Memory Definition(s) without name', {
         type: 'Scripting Memory',
         subtype: 'Scripting Memory without name',
         source: 'ScriptingProvider',
@@ -6204,7 +6134,7 @@ var ScriptingProvider_1 = class ScriptingProvider {
       return !entry.values || !Object.keys(entry.values).length;
     });
     if (aggregatedNoVariables.length) {
-      throw new BotiumError$2(`Scripting Memory Definition(s) ${aggregatedNoVariables.map(e => e.header.name).join(', ')} without variable`, {
+      throw new BotiumError$1(`Scripting Memory Definition(s) ${aggregatedNoVariables.map(e => e.header.name).join(', ')} without variable`, {
         type: 'Scripting Memory',
         subtype: 'Scripting Memory without variable',
         source: 'ScriptingProvider',
@@ -6219,7 +6149,7 @@ var ScriptingProvider_1 = class ScriptingProvider {
       return !lodash__default["default"].isUndefined(entry.values['']);
     });
     if (aggregatedNoVariableNames.length) {
-      throw new BotiumError$2(`Scripting Memory Definition(s) ${aggregatedNoVariableNames.map(e => e.header.name).join(', ')} without variable name`, {
+      throw new BotiumError$1(`Scripting Memory Definition(s) ${aggregatedNoVariableNames.map(e => e.header.name).join(', ')} without variable name`, {
         type: 'Scripting Memory',
         subtype: 'Scripting Memory without variable name',
         source: 'ScriptingProvider',
@@ -6247,7 +6177,7 @@ var ScriptingProvider_1 = class ScriptingProvider {
       }
     }
     if (aggregatedDuplicates.length) {
-      throw new BotiumError$2(`Scripting Memory Definition name(s) "${lodash__default["default"].uniq(aggregatedDuplicates.map(d => d.scriptingMemory.header.name)).join(', ')}" are not unique`, {
+      throw new BotiumError$1(`Scripting Memory Definition name(s) "${lodash__default["default"].uniq(aggregatedDuplicates.map(d => d.scriptingMemory.header.name)).join(', ')}" are not unique`, {
         type: 'Scripting Memory',
         subtype: 'Scripting Memory name collision',
         source: 'ScriptingProvider',
@@ -6278,7 +6208,7 @@ var ScriptingProvider_1 = class ScriptingProvider {
       }
     }
     if (aggregatedIntersections.length) {
-      throw new BotiumError$2(`Scripting Memory Definitions "${aggregatedIntersections.map(i => i.scriptingMemory.header.name).join(', ')}" are invalid because variable name collision"`, {
+      throw new BotiumError$1(`Scripting Memory Definitions "${aggregatedIntersections.map(i => i.scriptingMemory.header.name).join(', ')}" are invalid because variable name collision"`, {
         type: 'Scripting Memory',
         subtype: 'Scripting Memory variable name collision',
         source: 'ScriptingProvider',
@@ -6841,7 +6771,7 @@ var ScriptingProvider_1 = class ScriptingProvider {
       }
     } else if (scriptingMemories) {
       if (!scriptingMemories.header || !scriptingMemories.header.name) {
-        throw new BotiumError$2('Scripting Memory Definition has no name', {
+        throw new BotiumError$1('Scripting Memory Definition has no name', {
           type: 'Compiler',
           subtype: 'Scripting memory without name',
           source: 'ScriptingProvider',
@@ -6851,7 +6781,7 @@ var ScriptingProvider_1 = class ScriptingProvider {
         });
       }
       if (!scriptingMemories.values || !Object.keys(scriptingMemories.values).length) {
-        throw new BotiumError$2('Scripting Memory Definition has no variables', {
+        throw new BotiumError$1('Scripting Memory Definition has no variables', {
           type: 'Compiler',
           subtype: 'Scripting memory without variable',
           source: 'ScriptingProvider',
@@ -6861,7 +6791,7 @@ var ScriptingProvider_1 = class ScriptingProvider {
         });
       }
       if (scriptingMemories.values && !lodash__default["default"].isUndefined(scriptingMemories.values[''])) {
-        throw new BotiumError$2('Scripting Memory Definition variable has no name', {
+        throw new BotiumError$1('Scripting Memory Definition variable has no name', {
           type: 'Compiler',
           subtype: 'Scripting memory without variable name',
           source: 'ScriptingProvider',
@@ -7748,7 +7678,7 @@ const {
   escapeJSONString
 } = Utils;
 const {
-  BotiumError: BotiumError$1
+  BotiumError
 } = BotiumError_1;
 mustache__default["default"].escape = s => s;
 var SimpleRestContainer_1 = class SimpleRestContainer {
@@ -8045,22 +7975,32 @@ var SimpleRestContainer_1 = class SimpleRestContainer {
     }
     const result = [];
     if (isFromUser) {
-      const _extractFrom = (root, jsonPaths) => {
-        const flattened = [];
+      const _extractFrom = (root, jsonPaths, acceptFn = null) => {
+        const result = [];
         for (const jsonPath of jsonPaths) {
+          const jsonPathRes = [];
           const rb = jsonpath__default["default"].query(root, jsonPath);
           if (lodash__default["default"].isArray(rb)) {
-            lodash__default["default"].flattenDeep(rb).forEach(r => flattened.push(r));
-          } else if (rb) {
-            flattened.push(rb);
+            lodash__default["default"].flattenDeep(rb).forEach(r => jsonPathRes.push(r));
+          } else {
+            jsonPathRes.push(rb);
+          }
+          if (acceptFn) {
+            result.push(...jsonPathRes.filter(r => acceptFn(root, jsonPath, r)));
+          } else {
+            result.push(...jsonPathRes);
           }
         }
-        return flattened;
+        return result;
       };
       const jsonPathRoots = [];
       const jsonPathsBody = getAllCapValues(Capabilities.SIMPLEREST_BODY_JSONPATH, this.caps);
       if (jsonPathsBody.length > 0) {
-        jsonPathRoots.push(..._extractFrom(body, jsonPathsBody));
+        jsonPathRoots.push(..._extractFrom(body, jsonPathsBody, (root, jsonPath, r) => {
+          if (r && lodash__default["default"].isObject(r)) return true;
+          debug$4(`Ignoring result body from ${jsonPath} - not a querieable object (${util__default["default"].inspect(r)})`);
+          return false;
+        }));
       } else {
         jsonPathRoots.push(body);
       }
@@ -8219,7 +8159,7 @@ 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$1(`got error response: ${response.statusCode}/${response.statusMessage} - ${jsonBody[errKey]}`, {
+                return reject(new BotiumError(`got error response: ${response.statusCode}/${response.statusMessage} - ${jsonBody[errKey]}`, {
                   message: Utils.shortenJsonString(body)
                 }));
               }
@@ -8674,9 +8614,6 @@ var SimpleRestContainer_1 = class SimpleRestContainer {
 };
 
 const debug$3 = debug__default["default"]('botium-connector-PluginConnectorContainer-helper');
-const {
-  BotiumError
-} = BotiumError_1;
 const pluginResolver = containermode => {
   if (containermode === 'simplerest') {
     return SimpleRestContainer_1;
@@ -8727,20 +8664,6 @@ const loadConnectorModule = (PluginClass, args) => {
 };
 const tryLoadPlugin$1 = (containermode, modulepath, args) => {
   const pluginLoaderSpec = modulepath || containermode;
-  const _checkUnsafe = (caps, mode, cause) => {
-    if (!caps[Capabilities.SECURITY_ALLOW_UNSAFE]) {
-      throw new BotiumError(`Security Error. Using unsafe connector mode "${mode}" is not allowed`, {
-        type: 'security',
-        subtype: 'allow unsafe',
-        source: 'src/containers/plugins/index.js',
-        cause: {
-          SECURITY_ALLOW_UNSAFE: caps[Capabilities.SECURITY_ALLOW_UNSAFE],
-          mode,
-          ...cause
-        }
-      });
-    }
-  };
   if (pluginResolver(pluginLoaderSpec)) {
     const pluginInstance = new (pluginResolver(pluginLoaderSpec))(args);
     debug$3('Botium plugin loaded from internal plugin resolver');
@@ -8752,44 +8675,47 @@ const tryLoadPlugin$1 = (containermode, modulepath, args) => {
     return pluginInstance;
   }
   const loadErr = [];
+  const allowUnsafe = !!args.caps[Capabilities.SECURITY_ALLOW_UNSAFE];
   if (lodash__default["default"].isString(pluginLoaderSpec)) {
-    const tryLoadFile = path__default["default"].resolve(process.cwd(), pluginLoaderSpec);
-    if (fs__default["default"].existsSync(tryLoadFile)) {
-      _checkUnsafe(args.caps, 'Using work dir', {
-        modulepath,
-        containermode
-      });
+    if (args.caps.SAFEDIR) {
+      const tryLoadFile = path__default["default"].resolve(args.caps.SAFEDIR, pluginLoaderSpec);
+      if (tryLoadFile.startsWith(path__default["default"].resolve(args.caps.SAFEDIR))) {
+        if (fs__default["default"].existsSync(tryLoadFile)) {
+          try {
+            let plugin = commonjsRequire(tryLoadFile);
+            if (plugin.default) {
+              plugin = plugin.default;
+            }
+            if (!plugin.PluginVersion || !plugin.PluginClass) {
+              loadErr.push(`Invalid Botium plugin loaded from ${tryLoadFile}, expected PluginVersion, PluginClass fields`);
+            } else {
+              const pluginInstance = loadConnectorModule(plugin.PluginClass, args);
+              debug$3(`Botium plugin loaded from ${tryLoadFile}`);
+              return pluginInstance;
+            }
+          } catch (err) {
+            loadErr.push(`Loading Botium plugin from ${tryLoadFile} failed - ${err.message}`);
+          }
+        }
+      }
+    }
+    if (allowUnsafe) {
       try {
-        let plugin = commonjsRequire(tryLoadFile);
+        let plugin = commonjsRequire(pluginLoaderSpec);
         if (plugin.default) {
           plugin = plugin.default;
         }
         if (!plugin.PluginVersion || !plugin.PluginClass) {
-          loadErr.push(`Invalid Botium plugin loaded from ${tryLoadFile}, expected PluginVersion, PluginClass fields`);
+          loadErr.push(`Invalid Botium plugin loaded from ${pluginLoaderSpec}, expected PluginVersion, PluginClass fields`);
         } else {
           const pluginInstance = loadConnectorModule(plugin.PluginClass, args);
-          debug$3(`Botium plugin loaded from ${tryLoadFile}`);
+          debug$3(`Botium plugin loaded from ${pluginLoaderSpec}. Plugin version is ${getModuleVersionSafe(pluginLoaderSpec)}`);
           return pluginInstance;
         }
       } catch (err) {
-        loadErr.push(`Loading Botium plugin from ${tryLoadFile} failed - ${err.message}`);
+        loadErr.push(`Loading Botium plugin from ${pluginLoaderSpec} failed - ${err.message}`);
       }
     }
-    try {
-      let plugin = commonjsRequire(pluginLoaderSpec);
-      if (plugin.default) {
-        plugin = plugin.default;
-      }
-      if (!plugin.PluginVersion || !plugin.PluginClass) {
-        loadErr.push(`Invalid Botium plugin loaded from ${pluginLoaderSpec}, expected PluginVersion, PluginClass fields`);
-      } else {
-        const pluginInstance = loadConnectorModule(plugin.PluginClass, args);
-        debug$3(`Botium plugin loaded from ${pluginLoaderSpec}. Plugin version is ${getModuleVersionSafe(pluginLoaderSpec)}`);
-        return pluginInstance;
-      }
-    } catch (err) {
-      loadErr.push(`Loading Botium plugin from ${pluginLoaderSpec} failed - ${err.message}`);
-    }
     const tryLoadPackage = `botium-connector-${pluginLoaderSpec}`;
     try {
       let plugin = commonjsRequire(tryLoadPackage);
@@ -8953,6 +8879,13 @@ var PluginConnectorContainer_1 = class PluginConnectorContainer extends BaseCont
       return Promise.reject(new Error(`Clean - Botium plugin failed: ${util__default["default"].inspect(err)}`));
     }
   }
+  GetMetaData() {
+    try {
+      return this.pluginInstance.GetMetaData ? this.pluginInstance.GetMetaData() || Promise.resolve() : Promise.resolve();
+    } catch (err) {
+      return Promise.reject(new Error(`GetMetaData - Botium plugin failed: ${util__default["default"].inspect(err)}`));
+    }
+  }
 };
 
 var require$$3 = getCjsExportFromNamespace(_package$1);