pluginManager.js

import fs from "fs";
import path from "path";
import { promisify } from "util";

import env from "./env.js";
import database from "./database.js";

const fsReaddirAsync = promisify(fs.readdir);

String.prototype.replaceAll = function(strReplace, strWith) {
    // See http://stackoverflow.com/a/3561711/556609
    var esc = strReplace.replace(/[-\/\\^$*+?.()|[\]{}]/g, '\\$&');
    var reg = new RegExp(esc, 'ig');
    return this.replace(reg, strWith);
};

class PluginManager {
  constructor(isRss) {
    this.plugins = [];
    this.rssQueue = [];
    this.rssSendInterval = setInterval(() => this.processRssQueue(), 4000);
  }
  startInterval() {
    if (!this.rssSendInterval) {
      this.rssSendInterval = setInterval(() => this.processRssQueue(), 4000);
    }
  }

  async loadPlugins() {
    const internalPluginFiles = await fsReaddirAsync("src/plugins");
    const thirdPartyFiles = await fsReaddirAsync(
      path.join(env.DATA_PATH, "plugins")
    ).catch((e) => []);

    const internalPlugins = await Promise.all(
      internalPluginFiles
        .filter((f) => !f.endsWith(".src"))
        .map((f) => import("./" + path.join("plugins", f)))
    );

    const thirdPartyPlugins = await Promise.all(
      thirdPartyFiles.map((f) => import("./" + path.join("plugins", f)))
    );

    this.plugins = [].concat(internalPlugins.map((p) => p.default)).concat(
      thirdPartyPlugins.map((p) => {
        p.default.thirdParty = true;
        return p.default;
      })
    );
    const pluginsUsedInGroups = new Set(
      (database.data.groupPluginSettings || []).map((s) => s.pluginId)
    );
    this._initializedPlugins = new Set();
    await Promise.all(
      this.plugins
        .filter((p) => {
          const globallyEnabled = database.data.pluginSettings.find((ps) => ps.id === p.id)?.enabled ?? false;
          return globallyEnabled || pluginsUsedInGroups.has(p.id);
        })
        .map((p) => {
          this._initializedPlugins.add(p.id);
          return p.onPluginEnabled && p.onPluginEnabled();
        })
    );
  }

  async handleEvents(events, newData) {
    let hostEvents = [];
    let hostPlugins = {};

    if (newData.enabledNotifList) {
      const eventsList = Object.values(newData.enabledNotifList)
        .filter((e) => !e.value)
        .map((e) => e.events)
        .flat();
      hostEvents = [...eventsList];
    }

    if (!newData.enabledPlugins) {
      hostPlugins = {
        ALL_PLUGINS: {
          value: true,
        },
        TELEGRAM: {
          value: true,
        },
        SLACK: {
          value: true,
        },
        EMAIL: {
          value: true,
        },
      };
    } else {
      hostPlugins = newData.enabledPlugins;
    }
    const pluginsForHost = [
      ["telegram-notifications", "TELEGRAM"],
      ["slack-notifications", "SLACK"],
      ["gmail-notifications", "EMAIL"],
      ["email-notifications", "EMAIL"],
    ];
    function getEnabledPluginsForHost() {
      if (hostPlugins.ALL_PLUGINS.value) {
        return pluginsForHost.map((p) => {
          return p[0];
        });
      } else {
        let newArr = [];
        pluginsForHost.forEach((p) => {
          if (hostPlugins[p[1]].value) {
            newArr.push(p[0]);
          }
        });
        return newArr;
      }
    }

    const enabledPlugins = getEnabledPluginsForHost();

    for (let eventType of events) {
      console.log(`[PluginManager] Event: ${eventType} | host: ${newData.HOST_NAME || newData.url || '?'} | hostEvents disabled: [${hostEvents.join(',')}] | enabledPlugins: [${enabledPlugins.join(',')}]`);

      const plugins = this.plugins
        .map((p) => {
          const globalSettings =
            database.data.pluginSettings.find((ps) => ps.id === p.id) || {};
          // Merge group-specific plugin settings on top of global settings
          const groupEntry = newData.HOST_GROUP?.pluginSettings?.[p.id];
          const settings = groupEntry
            ? {
                ...globalSettings,
                params: { ...globalSettings.params, ...groupEntry.params },
                // Only override enabledEvents when explicitly set in group entry
                ...('enabledEvents' in groupEntry ? { enabledEvents: groupEntry.enabledEvents } : {}),
              }
            : globalSettings;
          return { plugin: p, settings };
        })

        .filter((p) => {
          const effectiveEnabledEvents = p.plugin.getEffectiveEnabledEvents
            ? p.plugin.getEffectiveEnabledEvents({ data: newData, settings: p.settings })
            : p.settings.enabledEvents;
          const hasGroupOverride = !!newData.HOST_GROUP?.pluginSettings?.[p.plugin.id];
          const effectiveEnabled = hasGroupOverride || p.settings.enabled;
          const pass =
            effectiveEnabled &&
            effectiveEnabledEvents?.includes(eventType) &&
            !hostEvents.includes(eventType) &&
            enabledPlugins.includes(p.plugin.id);
          if (!pass) {
            console.log(`[PluginManager] Skip plugin ${p.plugin.id}: enabled=${effectiveEnabled}(group=${hasGroupOverride}) hasEvent=${effectiveEnabledEvents?.includes(eventType)} notSuppressed=${!hostEvents.includes(eventType)} inEnabledList=${enabledPlugins.includes(p.plugin.id)}`);
          }
          return pass;
        });

      console.log(`[PluginManager] Dispatching ${eventType} to ${plugins.length} plugin(s): [${plugins.map(p => p.plugin.id).join(',')}]`);

      // handle event by all plugins in parallel
      await Promise.all(
        plugins.map(async (p) => {
          try {
            await p.plugin.handleEvent({
              eventType,
              data: newData,
              settings: p.settings,
            });
          } catch (e) {
            console.error("Error in plugin", p.plugin.id, e, "stack:", e.stack);
          }
        })
      );
    }
  }

  async processRssQueue() {
    if (this.rssQueue.length) {
      const { rssFormatedMessage, enabledPlugins, hostGroup } = this.rssQueue.shift();
      const hostPlugins = enabledPlugins || {
        ALL_PLUGINS: {
          value: true,
        },
        TELEGRAM: {
          value: true,
        },
        SLACK: {
          value: true,
        },
        EMAIL: {
          value: true,
        },
      };
      const pluginsForHost = [
        ["telegram-notifications", "TELEGRAM"],
        ["slack-notifications", "SLACK"],
        ["gmail-notifications", "EMAIL"],
        ["email-notifications", "EMAIL"],
      ];
      function getEnabledPluginsForHost() {
        if (hostPlugins.ALL_PLUGINS.value) {
          return pluginsForHost.map((p) => {
            return p[0];
          });
        } else {
          let newArr = [];
          pluginsForHost.forEach((p) => {
            if (hostPlugins[p[1]].value) {
              newArr.push(p[0]);
            }
          });
          return newArr;
        }
      }
      const enabledPluginsArr = getEnabledPluginsForHost();

      const plugins = this.plugins
        .map((p) => {
          const globalSettings = database.data.pluginSettings.find((ps) => ps.id === p.id) || {};
          const groupEntry = hostGroup?.pluginSettings?.[p.id];
          const settings = groupEntry
            ? { ...globalSettings, params: { ...globalSettings.params, ...groupEntry.params } }
            : globalSettings;
          return { plugin: p, settings };
        })
        .filter((p) => {
          const hasGroupOverride = !!hostGroup?.pluginSettings?.[p.plugin.id];
          return (hasGroupOverride || p.settings.enabled) && enabledPluginsArr.includes(p.plugin.id);
        });

      await Promise.all(
        plugins.map(async (p) => {
          try {
            await p.plugin.sendMessage(p.settings, rssFormatedMessage);
          } catch (e) {
            console.error("Error in plugin", p.plugin.id, e, "stack:", e.stack);
          }
        })
      );
    }
    const rssMonitor = database.data.httpMonitoringData.find(
      (p) => p.monitor_type === "rss_parser"
    );
    if (!rssMonitor) {
      this.stopProcessRssQueue();
    }
  }


  async handleRssEvent({ rssFormatedMessage, enabledPlugins, data, hostGroup }) {
    let needExceptMessage = false;
    let needBeHighlighted = false;
    let fullMessageString = "";
    let messageString = "";
    let excludedFields = [
      "content:encoded",
      "content:encodedSnippet",
      "contentSnippet",
      "isoDate",
    ];
    const exceptionsList =
      data &&
      data.rssFilters.filter((e) => {
        return e.name === "Exclude";
      })[0].data;

    const highlightedList =
      data &&
      data.rssFilters.filter((e) => {
        return e.name === "Highlighted";
      })[0].data;

    const onlyPrio =
      data &&
      data.rssFilters.filter((e) => {
        return e.name === "OnlyPrio";
      })[0].data;

    Object.entries(rssFormatedMessage).forEach((e) => {
      fullMessageString = `${fullMessageString}${e[0]}${e[1]}`;
    });

    exceptionsList.forEach((ex) => {
      if (fullMessageString.toLowerCase().includes(ex.toLowerCase())) {
        needExceptMessage = true;
      }
    });

    highlightedList.forEach((hig) => {
      if (fullMessageString.toLowerCase().includes(hig.toLowerCase())) {
        needBeHighlighted = true;
        messageString = messageString.replaceAll(hig.toLowerCase(), `🔥${hig}`);
      }
    });

    const prepareMessage = (cutField) => {
      const CHARACTERS_LIMIT = 500;
      Object.entries(rssFormatedMessage).forEach((e) => {
        if (!excludedFields.includes(e[0])) {
          if (!cutField) {
            messageString = `${messageString}\n✅-${e[0]
              .charAt(0)
              .toUpperCase()}${e[0].slice(1)}:${e[1]})`;
          } else {
            messageString = `${messageString}\n⚠️-${e[0]
              .charAt(0)
              .toUpperCase()}${e[0].slice(1)}:${e[1].slice(
              0,
              CHARACTERS_LIMIT
            )}(short message...)`;
          }
        }
      });
    };
    prepareMessage();
    if (messageString.length > 4000) {
      messageString = "";
      prepareMessage(true);
    }
    if (!needExceptMessage) {
      if (needBeHighlighted) {
        messageString = `🔥🔥🔥 [PRIO] \n${messageString}\n🔥🔥🔥}`;
      }
      if (!onlyPrio || needBeHighlighted) {
        this.rssQueue.push({ rssFormatedMessage: messageString, enabledPlugins, hostGroup });
      }
    }
  }

  stopProcessRssQueue() {
    clearInterval(this.rssSendInterval);
    this.rssSendInterval = null;
  }
}

let _instance;
const PluginManagerSingleton = () => {
  if (!_instance) {
    _instance = new PluginManager();
  }
  return _instance;
};

export default PluginManagerSingleton;