@daemonitor/plugins 1.0.3 → 1.1.0

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/nuxt.config.js

@@ -0,0 +1 @@
+export default defineNuxtConfig({});

package/dist/plugins/index.js

@@ -1,12 +1,27 @@
-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";
+// 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,
+    // CloudflarePlugin: createCloudflarePlugin,
+    // EwelinkPlugin: createEwelinkPlugin,
+    // MongoDBPlugin: createMongoDBPlugin,
+    // OSPlugin: createOSPlugin,
+    // WebsitePlugin: createWebsitePlugin,
 };

package/dist/plugins/monitoring/CloudflarePlugin.js

@@ -0,0 +1,84 @@
+import { MonitoringPlugin } from "../../lib/MonitoringPlugin.js";
+/**
+ * CloudflarePlugin - Receives push updates from Cloudflare Workers
+ *
+ * This plugin receives data directly from a client's Cloudflare Worker
+ * rather than polling for it. The plugin sets up a monitoring endpoint,
+ * and the Cloudflare Worker pushes data to this endpoint on a schedule.
+ */
+export class CloudflarePlugin extends MonitoringPlugin {
+    lastReportedData = null;
+    lastReportTime = 0;
+    reportingKey;
+    maxDataAge;
+    constructor() {
+        super("cloudflare", "Cloudflare", "Cloudflare Deployment Monitoring Plugin (Push Mode)");
+        this.reportingKey = this.config.reportingKey;
+        this.maxDataAge = this.config.maxDataAge || 5 * 60 * 1000; // Default 5 minutes
+    }
+    async setup() {
+        if (!this.reportingKey) {
+            console.error("Cloudflare reporting key not provided");
+            return Promise.reject("Reporting key not provided");
+        }
+        // Register this instance to receive push updates
+        try {
+            // Normally this would make an API call to register this plugin instance
+            // to receive push updates from Cloudflare Workers with this reporting key
+            console.log(`Cloudflare plugin ready to receive push updates for key: ${this.reportingKey}`);
+            return Promise.resolve();
+        }
+        catch (error) {
+            console.error("Failed to register for Cloudflare push updates:", error);
+            return Promise.reject("Registration failed");
+        }
+    }
+    /**
+     * This method is called when data is pushed from a Cloudflare Worker
+     * It would typically be called by a webhook or socket connection
+     */
+    async receiveUpdate(data, key) {
+        // Verify the reporting key matches
+        if (key !== this.reportingKey) {
+            console.error("Invalid reporting key for Cloudflare update");
+            return;
+        }
+        this.lastReportedData = {
+            ...data,
+            receivedAt: Date.now()
+        };
+        this.lastReportTime = Date.now();
+        // Forward the data to the monitoring system
+        await this.send({
+            ...data,
+            timestamp: Date.now(),
+            status: "ok"
+        });
+    }
+    // This method checks if data is still fresh
+    async refresh() {
+        const now = Date.now();
+        const dataAge = now - this.lastReportTime;
+        // If we have data and it's still fresh, do nothing
+        if (this.lastReportedData && dataAge < this.maxDataAge) {
+            return;
+        }
+        // If data is stale or doesn't exist, report error status
+        await this.send({
+            timestamp: now,
+            error: `No data received in the last ${dataAge / 60000} minutes`,
+            status: "error",
+            lastReportTime: this.lastReportTime
+        });
+    }
+    async monitor() {
+        // Set up interval just to check for stale data
+        this.refreshTimer = setInterval(this.refresh.bind(this), this.config.refreshInterval || 60000 // Default to 1 minute
+        );
+    }
+    async teardown() {
+        // Unregister from receiving push updates
+        clearInterval(this.refreshTimer);
+        return Promise.resolve();
+    }
+}

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;

package/dist/plugins/monitoring/EwelinkPlugin.js

@@ -1,6 +1,6 @@
 import ewelink from "ewelink-api";
 import * as dotenv from "dotenv";
-import { MonitoringPlugin } from "../../lib/MonitoringPlugin.js";
+import { MonitoringPlugin } from "~/lib/MonitoringPlugin";
 dotenv.config();
 export class EwelinkPlugin extends MonitoringPlugin {
     connection;

package/dist/plugins/monitoring/LxcPlugin.js

@@ -0,0 +1,126 @@
+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 };
+/** Parse LXD memory-limit strings like "1GB", "512MiB", "2GiB" to bytes. */
+function limitToBytes(value) {
+    if (!value)
+        return 0;
+    const unit = String(value).replace(/[0-9.\s]/g, "").toUpperCase();
+    const num = parseFloat(String(value).replace(/[^0-9.]/g, "")) || 0;
+    const mult = {
+        "": 1, 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));
+}
+export function createLxcPlugin() {
+    let refreshTimer = null;
+    let available = false;
+    let lxcBin = "lxc";
+    // cumulative CPU usage (ns) + wall clock (ms) per instance, for %-of-core calc
+    const prevCpu = new Map();
+    const setupFn = async (plugin) => {
+        lxcBin = plugin.config?.lxcBin || plugin.config?.bin || "lxc";
+        try {
+            await execAsync(`${lxcBin} version`, EXEC_OPTS);
+            available = true;
+        }
+        catch (err) {
+            available = false;
+            console.error(`lxc: "${lxcBin}" not available — plugin idle:`, err.message);
+        }
+    };
+    const refreshFn = async (plugin) => {
+        if (!available)
+            return;
+        try {
+            const { stdout } = await execAsync(`${lxcBin} list --format json`, EXEC_OPTS);
+            const instances = JSON.parse(stdout || "[]");
+            const only = plugin.config?.instances || [];
+            const exclude = plugin.config?.exclude || [];
+            const host = hostname();
+            const now = Date.now();
+            const groups = new Map();
+            for (const inst of instances) {
+                const name = inst.name;
+                if (!name)
+                    continue;
+                if (only.length && !only.includes(name))
+                    continue;
+                if (exclude.includes(name))
+                    continue;
+                const running = String(inst.status || "").toLowerCase() === "running";
+                const st = inst.state || {};
+                // CPU %: delta of cumulative usage(ns) over wall time -> % of one core
+                const usage = Number(st.cpu?.usage) || 0;
+                let cpu = 0;
+                const p = prevCpu.get(name);
+                if (running && p && now > p.t) {
+                    const dUsage = usage - p.usage;
+                    const dWallNs = (now - p.t) * 1e6;
+                    if (dWallNs > 0 && dUsage >= 0)
+                        cpu = Math.round((dUsage / dWallNs) * 1000) / 10;
+                }
+                prevCpu.set(name, { usage, t: now });
+                const mem = Number(st.memory?.usage) || 0;
+                const memLimit = limitToBytes(inst.config?.["limits.memory"] || inst.expanded_config?.["limits.memory"]);
+                const memPercent = memLimit ? Math.round((mem / memLimit) * 1000) / 10 : 0;
+                const container = {
+                    id: name,
+                    name,
+                    service: "",
+                    image: inst.config?.["image.description"] || inst.type || "lxc",
+                    state: String(inst.status || "").toLowerCase(),
+                    status: inst.status || "",
+                    running,
+                    health: "",
+                    cpu,
+                    mem,
+                    memLimit,
+                    memPercent,
+                    restarts: 0,
+                    exitCode: 0,
+                };
+                // Grouping: a user.daemonitor.group config key, else the host.
+                const group = inst.config?.["user.daemonitor.group"] ||
+                    inst.expanded_config?.["user.daemonitor.group"] || host;
+                const arr = groups.get(group) || [];
+                arr.push(container);
+                groups.set(group, arr);
+            }
+            for (const [project, containers] of groups) {
+                const running = containers.filter((c) => c.running).length;
+                const payload = {
+                    name: project,
+                    engine: "lxc",
+                    host,
+                    project,
+                    running,
+                    total: containers.length,
+                    containers,
+                    timestamp: now,
+                };
+                await plugin.send(payload, `lxc-${project}`);
+            }
+        }
+        catch (err) {
+            console.error("lxc: 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("lxc", "lxc", "LXC / LXD / Incus container monitoring plugin", setupFn, monitorFn, refreshFn, teardownFn);
+}
+export default createLxcPlugin;

package/dist/plugins/monitoring/OSPlugin.js

@@ -1,29 +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();
+import { createMonitoringPlugin } from "../../lib/MonitoringPlugin";
+import { arch, cpus, freemem, hostname, loadavg, networkInterfaces, platform, release, totalmem, type, uptime, } from "os";
+import { readFileSync } from "fs";
+// True available memory: on Linux, os.freemem() returns MemFree, which excludes
+// reclaimable page cache and makes hosts look near-full. MemAvailable is the
+// kernel's estimate of memory obtainable without swapping. Fall back to freemem()
+// on non-Linux (or if /proc is unreadable).
+function availableMem() {
+    if (platform() === "linux") {
+        try {
+            const info = readFileSync("/proc/meminfo", "utf8");
+            const m = info.match(/^MemAvailable:\s+(\d+)\s*kB/m);
+            if (m)
+                return parseInt(m[1], 10) * 1024;
+        }
+        catch {
+            // fall through to freemem()
+        }
     }
-    async refresh() {
+    return freemem();
+}
+// Host OS metrics: cpu (from cpus().times), memory, load, uptime, addresses.
+// Matches the frontend `os` fleetAdapter case.
+export function createOSPlugin() {
+    let refreshTimer = null;
+    const collect = () => {
         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 };
-                }
-            }
+        for (const [key, value] of Object.entries(interfaces)) {
+            if (!value)
+                continue;
+            const found = value.find((p) => p.family === "IPv4" && p.internal !== true);
+            if (found)
+                addresses[key] = { address: found.address, netmask: found.netmask, mac: found.mac };
         }
-        await this.send({
+        return {
             addresses,
             totalmem: totalmem(),
             freemem: freemem(),
+            available: availableMem(),
             loadavg: loadavg(),
             uptime: uptime(),
             hostname: hostname(),
@@ -31,13 +45,26 @@ export class OSPlugin extends MonitoringPlugin {
             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);
-    }
+            cpus: cpus(),
+        };
+    };
+    const refreshFn = async (plugin) => {
+        try {
+            await plugin.send({ name: hostname(), ...collect() }, "os");
+        }
+        catch (err) {
+            console.error("os: refresh error:", err.message);
+        }
+    };
+    const monitorFn = async (plugin) => {
+        await refreshFn(plugin);
+        refreshTimer = setInterval(() => refreshFn(plugin), plugin.config?.refreshInterval || 30000);
+    };
+    const teardownFn = async () => {
+        if (refreshTimer)
+            clearInterval(refreshTimer);
+        refreshTimer = null;
+    };
+    return createMonitoringPlugin("os", "os", "Host OS monitoring plugin", async () => { }, monitorFn, refreshFn, teardownFn);
 }
+export default createOSPlugin;

package/dist/plugins/monitoring/PM2Plugin.js

@@ -1,48 +1,68 @@
-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) => {
+import { createMonitoringPlugin } from "../../lib/MonitoringPlugin";
+// Factory function to create PM2 plugin
+export function createPM2Plugin() {
+    // Create plugin state
+    let pm2Instance = null;
+    let refreshTimer = null;
+    // Define setup function
+    const setupFn = async (plugin) => {
+        try {
+            // First, check if PM2 is available globally (injected by the client-test)
+            if (global.pm2Library) {
+                console.log("Using globally provided PM2 instance");
+                pm2Instance = global.pm2Library;
+            }
+            else {
+                // Otherwise use dynamic import approach which is ESM friendly
+                try {
+                    const pm2Module = await import('pm2');
+                    pm2Instance = pm2Module.default || pm2Module;
+                    // If import fails, try CommonJS require as fallback
+                    if (!pm2Instance) {
+                        try {
+                            // @ts-ignore - Dynamically require pm2
+                            pm2Instance = require('pm2');
+                        }
+                        catch (requireErr) {
+                            console.error("Failed to require PM2:", requireErr);
+                            throw new Error(`Neither import nor require could load pm2: ${requireErr.message}`);
+                        }
+                    }
+                }
+                catch (err) {
+                    console.error("Failed to import PM2:", err);
+                    throw new Error(`PM2 import failed: ${err.message}`);
+                }
+            }
+            // Return a promise for the PM2 connection
+            return new Promise((resolve, reject) => {
+                pm2Instance.connect((err) => {
                     if (err) {
-                        console.error(err);
+                        console.error("PM2 connection failed:", err);
                         reject(err);
                     }
                     else {
                         resolve();
                     }
                 });
-            }
-            catch (e) {
-                console.error("ERROR", e);
-                reject(e);
-            }
-        });
-    }
-    async refresh() {
+            });
+        }
+        catch (e) {
+            console.error("PM2Plugin setup error:", e);
+            throw e;
+        }
+    };
+    // Define refresh function
+    const refreshFn = async (plugin) => {
+        if (!pm2Instance) {
+            console.error("PM2 instance not initialized");
+            return;
+        }
         const instanceCounts = {};
-        pm2.list(async (err, list) => {
+        pm2Instance.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 { pid, name, pm_id, monit, } = p;
                     if (instanceCounts[name] === undefined) {
                         instanceCounts[name] = 0;
                     }
@@ -69,18 +89,26 @@ export class PM2Plugin extends MonitoringPlugin {
                         status,
                         pm_uptime,
                     };
-                    await this.send(payload, instance_id);
+                    await plugin.send(payload, instance_id);
                 }
             }
             else {
                 console.error(err);
             }
         });
-    }
-    async monitor() {
-        this.refreshTimer = setInterval(this.refresh.bind(this), this.config.refreshInterval || 5000);
-    }
-    async teardown() {
-        clearInterval(this.refreshTimer);
-    }
+    };
+    // Define monitor function
+    const monitorFn = async (plugin) => {
+        refreshTimer = setInterval(() => refreshFn(plugin), plugin.config.refreshInterval || 5000);
+    };
+    // Define teardown function
+    const teardownFn = async (plugin) => {
+        if (refreshTimer) {
+            clearInterval(refreshTimer);
+        }
+    };
+    // Create and return the plugin
+    return createMonitoringPlugin("pm2", "PM2", "PM2 Monitoring Plugin", setupFn, monitorFn, refreshFn, teardownFn);
 }
+// Export a default factory function for plugin loader
+export default createPM2Plugin;

package/dist/plugins/monitoring/WebsitePlugin.js

@@ -1,46 +1,72 @@
-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);
-    }
+import { createMonitoringPlugin } from "../../lib/MonitoringPlugin";
+// HTTP uptime/content checks. Emits one client_state per endpoint, matching the
+// frontend `web`/`website` fleetAdapter case ({ url, name, ok, status, duration }).
+export function createWebsitePlugin() {
+    let refreshTimer = null;
+    const check = async (plugin, ep) => {
+        const start = Date.now();
+        const label = ep.name || ep.url;
+        const uid = `web-${(ep.name || ep.url).replace(/[^a-zA-Z0-9_.-]+/g, "-")}`;
+        try {
+            const ctrl = new AbortController();
+            const t = ep.timeout ? setTimeout(() => ctrl.abort(), ep.timeout) : null;
+            const res = await fetch(ep.url, { signal: ctrl.signal, redirect: "follow" });
+            if (t)
+                clearTimeout(t);
+            const body = await res.text();
+            const duration = Date.now() - start;
+            const expected = ep.expectedStrings || [];
+            const unexpected = ep.unexpectedStrings || [];
+            const hasAllExpected = expected.every((s) => body.indexOf(s) !== -1);
+            const hasAnyUnexpected = unexpected.some((s) => body.indexOf(s) !== -1);
+            const statusOk = ep.expectedStatusCode ? res.status === ep.expectedStatusCode : res.ok;
+            const ok = statusOk && hasAllExpected && !hasAnyUnexpected;
+            await plugin.send({
+                name: label,
+                url: res.url || ep.url,
+                status: res.status,
+                duration,
+                ok,
+                redirected: res.redirected,
+                hasAllExpectedStrings: hasAllExpected,
+                hasAnyUnexpectedStrings: hasAnyUnexpected,
+            }, uid);
+        }
+        catch (err) {
+            await plugin.send({
+                name: label,
+                url: ep.url,
+                status: 0,
+                duration: Date.now() - start,
+                ok: false,
+                error: err.message,
+            }, uid);
+        }
+    };
+    const endpointsOf = (plugin) => {
+        const cfg = plugin.config || {};
+        if (Array.isArray(cfg.endpoints))
+            return cfg.endpoints;
+        if (cfg.url)
+            return [{ name: cfg.name, url: cfg.url, expectedStrings: cfg.expectedStrings, unexpectedStrings: cfg.unexpectedStrings }];
+        return [];
+    };
+    const refreshFn = async (plugin) => {
+        const eps = endpointsOf(plugin);
+        for (const ep of eps) {
+            if (ep?.url)
+                await check(plugin, ep);
+        }
+    };
+    const monitorFn = async (plugin) => {
+        await refreshFn(plugin);
+        refreshTimer = setInterval(() => refreshFn(plugin), plugin.config?.refreshInterval || 60000);
+    };
+    const teardownFn = async () => {
+        if (refreshTimer)
+            clearInterval(refreshTimer);
+        refreshTimer = null;
+    };
+    return createMonitoringPlugin("web", "web", "Website / HTTP uptime monitoring plugin", async () => { }, monitorFn, refreshFn, teardownFn);
 }
+export default createWebsitePlugin;

package/index.ts

@@ -0,0 +1,11 @@
+// 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/package.json

@@ -1,9 +1,10 @@
 {
   "name": "@daemonitor/plugins",
-  "version": "1.0.3",
+  "version": "1.1.0",
   "description": "daemonitor plugins",
   "types": "types/index.d.ts",
-  "main": "dist/index.js",
+  "main": "index.ts",
+  "type": "module",
   "scripts": {
     "build": "tsc",
     "test": "echo \"Error: no test specified\" && exit 1"
@@ -12,24 +13,42 @@
     "dist",
     "types"
   ],
-  "type": "module",
+  "exports": {
+    ".": "./index.ts",
+    "./lib/*": "./lib/*.ts",
+    "./plugins/*": "./plugins/*.ts"
+  },
+  "publishConfig": {
+    "access": "public",
+    "main": "dist/index.js",
+    "types": "types/index.d.ts",
+    "exports": {
+      ".": {
+        "types": "./types/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "./lib/*": "./dist/lib/*.js",
+      "./plugins/*": "./dist/plugins/*.js"
+    }
+  },
   "author": "",
   "license": "ISC",
   "packageManager": "pnpm@8.2.0",
+  "devDependencies": {
+    "nuxt": "^3.15.4",
+    "vue": "^3.5.13",
+    "vue-router": "^4.5.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": "^1.0.0",
-    "tsconfig-paths": "^4.2.0"
-  },
-  "exports": {
-    ".": "./dist/index.js",
-    "./types": "./dist/types/index.js"
+    "tsconfig-paths": "^4.2.0",
+    "pm2": "^6.0.5"
   },
   "repository": {
     "type": "git",
@@ -38,6 +57,5 @@
   "bugs": {
     "url": "https://github.com/daemonitor/plugins/issues"
   },
-
   "homepage": "https://github.com/daemonitor/plugins#readme"
 }