@duckduckgo/autoconsent 1.0.3 → 1.0.6

package/lib/cmps/all.ts

@@ -5,6 +5,7 @@ import SourcePoint from './sourcepoint';
 import ContentManager from './consentmanager';
 import Evidon from './evidon';
 import { AutoConsentCMPRule } from '../rules';
+import Onetrust from './onetrust';
 
 const rules = [
   new TrustArc(),
@@ -12,6 +13,7 @@ const rules = [
   new SourcePoint(),
   new ContentManager(),
   new Evidon(),
+  new Onetrust(),
 ];
 
 export function createAutoCMP(config: AutoConsentCMPRule): AutoConsent {

package/lib/cmps/base.js

@@ -1,4 +1,5 @@
 /* eslint-disable no-restricted-syntax,no-await-in-loop,no-underscore-dangle */
+import { enableLogs } from "../config";
 export async function waitFor(predicate, maxTimes, interval) {
     let result = await predicate();
     if (!result && maxTimes > 0) {
@@ -13,7 +14,7 @@ export async function waitFor(predicate, maxTimes, interval) {
 export async function success(action) {
     const result = await action;
     if (!result) {
-        throw new Error(`Action failed: ${action}`);
+        throw new Error(`Action failed: ${action} ${result}`);
     }
     return result;
 }
@@ -118,7 +119,9 @@ export class AutoConsent extends AutoConsentBase {
     }
     async _runRulesSequentially(tab, rules) {
         for (const rule of rules) {
+            enableLogs && console.log('Running rule...', rule, tab.id);
             const result = await evaluateRule(rule, tab);
+            enableLogs && console.log('...rule result', result);
             if (!result && !rule.optional) {
                 return false;
             }
@@ -145,6 +148,7 @@ export class AutoConsent extends AutoConsentBase {
     }
     async optOut(tab) {
         if (this.config.optOut) {
+            enableLogs && console.log('Initiated optOut()', this.config.optOut);
             return this._runRulesSequentially(tab, this.config.optOut);
         }
         return false;

package/lib/cmps/base.ts

@@ -2,6 +2,7 @@
 
 import { AutoCMP, TabActor } from "../types";
 import { AutoConsentCMPRule, AutoConsentRuleStep } from "../rules";
+import { enableLogs } from "../config";
 
 export async function waitFor(predicate: () => Promise<boolean> | boolean, maxTimes: number, interval: number): Promise<boolean> {
   let result = await predicate();
@@ -19,7 +20,7 @@ export async function waitFor(predicate: () => Promise<boolean> | boolean, maxTi
 export async function success(action: Promise<boolean>): Promise<boolean> {
   const result = await action;
   if (!result) {
-    throw new Error(`Action failed: ${action}`)
+    throw new Error(`Action failed: ${action} ${result}`)
   }
   return result
 }
@@ -140,7 +141,9 @@ export class AutoConsent extends AutoConsentBase {
 
   async _runRulesSequentially(tab: TabActor, rules: AutoConsentRuleStep[]): Promise<boolean> {
     for (const rule of rules) {
+      enableLogs && console.log('Running rule...', rule, tab.id);
       const result = await evaluateRule(rule, tab);
+      enableLogs && console.log('...rule result', result);
       if (!result && !rule.optional) {
         return false;
       }
@@ -171,6 +174,7 @@ export class AutoConsent extends AutoConsentBase {
 
   async optOut(tab: TabActor) {
     if (this.config.optOut) {
+      enableLogs && console.log('Initiated optOut()', this.config.optOut);
       return this._runRulesSequentially(tab, this.config.optOut);
     }
     return false;

package/lib/cmps/onetrust.js

@@ -0,0 +1,32 @@
+import AutoConsentBase, { success } from "./base";
+export default class Onetrust extends AutoConsentBase {
+    constructor() {
+        super("Onetrust");
+        this.prehideSelectors = ["#onetrust-banner-sdk,#onetrust-consent-sdk,.optanon-alert-box-wrapper,.onetrust-pc-dark-filter,.js-consent-banner"];
+    }
+    detectCmp(tab) {
+        return tab.elementExists("#onetrust-banner-sdk,.optanon-alert-box-wrapper");
+    }
+    detectPopup(tab) {
+        return tab.elementsAreVisible("#onetrust-banner-sdk,.optanon-alert-box-wrapper");
+    }
+    async optOut(tab) {
+        if (await tab.elementExists("#onetrust-pc-btn-handler")) { // "show purposes" button inside a popup
+            await success(tab.clickElement("#onetrust-pc-btn-handler"));
+        }
+        else { // otherwise look for a generic "show settings" button
+            await success(tab.clickElement(".ot-sdk-show-settings,button.js-cookie-settings"));
+        }
+        await success(tab.waitForElement("#onetrust-consent-sdk", 2000));
+        await success(tab.wait(1000));
+        await tab.clickElements("#onetrust-consent-sdk input.category-switch-handler:checked,.js-editor-toggle-state:checked"); // optional step
+        await success(tab.waitForThenClick(".save-preference-btn-handler,.js-consent-save", 1000));
+        return true;
+    }
+    async optIn(tab) {
+        return tab.clickElement("onetrust-accept-btn-handler,js-accept-cookies");
+    }
+    async test(tab) {
+        return tab.eval("window.OnetrustActiveGroups.split(',').filter(s => s.length > 0).length <= 1");
+    }
+}

package/lib/cmps/onetrust.ts

@@ -0,0 +1,41 @@
+import AutoConsentBase, { success } from "./base";
+import { TabActor } from "../types";
+
+export default class Onetrust extends AutoConsentBase {
+
+  prehideSelectors = ["#onetrust-banner-sdk,#onetrust-consent-sdk,.optanon-alert-box-wrapper,.onetrust-pc-dark-filter,.js-consent-banner"]
+
+  constructor() {
+    super("Onetrust");
+  }
+
+  detectCmp(tab: TabActor) {
+    return tab.elementExists("#onetrust-banner-sdk,.optanon-alert-box-wrapper");
+  }
+
+  detectPopup(tab: TabActor) {
+    return tab.elementsAreVisible("#onetrust-banner-sdk,.optanon-alert-box-wrapper");
+  }
+
+  async optOut(tab: TabActor) {
+    if (await tab.elementExists("#onetrust-pc-btn-handler")) { // "show purposes" button inside a popup
+      await success(tab.clickElement("#onetrust-pc-btn-handler"));
+    } else { // otherwise look for a generic "show settings" button
+      await success(tab.clickElement(".ot-sdk-show-settings,button.js-cookie-settings"));
+    }
+
+    await success(tab.waitForElement("#onetrust-consent-sdk", 2000));
+    await success(tab.wait(1000));
+    await tab.clickElements("#onetrust-consent-sdk input.category-switch-handler:checked,.js-editor-toggle-state:checked"); // optional step
+    await success(tab.waitForThenClick(".save-preference-btn-handler,.js-consent-save", 1000));
+    return true;
+  }
+
+  async optIn(tab: TabActor) {
+    return tab.clickElement("onetrust-accept-btn-handler,js-accept-cookies");
+  }
+
+  async test(tab: TabActor){
+    return tab.eval("window.OnetrustActiveGroups.split(',').filter(s => s.length > 0).length <= 1");
+  }
+}

package/lib/config.js

@@ -0,0 +1 @@
+export const enableLogs = false; // change this to enable debug logs

package/lib/config.ts

@@ -0,0 +1 @@
+export const enableLogs = false; // change this to enable debug logs

package/lib/detector.js

@@ -1,11 +1,14 @@
+import { enableLogs } from './config';
 export default async function detectDialog(tab, retries, rules) {
     let breakEarly = false;
     const found = await new Promise(async (resolve) => {
         let earlyReturn = false;
+        enableLogs && console.log(`${new Date()} [${tab.id}] Detecting CMPs (${rules.length} rules)`);
         await Promise.all(rules.map(async (r, index) => {
             try {
                 if (await r.detectCmp(tab)) {
                     earlyReturn = true;
+                    enableLogs && console.log(`Found CMP in [${tab.id}]: ${r.name}`);
                     resolve(index);
                 }
             }
@@ -17,6 +20,7 @@ export default async function detectDialog(tab, retries, rules) {
             resolve(-1);
         }
     });
+    enableLogs && console.log(`${new Date()} CMP detection finished in [${tab.id}], found rule #${found}`);
     if (found === -1 && retries > 0 && !breakEarly) {
         return new Promise((resolve) => {
             setTimeout(async () => {

package/lib/detector.ts

@@ -1,13 +1,16 @@
+import { enableLogs } from './config';
 import { AutoCMP, TabActor } from './types';
 
 export default async function detectDialog(tab: TabActor, retries: number, rules: AutoCMP[]): Promise<AutoCMP> {
   let breakEarly = false;
   const found: number = await new Promise(async (resolve) => {
     let earlyReturn = false;
+    enableLogs && console.log(`${new Date()} [${tab.id}] Detecting CMPs (${rules.length} rules)`);
     await Promise.all(rules.map(async (r, index) => {
       try {
         if (await r.detectCmp(tab)) {
           earlyReturn = true;
+          enableLogs && console.log(`Found CMP in [${tab.id}]: ${r.name}`);
           resolve(index)
         }
       } catch (e) {
@@ -18,6 +21,7 @@ export default async function detectDialog(tab: TabActor, retries: number, rules
       resolve(-1)
     }
   })
+  enableLogs && console.log(`${new Date()} CMP detection finished in [${tab.id}], found rule #${found}`);
   if (found === -1 && retries > 0 && !breakEarly) {
     return new Promise((resolve) => {
       setTimeout(async () => {

package/lib/hider.js

@@ -9,5 +9,5 @@ export default async function prehideElements(tab, rules) {
         }
         return selectorList;
     }, globalHidden);
-    await tab.hideElements(selectors);
+    await tab.hideElements(selectors, undefined, 'opacity');
 }

package/lib/hider.ts

@@ -12,5 +12,5 @@ export default async function prehideElements(tab: TabActor, rules: AutoCMP[]):
         }
         return selectorList;
       }, globalHidden);
-    await tab.hideElements(selectors);
+    await tab.hideElements(selectors, undefined, 'opacity');
 }

package/lib/messages.d.ts

@@ -9,6 +9,8 @@ export type ContentScriptMessage =
   | MatchesMessage
   | ActionMessage;
 
+export type HideMethod = 'display' | 'opacity';
+
 type ClickMessage = {
   type: "click";
   selector: string;
@@ -40,6 +42,7 @@ type EvalMessage = {
 type HideMessage = {
   type: "hide";
   selectors: string[];
+  method: HideMethod;
 };
 
 type UndoHideMessage = {

package/lib/node.js

@@ -1,13 +1,15 @@
 import Tab from './puppet/tab';
 import detectDialog from './detector';
 import TabConsent from './tabwrapper';
+import prehideElements from './hider';
 export * from './index';
 export { ConsentOMaticCMP } from './consentomatic/index';
 export { Tab, detectDialog, TabConsent, };
-export function attachToPage(page, url, rules, retries = 1) {
-    const frames = {};
+export function attachToPage(page, url, rules, retries = 1, prehide = true) {
+    const frames = {
+        0: page.mainFrame(),
+    };
     const tab = new Tab(page, url, frames);
-    frames[0] = page.mainFrame();
     async function onFrame(frame) {
         const allFrames = await page.frames();
         allFrames.forEach((frame, frameId) => {
@@ -26,5 +28,8 @@ export function attachToPage(page, url, rules, retries = 1) {
     }
     page.on('framenavigated', onFrame);
     page.frames().forEach(onFrame);
+    if (prehide) {
+        prehideElements(tab, rules);
+    }
     return new TabConsent(tab, detectDialog(tab, retries, rules));
 }

package/lib/node.ts

@@ -2,6 +2,7 @@ import Tab from './puppet/tab';
 import detectDialog from './detector';
 import TabConsent from './tabwrapper';
 import { AutoCMP } from './types';
+import prehideElements from './hider';
 
 export * from './index';
 export { ConsentOMaticCMP } from './consentomatic/index';
@@ -11,11 +12,12 @@ export {
   TabConsent,
 }
 
-export function attachToPage(page: any, url: string, rules: AutoCMP[], retries = 1) {
-  const frames: { [id: number]: any } = {};
+export function attachToPage(page: any, url: string, rules: AutoCMP[], retries = 1, prehide = true) {
+  const frames: { [id: number]: any } = {
+    0: page.mainFrame(),
+  };
   const tab = new Tab(page, url, frames);
-  frames[0] = page.mainFrame();
-  
+
   async function onFrame(frame: any) {
     const allFrames: any[] = await page.frames();
     allFrames.forEach((frame, frameId) => {
@@ -34,5 +36,8 @@ export function attachToPage(page: any, url: string, rules: AutoCMP[], retries =
   }
   page.on('framenavigated', onFrame);
   page.frames().forEach(onFrame);
-  return new TabConsent(tab, detectDialog(tab, retries, rules))
+  if (prehide) {
+    prehideElements(tab, rules);
+  }
+  return new TabConsent(tab, detectDialog(tab, retries, rules));
 }

package/lib/puppet/tab.js

@@ -1,6 +1,7 @@
 import { waitFor } from '../cmps/base';
 import Tools from '../web/consentomatic/tools';
 import { matches } from '../web/consentomatic/index';
+import { hideElementsUtil, getStyleElementUtil } from '../web/content-utils';
 const DEBUG = false;
 export default class Tab {
     constructor(page, url, frames) {
@@ -9,6 +10,10 @@ export default class Tab {
         this.page = page;
         this.url = url;
         this.frames = frames;
+        this._utilsSnippet = `
+      ${getStyleElementUtil.toString()}
+      ${hideElementsUtil.toString()}
+    `;
     }
     async elementExists(selector, frameId = 0) {
         const elements = await this.frames[frameId].$$(selector);
@@ -84,9 +89,11 @@ export default class Tab {
         }
         return false;
     }
-    async hideElements(selectors, frameId = 0) {
-        // TODO implement this
-        return Promise.resolve(true);
+    async hideElements(selectors, frameId = 0, method = 'display') {
+        return await this.frames[frameId].evaluate(`(() => {
+      ${this._utilsSnippet}
+      return hideElementsUtil(${JSON.stringify(selectors)}, '${method}');
+    })()`);
     }
     undoHideElements(frameId) {
         return Promise.resolve(true);

package/lib/puppet/tab.ts

@@ -2,6 +2,8 @@ import { waitFor } from '../cmps/base';
 import { TabActor } from '../types';
 import Tools from '../web/consentomatic/tools';
 import { matches } from '../web/consentomatic/index';
+import { HideMethod } from '../messages';
+import { hideElementsUtil, getStyleElementUtil } from '../web/content-utils';
 
 const DEBUG = false;
 
@@ -17,10 +19,16 @@ export default class Tab implements TabActor {
     url: string
   }
 
+  _utilsSnippet: string // serialized RPC functions borrowed from content script
+
   constructor(page: any, url: string, frames: { [id: number]: any }) {
     this.page = page;
     this.url = url;
     this.frames = frames;
+    this._utilsSnippet = `
+      ${getStyleElementUtil.toString()}
+      ${hideElementsUtil.toString()}
+    `;
   }
 
   async elementExists(selector: string, frameId = 0) {
@@ -101,9 +109,11 @@ export default class Tab implements TabActor {
     return false;
   }
 
-  async hideElements(selectors: string[], frameId = 0) {
-    // TODO implement this
-    return Promise.resolve(true)
+  async hideElements(selectors: string[], frameId = 0, method: HideMethod = 'display') {
+    return await this.frames[frameId].evaluate(`(() => {
+      ${this._utilsSnippet}
+      return hideElementsUtil(${JSON.stringify(selectors)}, '${method}');
+    })()`);
   }
 
   undoHideElements(frameId?: number): Promise<boolean> {

package/lib/tabwrapper.js

@@ -1,3 +1,4 @@
+import { enableLogs } from './config';
 export default class TabConsent {
     constructor(tab, ruleCheckPromise) {
         this.tab = tab;
@@ -12,23 +13,28 @@ export default class TabConsent {
         return null;
     }
     async isPopupOpen(retries = 1, interval = 1000) {
+        enableLogs && console.log('checking if popup is open...', this.tab.id, this.rule.name);
         const isOpen = await this.rule.detectPopup(this.tab);
         if (!isOpen && retries > 0) {
             return new Promise((resolve) => setTimeout(() => resolve(this.isPopupOpen(retries - 1, interval)), interval));
         }
+        enableLogs && console.log(`popup is ${isOpen ? 'open' : 'not open'}`);
         return isOpen;
     }
     async doOptOut() {
         try {
+            enableLogs && console.log(`doing opt out ${this.getCMPName()} in tab ${this.tab.id}`);
             this.optOutStatus = await this.rule.optOut(this.tab);
             return this.optOutStatus;
         }
         catch (e) {
+            console.error('error during opt out', e);
             this.optOutStatus = e;
             throw e;
         }
         finally {
             if (!this.rule.isHidingRule) {
+                enableLogs && console.log('unhiding elements');
                 if (this.getCMPName().startsWith('com_')) {
                     this.tab.wait(5000).then(() => this.tab.undoHideElements());
                 }

package/lib/tabwrapper.ts

@@ -1,3 +1,4 @@
+import { enableLogs } from './config';
 import { AutoCMP, TabActor } from './types';
 
 export default class TabConsent {
@@ -18,22 +19,27 @@ export default class TabConsent {
     }
   
     async isPopupOpen(retries = 1, interval = 1000): Promise<boolean> {
+      enableLogs && console.log('checking if popup is open...', this.tab.id, this.rule.name);
       const isOpen = await this.rule.detectPopup(this.tab);
       if (!isOpen && retries > 0) {
         return new Promise((resolve) => setTimeout(() => resolve(this.isPopupOpen(retries - 1, interval)), interval));
       }
+      enableLogs && console.log(`popup is ${isOpen ? 'open' : 'not open'}`);
       return isOpen;
     }
   
     async doOptOut() {
       try {
+        enableLogs && console.log(`doing opt out ${this.getCMPName()} in tab ${this.tab.id}`);
         this.optOutStatus = await this.rule.optOut(this.tab);
         return this.optOutStatus;
       } catch (e) {
+        console.error('error during opt out', e);
         this.optOutStatus = e;
         throw e;
       } finally {
         if (!this.rule.isHidingRule) {
+          enableLogs && console.log('unhiding elements');
           if (this.getCMPName().startsWith('com_')) {
             this.tab.wait(5000).then(() => this.tab.undoHideElements())
           } else {

package/lib/types.d.ts

@@ -1,4 +1,4 @@
-import { ContentScriptMessage } from "./messages";
+import { ContentScriptMessage, HideMethod } from "./messages";
 
 type Tab = {
   url: string
@@ -27,7 +27,7 @@ export interface TabActor {
   eval(script: string, frameId?: number): Promise<boolean>
   waitForElement(selector: string, timeout: number, frameId?: number): Promise<boolean>
   waitForThenClick(selector: string, timeout?: number, frameId?: number): Promise<boolean>
-  hideElements(selectors: string[], frameId?: number): Promise<boolean>
+  hideElements(selectors: string[], frameId?: number, method?: HideMethod): Promise<boolean>
   undoHideElements(frameId?: number): Promise<boolean>
   goto(url: string): Promise<void>
   wait(ms: number): Promise<true>

package/lib/web/content-utils.js

@@ -0,0 +1,29 @@
+// get or create a style container for CSS overrides
+export function getStyleElementUtil() {
+    const styleOverrideElementId = "autoconsent-css-rules";
+    const styleSelector = `style#${styleOverrideElementId}`;
+    const existingElement = document.querySelector(styleSelector);
+    if (existingElement && existingElement instanceof HTMLStyleElement) {
+        return existingElement;
+    }
+    else {
+        const parent = document.head ||
+            document.getElementsByTagName("head")[0] ||
+            document.documentElement;
+        const css = document.createElement("style");
+        css.id = styleOverrideElementId;
+        parent.appendChild(css);
+        return css;
+    }
+}
+// hide elements with a CSS rule
+export function hideElementsUtil(selectors, method) {
+    const hidingSnippet = method === 'display' ? `display: none` : `opacity: 0`;
+    const rule = `${selectors.join(",")} { ${hidingSnippet} !important; z-index: -1 !important; pointer-events: none !important; } `;
+    const styleEl = getStyleElementUtil();
+    if (styleEl instanceof HTMLStyleElement) {
+        styleEl.innerText += rule;
+        return selectors.length > 0;
+    }
+    return false;
+}

package/lib/web/content-utils.ts

@@ -0,0 +1,31 @@
+import { HideMethod } from "../messages";
+
+// get or create a style container for CSS overrides
+export function getStyleElementUtil(): HTMLStyleElement {
+  const styleOverrideElementId = "autoconsent-css-rules";
+  const styleSelector = `style#${styleOverrideElementId}`;
+  const existingElement = document.querySelector(styleSelector);
+  if (existingElement && existingElement instanceof HTMLStyleElement) {
+    return existingElement;
+  } else {
+    const parent = document.head ||
+      document.getElementsByTagName("head")[0] ||
+      document.documentElement;
+    const css = document.createElement("style");
+    css.id = styleOverrideElementId;
+    parent.appendChild(css);
+    return css;
+  }
+}
+
+// hide elements with a CSS rule
+export function hideElementsUtil(selectors: string[], method: HideMethod): boolean {
+  const hidingSnippet = method === 'display' ? `display: none` : `opacity: 0`;
+  const rule = `${selectors.join(",")} { ${hidingSnippet} !important; z-index: -1 !important; pointer-events: none !important; } `;
+  const styleEl = getStyleElementUtil();
+  if (styleEl instanceof HTMLStyleElement) {
+    styleEl.innerText += rule;
+    return selectors.length > 0;
+  }
+  return false;
+}

package/lib/web/content.js

@@ -1,7 +1,6 @@
 import { matches, executeAction } from "./consentomatic/index";
+import { hideElementsUtil, getStyleElementUtil } from "./content-utils";
 let actionQueue = Promise.resolve(null);
-const styleOverrideElementId = "autoconsent-css-rules";
-const styleSelector = `style#${styleOverrideElementId}`;
 export default function handleMessage(message, debug = false) {
     if (message.type === "click") {
         const elem = document.querySelectorAll(message.selector);
@@ -25,8 +24,9 @@ export default function handleMessage(message, debug = false) {
         const elem = document.querySelectorAll(message.selector);
         const results = new Array(elem.length);
         elem.forEach((e, i) => {
-            results[i] = e.offsetParent !== null || window.getComputedStyle(e).display !== "none" || e.style?.display !== "none";
+            results[i] = e.offsetParent !== null || window.getComputedStyle(e).display !== "none"; // TODO: handle visibility and z-index?
         });
+        debug && console.log("[visible?]", message.selector, elem, results);
         if (results.length === 0) {
             return false;
         }
@@ -41,6 +41,7 @@ export default function handleMessage(message, debug = false) {
     }
     else if (message.type === "getAttribute") {
         const elem = document.querySelector(message.selector);
+        debug && console.log("[getAttribute]", message.selector, elem);
         if (!elem) {
             return false;
         }
@@ -48,31 +49,16 @@ export default function handleMessage(message, debug = false) {
     }
     else if (message.type === "eval") {
         // TODO: chrome support
+        debug && console.log("about to [eval]", message.script); // this will not show in Webkit console
         const result = window.eval(message.script); // eslint-disable-line no-eval
-        debug && console.log("[eval]", message.script, result);
         return result;
     }
     else if (message.type === "hide") {
-        const parent = document.head ||
-            document.getElementsByTagName("head")[0] ||
-            document.documentElement;
-        const rule = `${message.selectors.join(",")} { display: none !important; z-index: -1 !important; } `;
-        const existingElement = document.querySelector(styleSelector);
-        debug && console.log("[hide]", message.selectors, !!existingElement);
-        if (existingElement && existingElement instanceof HTMLStyleElement) {
-            existingElement.innerText += rule;
-        }
-        else {
-            const css = document.createElement("style");
-            css.type = "text/css";
-            css.id = styleOverrideElementId;
-            css.appendChild(document.createTextNode(rule));
-            parent.appendChild(css);
-        }
-        return message.selectors.length > 0;
+        debug && console.log("[hide]", message.selectors);
+        return hideElementsUtil(message.selectors, message.method);
     }
     else if (message.type === "undohide") {
-        const existingElement = document.querySelector(styleSelector);
+        const existingElement = getStyleElementUtil();
         debug && console.log("[unhide]", !!existingElement);
         if (existingElement) {
             existingElement.remove();
@@ -81,9 +67,11 @@ export default function handleMessage(message, debug = false) {
     }
     else if (message.type === "matches") {
         const matched = matches(message.config);
+        debug && console.log("[matches?]", message.config.type, JSON.stringify(message.config), matched);
         return matched;
     }
     else if (message.type === "executeAction") {
+        debug && console.log("[executeAction]", message);
         actionQueue = actionQueue.then(() => executeAction(message.config, message.param));
         return true;
     }