@daemonitor/plugins 1.0.0

package/dist/index.js

@@ -0,0 +1,6 @@
+export { PluginConfigProvider } from "./lib/PluginConfigProvider.js";
+export { BasePlugin } from "./lib/BasePlugin.js";
+export { MonitoringPlugin } from "./lib/MonitoringPlugin.js";
+export { PluginLoader } from "./lib/PluginLoader.js";
+export { PluginManager } from "./lib/PluginManager.js";
+export * as Plugins from "./plugins/index.js";

package/dist/lib/BasePlugin.js

@@ -0,0 +1,17 @@
+import { PluginConfigProvider } from "./PluginConfigProvider.js";
+class BasePlugin {
+    static currentPluginIndex = 0;
+    alias;
+    name;
+    description;
+    config;
+    constructor(alias, name, description) {
+        this.config = PluginConfigProvider.get(alias);
+        this.name = name;
+        this.description = description;
+    }
+    getName() {
+        return this.name;
+    }
+}
+export { BasePlugin };

package/dist/lib/MonitoringPlugin.js

@@ -0,0 +1,24 @@
+import { BasePlugin } from "./BasePlugin.js";
+import { PluginManager } from "@daemonitor/plugins";
+class MonitoringPlugin extends BasePlugin {
+    static currentPluginIndex = 0;
+    instanceName;
+    refreshTimer;
+    uniqueId;
+    pluginIndex;
+    constructor(alias, name, description) {
+        super(alias, name, description);
+        this.pluginIndex = MonitoringPlugin.currentPluginIndex++;
+        this.instanceName = this.config.name || name;
+        this.uniqueId = this.config?.uniqueId || this.alias + "-" + this.pluginIndex;
+    }
+    async send(data, unique_id) {
+        for (const apiConnection of PluginManager.API_CONNECTIONS) {
+            await apiConnection.sendData({ name: this.instanceName, ...data }, this.name, unique_id || this.uniqueId);
+        }
+    }
+    getName() {
+        return this.name;
+    }
+}
+export { MonitoringPlugin };

package/dist/lib/PluginConfigProvider.js

@@ -0,0 +1,10 @@
+class PluginConfigProvider {
+    static config = {};
+    static async get(key) {
+        if (!PluginConfigProvider.config[key]) {
+            return null;
+        }
+        return PluginConfigProvider.config[key];
+    }
+}
+export { PluginConfigProvider };

package/dist/lib/PluginLoader.js

@@ -0,0 +1,13 @@
+import PluginClasses from "../plugins/index.js";
+export class PluginLoader {
+    static async loadPlugins() {
+        const plugins = [];
+        const pluginClasses = PluginClasses;
+        for (const file of Object.keys(pluginClasses)) {
+            const PluginClass = pluginClasses[file];
+            const pluginInstance = new PluginClass();
+            plugins.push(pluginInstance);
+        }
+        return plugins;
+    }
+}

package/dist/lib/PluginManager.js

@@ -0,0 +1,69 @@
+import { PluginLoader } from "./PluginLoader.js";
+class PluginManager {
+    static API_CONNECTIONS = [];
+    availablePlugins;
+    activePlugins;
+    configuredPlugins;
+    constructor(configuredPlugins) {
+        this.availablePlugins = [];
+        this.activePlugins = [];
+        this.configuredPlugins = configuredPlugins;
+    }
+    async initialize() {
+        return this.loadPlugins().then(() => this.setupAll());
+    }
+    async loadPlugins() {
+        return await PluginLoader.loadPlugins().then(plugins => {
+            if (!plugins) {
+                throw new Error("Failed to load plugins.");
+            }
+            else if (plugins.length === 0) {
+                throw new Error("No plugins found.");
+            }
+            else {
+                console.log(`Loaded ${plugins.length} plugins.`);
+            }
+            this.availablePlugins = plugins;
+        });
+    }
+    async addConnector(apiConnection) {
+        PluginManager.API_CONNECTIONS.push(apiConnection);
+    }
+    async setupAll() {
+        console.log("Setting up plugins...");
+        // const configuredPlugins = await AppConfigProvider.get("plugins")
+        console.log("Configured plugins:", this.configuredPlugins.join(", "));
+        if (!this.configuredPlugins)
+            throw new Error("No plugins configured. Set up config.json first.");
+        this.activePlugins = this.availablePlugins.filter(plugin => {
+            return this.configuredPlugins.includes(plugin.getName().toLowerCase());
+        });
+        if (!this.activePlugins)
+            throw new Error("No plugins to set up.");
+        for (const plugin of this.activePlugins) {
+            await plugin.setup();
+        }
+    }
+    async monitorAll() {
+        const results = [];
+        if (!this.availablePlugins)
+            throw new Error("Plugins not loaded yet! Call loadPlugins() first.");
+        if (this.availablePlugins.length === 0)
+            throw new Error("No plugins loaded.");
+        if (!PluginManager.API_CONNECTIONS || PluginManager.API_CONNECTIONS.length === 0)
+            throw new Error("No connections loaded yet! Call addConnector() first.");
+        console.log(`Monitoring ${this.activePlugins.length} plugins...`);
+        for (const plugin of this.activePlugins) {
+            console.log(` + ${plugin.getName()}`);
+            const data = plugin.monitor();
+            results.push(data);
+        }
+        return results;
+    }
+    async teardownAll() {
+        for (const plugin of this.activePlugins) {
+            await plugin.teardown();
+        }
+    }
+}
+export { PluginManager };

package/dist/plugins/index.js

@@ -0,0 +1,10 @@
+import { EwelinkPlugin } from "./monitoring/EwelinkPlugin.js";
+import { OSPlugin } from "./monitoring/OSPlugin.js";
+import { PM2Plugin } from "./monitoring/PM2Plugin.js";
+import { WebsitePlugin } from "./monitoring/WebsitePlugin.js";
+export default {
+    EwelinkPlugin,
+    OSPlugin,
+    PM2Plugin,
+    WebsitePlugin
+};

package/dist/plugins/monitoring/EwelinkPlugin.js

@@ -0,0 +1,57 @@
+import ewelink from "ewelink-api";
+import * as dotenv from "dotenv";
+import { MonitoringPlugin } from "../../lib/MonitoringPlugin.js";
+dotenv.config();
+export class EwelinkPlugin extends MonitoringPlugin {
+    connection;
+    devices;
+    constructor() {
+        super("ewelink", "Ewelink", "Ewelink Addon");
+        this.name = "Ewelink";
+        this.description = "Ewelink Addon";
+    }
+    async setup() {
+        if (!process.env.EWELINK_EMAIL || !process.env.EWELINK_PASSWORD) {
+            console.error("EWELINK_EMAIL and EWELINK_PASSWORD environment variables must be set");
+            return Promise.reject();
+        }
+        this.connection = new ewelink({
+            email: process.env.EWELINK_EMAIL,
+            password: process.env.EWELINK_PASSWORD
+        });
+        this.refresh().then(() => { });
+        return Promise.resolve();
+    }
+    async get(key) {
+        let [deviceName, propertiesString] = key.split(":");
+        deviceName = deviceName.toLowerCase();
+        const properties = propertiesString.split(",");
+        const device = this.devices?.find((d) => d.name.toLowerCase() === deviceName);
+        if (!device) {
+            return Promise.reject();
+        }
+        const values = {};
+        for (const property of properties) {
+            values[property] = device?.params[property];
+        }
+        return Promise.resolve(values);
+    }
+    async refresh() {
+        /* get all devices */
+        return this.connection.getDevices().then((devices) => {
+            this.devices = devices;
+            for (const device of this.devices) {
+                this.send(device, device.deviceid);
+            }
+        });
+    }
+    async monitor() {
+        this.refreshTimer = setInterval(this.refresh.bind(this), this.config.refreshInterval || 30000);
+    }
+    async teardown() {
+        clearInterval(this.refreshTimer);
+    }
+    async render() {
+        return this.devices;
+    }
+}

package/dist/plugins/monitoring/OSPlugin.js

@@ -0,0 +1,43 @@
+import { arch, cpus, freemem, hostname, loadavg, networkInterfaces, platform, release, totalmem, type, uptime } from "os";
+import { MonitoringPlugin } from "../../lib/MonitoringPlugin.js";
+export class OSPlugin extends MonitoringPlugin {
+    constructor() {
+        super("os", "OS", "OS Monitoring Plugin");
+    }
+    async setup() {
+        // no setup required
+        return Promise.resolve();
+    }
+    async refresh() {
+        const interfaces = networkInterfaces();
+        const addresses = {};
+        for (let [key, value] of Object.entries(interfaces)) {
+            if (value) {
+                let found = value.find(port => (port.family === "IPv4") && (port.internal !== true));
+                if (found) {
+                    let { address, netmask, mac } = found;
+                    addresses[key] = { address, netmask, mac };
+                }
+            }
+        }
+        await this.send({
+            addresses,
+            totalmem: totalmem(),
+            freemem: freemem(),
+            loadavg: loadavg(),
+            uptime: uptime(),
+            hostname: hostname(),
+            platform: platform(),
+            release: release(),
+            type: type(),
+            arch: arch(),
+            cpus: cpus()
+        });
+    }
+    async monitor() {
+        this.refreshTimer = setInterval(this.refresh.bind(this), this.config.refreshInterval || 5000);
+    }
+    async teardown() {
+        clearInterval(this.refreshTimer);
+    }
+}

package/dist/plugins/monitoring/PM2Plugin.js

@@ -0,0 +1,80 @@
+import pm2 from "pm2";
+import { MonitoringPlugin } from "../../lib/MonitoringPlugin.js";
+export class PM2Plugin extends MonitoringPlugin {
+    constructor() {
+        super("pm2", "PM2", "PM2 Monitoring Plugin");
+    }
+    async setup() {
+        return new Promise((resolve, reject) => {
+            try {
+                pm2.connect(async (err) => {
+                    if (err) {
+                        console.error(err);
+                        reject(err);
+                    }
+                    else {
+                        resolve();
+                    }
+                });
+            }
+            catch (e) {
+                console.error("ERROR", e);
+                reject(e);
+            }
+        });
+    }
+    async refresh() {
+        pm2.list(async (err, list) => {
+            if (!err) {
+                for (const p of list) {
+                    let { pid, name, pm_id, monit,
+                    // exit_code,
+                    // prev_restart_delay,
+                    // versioning,
+                    // axm_dynamic,
+                    // axm_actions,
+                    // merge_logs,
+                    // vizion,
+                    // instance_var,
+                    // pmx,
+                    // automation,
+                    // treekill,
+                    // windowsHide,
+                    // kill_retry_time
+                     } = p;
+                    let { username, watch, axm_options, axm_monitor, node_version, unique_id, restart_time, created_at, unstable_restarts, autorestart, status, pm_uptime } = p.pm2_env;
+                    const payload = {
+                        updated: (new Date()).getTime(),
+                        created_at,
+                        unstable_restarts,
+                        restarts: restart_time,
+                        pid,
+                        name,
+                        pm_id,
+                        monit,
+                        username,
+                        watch,
+                        axm_options,
+                        axm_monitor,
+                        node_version,
+                        unique_id,
+                        restart_time,
+                        autorestart,
+                        status,
+                        pm_uptime,
+                    };
+                    await this.send(payload, `${unique_id}-${pm_id}`);
+                }
+            }
+            else {
+                console.error(err);
+            }
+        });
+    }
+    async monitor() {
+        this.refreshTimer = setInterval(this.refresh.bind(this), this.config.refreshInterval || 5000);
+    }
+    async teardown() {
+        clearInterval(this.refreshTimer);
+    }
+}

package/dist/plugins/monitoring/WebsitePlugin.js

@@ -0,0 +1,46 @@
+import { MonitoringPlugin } from "../../lib/MonitoringPlugin.js";
+export class WebsitePlugin extends MonitoringPlugin {
+    constructor() {
+        super("website", "Website", "Website Monitoring Plugin");
+    }
+    async setup() {
+        // no setup required
+        return Promise.resolve();
+    }
+    async refresh() {
+        const startTimestamp = Date.now();
+        const result = await fetch(this.config.url);
+        const endTimestamp = Date.now();
+        const text = await result.text();
+        const status = result.status;
+        const headers = result.headers;
+        const ok = result.ok;
+        const redirected = result.redirected;
+        const type = result.type;
+        const url = result.url;
+        const body = text;
+        const duration = endTimestamp - startTimestamp;
+        const expectedStrings = this.config.expectedStrings || [];
+        const unexpectedStrings = this.config.unexpectedStrings || [];
+        const hasAllExpectedStrings = expectedStrings.every(expectedString => body.indexOf(expectedString) !== -1);
+        const hasAnyUnexpectedStrings = unexpectedStrings.some(unexpectedString => body.indexOf(unexpectedString) !== -1);
+        await this.send({
+            status,
+            duration,
+            headers,
+            ok,
+            redirected,
+            type,
+            url,
+            body,
+            hasAllExpectedStrings,
+            hasAnyUnexpectedStrings
+        });
+    }
+    async monitor() {
+        this.refreshTimer = setInterval(this.refresh.bind(this), this.config.refreshInterval || 5000);
+    }
+    async teardown() {
+        clearInterval(this.refreshTimer);
+    }
+}

package/package.json

@@ -0,0 +1,42 @@
+{
+  "name": "@daemonitor/plugins",
+  "version": "1.0.0",
+  "description": "daemonitor plugins",
+  "types": "types/index.d.ts",
+  "main": "dist/index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "files": [
+    "dist",
+    "types"
+  ],
+  "type": "module",
+  "author": "",
+  "license": "ISC",
+  "packageManager": "pnpm@8.2.0",
+  "dependencies": {
+    "dotenv": "^16.0.3",
+    "ewelink-api": "^3.1.1",
+    "node-machine-id": "^1.1.12",
+    "ohmyfetch": "^0.4.21",
+    "pm2": "^5.1.0",
+    "string-to-color": "^2.2.2",
+    "ts-node": "^10.9.1",
+    "@daemonitor/common": "file:../common",
+    "tsconfig-paths": "^4.2.0"
+  },
+  "exports": {
+    ".": "./dist/index.js",
+    "./types": "./dist/types/index.js"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/daemonitor/plugins.git"
+  },
+  "bugs": {
+    "url": "https://github.com/daemonitor/plugins/issues"
+  },
+
+  "homepage": "https://github.com/daemonitor/plugins#readme"
+}

package/types/index.d.ts

@@ -0,0 +1,71 @@
+declare module "@daemonitor/plugins" {
+    import { IConnector } from "@daemonitor/common"
+
+    export abstract class PluginConfigProvider {
+        static get(alias: string): any
+    }
+
+    export abstract class MonitoringPlugin extends BasePlugin {
+        static currentPluginIndex: number
+        protected instanceName: string
+        protected refreshTimer: any
+        protected uniqueId: string
+        protected pluginIndex: number
+
+        protected constructor(alias: string, name: string, description: string)
+
+        public send(data: any, unique_id?: string): Promise<void>
+
+        abstract setup(): Promise<void>;
+
+        abstract monitor(): Promise<any>;
+
+        abstract refresh(): Promise<void>;
+
+        abstract teardown(): Promise<void>;
+
+        getName(): string
+    }
+
+
+    export class PluginManager {
+
+        constructor(configuredPlugins: any)
+
+        static API_CONNECTIONS: IConnector[]
+
+        initialize(): Promise<void>
+
+        loadPlugins(): Promise<void>
+
+        setupAll(): Promise<void>
+
+        monitorAll(): Promise<any>
+
+        addConnector(connector: IConnector): Promise<void>
+
+        refreshAll(): Promise<void>
+
+        teardownAll(): Promise<void>
+    }
+
+    export abstract class BasePlugin {
+        static currentPluginIndex: number
+        protected alias: string
+        protected name: string
+        protected description: string
+        protected config: any
+
+        protected constructor(alias: string, name: string, description: string)
+
+        abstract setup(): Promise<void>;
+
+        abstract monitor(): Promise<any>;
+
+        abstract refresh(): Promise<void>;
+
+        abstract teardown(): Promise<void>;
+
+        getName(): string
+    }
+}