@daemonitor/plugins 1.0.3 → 1.1.1

package/dist/index.js

@@ -1,6 +1,9 @@
-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";
+// Export core plugin utilities
+export { PluginConfigProvider } from "./lib/PluginConfigProvider";
+export { PluginManager } from "./lib/PluginManager";
+export { PluginLoader } from "./lib/PluginLoader";
+// Only export creation functions, not types
+export { createBasePlugin } from "./lib/BasePlugin";
+export { createMonitoringPlugin } from "./lib/MonitoringPlugin";
+// Export the PM2 plugin factory function
+export { createPM2Plugin } from "./plugins/monitoring/PM2Plugin";

package/dist/lib/BasePlugin.js

@@ -1,17 +1,27 @@
-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;
-    }
+import { PluginConfigProvider } from "./PluginConfigProvider";
+let currentPluginIndex = 0;
+export function createBasePlugin(alias, name, description, setupFn, monitorFn, refreshFn, teardownFn) {
+    const config = PluginConfigProvider.get(alias);
+    const plugin = {
+        alias,
+        name,
+        description,
+        config,
+        setup: async function () {
+            return setupFn(this);
+        },
+        monitor: async function () {
+            return monitorFn(this);
+        },
+        refresh: async function () {
+            return refreshFn(this);
+        },
+        teardown: async function () {
+            return teardownFn(this);
+        },
+        getName: function () {
+            return this.name;
+        }
+    };
+    return plugin;
 }
-export { BasePlugin };

package/dist/lib/MonitoringPlugin.js

@@ -1,24 +1,40 @@
-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);
+import { PluginManager } from "./PluginManager";
+let monitoringPluginIndex = 0;
+export function createMonitoringPlugin(alias, name, description, setupFn, monitorFn, refreshFn, teardownFn) {
+    const config = PluginManager.getConfig ? PluginManager.getConfig(alias) : {};
+    const pluginIndex = monitoringPluginIndex++;
+    const instanceName = config?.name || name;
+    const uniqueId = config?.uniqueId || `${alias}-${pluginIndex}`;
+    const plugin = {
+        alias,
+        name,
+        description,
+        config,
+        instanceName,
+        uniqueId,
+        pluginIndex,
+        setup: async function () {
+            return setupFn(this);
+        },
+        monitor: async function () {
+            return monitorFn(this);
+        },
+        refresh: async function () {
+            return refreshFn(this);
+        },
+        teardown: async function () {
+            return teardownFn(this);
+        },
+        getName: function () {
+            return this.name;
+        },
+        send: async function (data, unique_id) {
+            // Access API_CONNECTIONS from PluginManager
+            const connections = PluginManager.API_CONNECTIONS || [];
+            for (const apiConnection of connections) {
+                await apiConnection.sendData({ name: this.instanceName, ...data }, this.name, unique_id || this.uniqueId);
+            }
         }
-    }
-    getName() {
-        return this.name;
-    }
+    };
+    return plugin;
 }
-export { MonitoringPlugin };

package/dist/lib/PluginConfigProvider.js

@@ -1,10 +1,17 @@
-class PluginConfigProvider {
+export class PluginConfigProvider {
     static config = {};
-    static async get(key) {
-        if (!PluginConfigProvider.config[key]) {
-            return null;
-        }
-        return PluginConfigProvider.config[key];
+    /**
+     * Load the full client config (the parsed client.config.json). Per-plugin
+     * sections are keyed by alias (e.g. config.docker, config.pm2). Without this
+     * the per-alias `get()` below always returns null and plugins silently fall
+     * back to their hardcoded defaults.
+     */
+    static loadAll(config) {
+        PluginConfigProvider.config = config || {};
+    }
+    /** Synchronous lookup of a plugin's config section by alias. */
+    static get(key) {
+        const section = PluginConfigProvider.config?.[key];
+        return section == null ? null : section;
     }
 }
-export { PluginConfigProvider };

package/dist/lib/PluginLoader.js

@@ -1,13 +1,28 @@
-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);
+import pluginsFactory from "../plugins/index";
+export const PluginLoader = {
+    // Load all plugins using the factories
+    loadPlugins: async function () {
+        try {
+            const plugins = [];
+            // Create plugin instances using the factory functions
+            const pluginFactories = pluginsFactory;
+            for (const pluginName of Object.keys(pluginFactories)) {
+                const createPlugin = pluginFactories[pluginName];
+                if (typeof createPlugin === 'function') {
+                    try {
+                        const plugin = await createPlugin();
+                        plugins.push(plugin);
+                    }
+                    catch (err) {
+                        console.error(`Error creating plugin ${pluginName}:`, err);
+                    }
+                }
+            }
+            return plugins;
+        }
+        catch (error) {
+            console.error("Error loading plugins:", error);
+            return [];
         }
-        return plugins;
     }
-}
+};

package/dist/lib/PluginManager.js

@@ -1,19 +1,37 @@
-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 => {
+import { PluginLoader } from "./PluginLoader";
+import { PluginConfigProvider } from "./PluginConfigProvider";
+// Singleton state
+const state = {
+    availablePlugins: [],
+    activePlugins: [],
+    configuredPlugins: []
+};
+// Export as namespace instead of class
+export const PluginManager = {
+    // Global connections array
+    API_CONNECTIONS: [],
+    // Initialize the manager. Accepts either the legacy string[] of plugin
+    // aliases, or the full client config object ({ plugins: [...], docker: {...}, ... }).
+    // Passing the full object also populates PluginConfigProvider so plugins
+    // receive their per-alias config section (dockerBin, refreshInterval, etc.).
+    initialize: async function (config) {
+        let configuredPlugins;
+        if (Array.isArray(config)) {
+            configuredPlugins = config;
+        }
+        else {
+            configuredPlugins = config?.plugins || [];
+            PluginConfigProvider.loadAll(config);
+        }
+        state.configuredPlugins = configuredPlugins.map((p) => String(p).toLowerCase());
+        await this.loadPlugins();
+        await this.setupAll();
+        return;
+    },
+    // Load all available plugins
+    loadPlugins: async function () {
+        try {
+            const plugins = await PluginLoader.loadPlugins();
             if (!plugins) {
                 throw new Error("Failed to load plugins.");
             }
@@ -23,47 +41,63 @@ class PluginManager {
             else {
                 console.log(`Loaded ${plugins.length} plugins.`);
             }
-            this.availablePlugins = plugins;
-        });
-    }
-    async addConnector(apiConnection) {
-        PluginManager.API_CONNECTIONS.push(apiConnection);
-    }
-    async setupAll() {
+            state.availablePlugins = plugins;
+        }
+        catch (error) {
+            console.error("Error loading plugins:", error);
+            throw error;
+        }
+    },
+    // Add a connector for plugins to use
+    addConnector: function (apiConnection) {
+        this.API_CONNECTIONS.push(apiConnection);
+    },
+    // Get connections for plugins
+    getConnections: function () {
+        return this.API_CONNECTIONS;
+    },
+    // Get config for a plugin by alias
+    getConfig: function (alias) {
+        return PluginConfigProvider.get(alias);
+    },
+    // Set up all the configured plugins
+    setupAll: async function () {
         console.log("Setting up plugins...");
-        // const configuredPlugins = await AppConfigProvider.get("plugins")
-        console.log("Configured plugins:", this.configuredPlugins.join(", "));
-        if (!this.configuredPlugins)
+        console.log("Configured plugins:", state.configuredPlugins.join(", "));
+        if (!state.configuredPlugins || state.configuredPlugins.length === 0) {
             throw new Error("No plugins configured. Set up config.json first.");
-        this.activePlugins = this.availablePlugins.filter(plugin => {
-            return this.configuredPlugins.includes(plugin.getName().toLowerCase());
+        }
+        state.activePlugins = state.availablePlugins.filter(plugin => {
+            return state.configuredPlugins.includes(plugin.getName().toLowerCase());
         });
-        if (!this.activePlugins)
+        if (state.activePlugins.length === 0) {
             throw new Error("No plugins to set up.");
-        for (const plugin of this.activePlugins) {
+        }
+        for (const plugin of state.activePlugins) {
             await plugin.setup();
         }
-    }
-    async monitorAll() {
+    },
+    // Start monitoring with all plugins
+    monitorAll: async function () {
         const results = [];
-        if (!this.availablePlugins)
+        if (!state.availablePlugins || state.availablePlugins.length === 0) {
             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)
+        }
+        if (this.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(`Monitoring ${state.activePlugins.length} plugins...`);
+        for (const plugin of state.activePlugins) {
             console.log(` + ${plugin.getName()}`);
-            const data = plugin.monitor();
+            const data = await plugin.monitor();
             results.push(data);
         }
         return results;
-    }
-    async teardownAll() {
-        for (const plugin of this.activePlugins) {
+    },
+    // Tear down all plugins
+    teardownAll: async function () {
+        for (const plugin of state.activePlugins) {
             await plugin.teardown();
         }
     }
-}
-export { PluginManager };
+};

package/dist/lib/processes.js

@@ -0,0 +1,36 @@
+// Aggregate named service processes (nginx, php-fpm, db, …) from `ps` output.
+// Used for host processes (OSPlugin) and per-container processes (LxcPlugin via
+// `lxc exec … ps`). MEM (rss) is exact; CPU is `ps` %cpu, which is the average
+// over each process's lifetime — a rough indicator for long-running daemons.
+// The command whose output parseProcesses() expects (headerless: comm rss pcpu).
+export const PS_CMD = "ps -eo comm=,rss=,pcpu=";
+const WATCH = [
+    { key: "nginx", test: (c) => c.startsWith("nginx") },
+    { key: "php-fpm", test: (c) => /^php-?fpm/i.test(c) },
+    { key: "mysql", test: (c) => c.startsWith("mysqld") || c.startsWith("mariadbd") },
+    { key: "postgres", test: (c) => c.startsWith("postgres") },
+    { key: "redis", test: (c) => c.startsWith("redis-server") || c.startsWith("redis") },
+    { key: "node", test: (c) => c.startsWith("node") },
+];
+export function parseProcesses(out) {
+    const agg = new Map();
+    for (const line of String(out || "").split("\n")) {
+        // Last two whitespace-separated tokens are rss + pcpu; the rest is comm
+        // (which may itself contain spaces/slashes, e.g. node process titles).
+        const m = line.trim().match(/^(.+?)\s+(\d+)\s+([\d.]+)$/);
+        if (!m)
+            continue;
+        const comm = m[1].trim();
+        const w = WATCH.find((x) => x.test(comm));
+        if (!w)
+            continue;
+        const cur = agg.get(w.key) || { name: w.key, count: 0, cpu: 0, mem: 0 };
+        cur.count++;
+        cur.cpu += Number(m[3]) || 0;
+        cur.mem += (Number(m[2]) || 0) * 1024; // rss KiB -> bytes
+        agg.set(w.key, cur);
+    }
+    return Array.from(agg.values())
+        .map((p) => ({ ...p, cpu: Math.round(p.cpu * 10) / 10 }))
+        .sort((a, b) => b.mem - a.mem);
+}

package/dist/plugins/index.js

@@ -1,12 +1,33 @@
-import { EwelinkPlugin } from "./monitoring/EwelinkPlugin.js";
-import { OSPlugin } from "./monitoring/OSPlugin.js";
-import { PM2Plugin } from "./monitoring/PM2Plugin.js";
-import { MongoDBPlugin } from "./monitoring/MongoDBPlugin.js";
-import { WebsitePlugin } from "./monitoring/WebsitePlugin.js";
+// Import plugin factory functions
+import { createPM2Plugin } from "./monitoring/PM2Plugin";
+import { createDockerPlugin } from "./monitoring/DockerPlugin";
+import { createLxcPlugin } from "./monitoring/LxcPlugin";
+import { createOSPlugin } from "./monitoring/OSPlugin";
+import { createWebsitePlugin } from "./monitoring/WebsitePlugin";
+import { createWordpressPlugin } from "./monitoring/WordpressPlugin";
+import { createLogWatchPlugin } from "./monitoring/LogWatchPlugin";
+import { createNetScanPlugin } from "./monitoring/NetScanPlugin";
+// In future, implement other plugin factory functions using the same pattern
+// import { createOSPlugin } from "./monitoring/OSPlugin"
+// import { createMongoDBPlugin } from "./monitoring/MongoDBPlugin"
+// import { createWebsitePlugin } from "./monitoring/WebsitePlugin"
+// import { createCloudflarePlugin } from "./monitoring/CloudflarePlugin"
+// import { createEwelinkPlugin } from "./monitoring/EwelinkPlugin"
+// Export factory functions to create plugin instances.
+// (Keys are display-only; the manager activates a plugin when its getName()
+// lowercased matches an alias in the config `plugins` array.)
 export default {
-    EwelinkPlugin,
-    MongoDBPlugin,
-    OSPlugin,
-    PM2Plugin,
-    WebsitePlugin
+    PM2Plugin: createPM2Plugin,
+    Docker: createDockerPlugin,
+    Lxc: createLxcPlugin,
+    OS: createOSPlugin,
+    Website: createWebsitePlugin,
+    Wordpress: createWordpressPlugin,
+    Logwatch: createLogWatchPlugin,
+    Netscan: createNetScanPlugin,
+    // CloudflarePlugin: createCloudflarePlugin,
+    // EwelinkPlugin: createEwelinkPlugin,
+    // MongoDBPlugin: createMongoDBPlugin,
+    // OSPlugin: createOSPlugin,
+    // WebsitePlugin: createWebsitePlugin,
 };

package/dist/plugins/monitoring/DockerPlugin.js

@@ -0,0 +1,170 @@
+import { createMonitoringPlugin } from "../../lib/MonitoringPlugin";
+import { exec } from "child_process";
+import { promisify } from "util";
+import { hostname } from "os";
+const execAsync = promisify(exec);
+const EXEC_OPTS = { maxBuffer: 32 * 1024 * 1024 }; // containers.length can be large
+const HEALTH_RE = /\((healthy|unhealthy|health: starting|starting)\)/i;
+/** Convert docker's "83.86MiB" / "1.952GiB" memory strings to bytes. */
+function memToBytes(value) {
+    if (!value)
+        return 0;
+    const unit = value.replace(/[0-9.\s]/g, "").toUpperCase();
+    const num = parseFloat(value.replace(/[^0-9.]/g, "")) || 0;
+    const mult = {
+        B: 1, KB: 1e3, KIB: 1024, MB: 1e6, MIB: 1024 ** 2,
+        GB: 1e9, GIB: 1024 ** 3, TB: 1e12, TIB: 1024 ** 4,
+    };
+    return Math.round(num * (mult[unit] ?? 1));
+}
+/**
+ * Collect all containers (including stopped) in a small, fixed number of
+ * exec calls regardless of how many containers exist:
+ *   1. `docker ps -a`      — names, image, state, status, compose labels
+ *   2. `docker stats`      — live CPU / memory for running containers (one batch)
+ *   3. `docker inspect`    — restart count, health, exit code (one batch)
+ */
+async function collectContainers(bin) {
+    const psFmt = '{{.ID}}|{{.Names}}|{{.Image}}|{{.State}}|{{.Status}}|{{.Label "com.docker.compose.project"}}|{{.Label "com.docker.compose.service"}}';
+    const { stdout: psOut } = await execAsync(`${bin} ps -a --format '${psFmt}'`, EXEC_OPTS);
+    const containers = [];
+    const byId = new Map();
+    for (const line of psOut.split("\n")) {
+        if (!line.trim())
+            continue;
+        const [id, name, image, state, status, project, service] = line.split("|");
+        const running = (state || "").toLowerCase() === "running";
+        const healthMatch = HEALTH_RE.exec(status || "");
+        const c = {
+            id,
+            name,
+            service: service || "",
+            image,
+            state: state || "",
+            status: status || "",
+            running,
+            health: healthMatch ? healthMatch[1].replace(/^health:\s*/i, "").toLowerCase() : "",
+            cpu: 0, mem: 0, memLimit: 0, memPercent: 0, restarts: 0, exitCode: 0,
+        };
+        c.__project = project || "";
+        containers.push(c);
+        byId.set(id, c);
+    }
+    if (!containers.length)
+        return containers;
+    // 2. live stats for running containers (one batched call, best-effort)
+    try {
+        const { stdout: statsOut } = await execAsync(`${bin} stats --no-stream --format '{{.ID}}|{{.CPUPerc}}|{{.MemUsage}}|{{.MemPerc}}'`, EXEC_OPTS);
+        for (const line of statsOut.split("\n")) {
+            if (!line.trim())
+                continue;
+            const [id, cpuPerc, memUsage, memPerc] = line.split("|");
+            const c = byId.get(id);
+            if (!c)
+                continue;
+            c.cpu = parseFloat((cpuPerc || "").replace("%", "")) || 0;
+            const [used, limit] = (memUsage || "").split("/").map((p) => p.trim());
+            c.mem = memToBytes(used);
+            c.memLimit = memToBytes(limit);
+            c.memPercent = parseFloat((memPerc || "").replace("%", "")) || 0;
+        }
+    }
+    catch (err) {
+        console.error("docker: stats collection failed:", err.message);
+    }
+    // 3. restart count + exit code (one batched inspect, best-effort).
+    // NOTE: we deliberately do NOT read .State.Health here — on some engines the
+    // template errors with `map has no entry for key "Health"` for containers
+    // without a healthcheck, which would fail the whole batch. Health is parsed
+    // from the ps `Status` string ("(healthy)" / "(unhealthy)") instead.
+    try {
+        const ids = containers.map((c) => c.id).join(" ");
+        const inspectFmt = '{{.Id}}|{{.RestartCount}}|{{.State.ExitCode}}';
+        const { stdout: inspOut } = await execAsync(`${bin} inspect --format '${inspectFmt}' ${ids}`, EXEC_OPTS);
+        for (const line of inspOut.split("\n")) {
+            if (!line.trim())
+                continue;
+            const [fullId, restarts, exitCode] = line.split("|");
+            const c = byId.get(fullId.slice(0, 12));
+            if (!c)
+                continue;
+            c.restarts = parseInt(restarts, 10) || 0;
+            c.exitCode = parseInt(exitCode, 10) || 0;
+        }
+    }
+    catch (err) {
+        console.error("docker: inspect collection failed:", err.message);
+    }
+    return containers;
+}
+export function createDockerPlugin() {
+    let refreshTimer = null;
+    let available = false;
+    let dockerBin = "docker";
+    const setupFn = async (plugin) => {
+        dockerBin = plugin.config?.dockerBin || plugin.config?.bin || "docker";
+        try {
+            await execAsync(`${dockerBin} version --format '{{.Server.Version}}'`, EXEC_OPTS);
+            available = true;
+        }
+        catch (err) {
+            // Don't throw: a missing docker engine shouldn't take down the whole client.
+            available = false;
+            console.error(`docker: engine not available via "${dockerBin}" — plugin idle:`, err.message);
+        }
+    };
+    const refreshFn = async (plugin) => {
+        if (!available)
+            return;
+        try {
+            const all = await collectContainers(dockerBin);
+            // Optional filtering by compose project.
+            const only = plugin.config?.projects || [];
+            const exclude = plugin.config?.exclude || [];
+            // Group by compose project (standalone containers group under their own name).
+            const groups = new Map();
+            for (const c of all) {
+                const project = c.__project || c.name;
+                delete c.__project;
+                if (only.length && !only.includes(project))
+                    continue;
+                if (exclude.includes(project))
+                    continue;
+                const arr = groups.get(project) || [];
+                arr.push(c);
+                groups.set(project, arr);
+            }
+            const host = hostname();
+            for (const [project, containers] of groups) {
+                const running = containers.filter((c) => c.running).length;
+                const payload = {
+                    name: project,
+                    engine: "docker",
+                    host,
+                    project,
+                    running,
+                    total: containers.length,
+                    containers,
+                    timestamp: Date.now(),
+                };
+                await plugin.send(payload, `docker-${project}`);
+            }
+        }
+        catch (err) {
+            console.error("docker: refresh error:", err.message);
+        }
+    };
+    const monitorFn = async (plugin) => {
+        if (!available)
+            return;
+        await refreshFn(plugin);
+        refreshTimer = setInterval(() => refreshFn(plugin), plugin.config?.refreshInterval || 60000);
+    };
+    const teardownFn = async () => {
+        if (refreshTimer)
+            clearInterval(refreshTimer);
+        refreshTimer = null;
+    };
+    return createMonitoringPlugin("docker", "docker", "Docker container monitoring plugin", setupFn, monitorFn, refreshFn, teardownFn);
+}
+export default createDockerPlugin;