@daemonitor/plugins 1.1.16 → 1.1.18

package/dist/plugins/index.js

@@ -9,6 +9,7 @@ import { createLogWatchPlugin } from "./monitoring/LogWatchPlugin";
 import { createNetScanPlugin } from "./monitoring/NetScanPlugin";
 import { createSnmpPlugin } from "./monitoring/SnmpPlugin";
 import { createThreeCXPlugin } from "./monitoring/ThreeCXPlugin";
+import { createTplinkPlugin } from "./monitoring/TplinkPlugin";
 // In future, implement other plugin factory functions using the same pattern
 // import { createOSPlugin } from "./monitoring/OSPlugin"
 // import { createMongoDBPlugin } from "./monitoring/MongoDBPlugin"
@@ -29,6 +30,7 @@ export default {
     Netscan: createNetScanPlugin,
     Snmp: createSnmpPlugin,
     ThreeCX: createThreeCXPlugin,
+    Tplink: createTplinkPlugin,
     // CloudflarePlugin: createCloudflarePlugin,
     // EwelinkPlugin: createEwelinkPlugin,
     // MongoDBPlugin: createMongoDBPlugin,

package/dist/plugins/monitoring/DockerPlugin.js

@@ -5,6 +5,14 @@ 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;
+// Previous cumulative NetIO/BlockIO totals per container id, to derive a
+// per-second rate across polls. Module-level (one collect per host per cycle).
+const ioPrev = {};
+// docker stats renders "12MB / 7.02MB" (rx / tx, or read / write). Split + convert.
+function pairToBytes(value) {
+    const [x, y] = (value || "").split("/").map((p) => p.trim());
+    return { a: memToBytes(x), b: memToBytes(y) };
+}
 /** Convert docker's "83.86MiB" / "1.952GiB" memory strings to bytes. */
 function memToBytes(value) {
     if (!value)
@@ -52,13 +60,17 @@ async function collectContainers(bin) {
     }
     if (!containers.length)
         return containers;
-    // 2. live stats for running containers (one batched call, best-effort)
+    // 2. live stats for running containers (one batched call, best-effort).
+    // NetIO/BlockIO are CUMULATIVE since container start, so we derive a per-second
+    // rate from the delta vs the previous poll (first poll → no rate).
     try {
-        const { stdout: statsOut } = await execAsync(`${bin} stats --no-stream --format '{{.ID}}|{{.CPUPerc}}|{{.MemUsage}}|{{.MemPerc}}'`, EXEC_OPTS);
+        const { stdout: statsOut } = await execAsync(`${bin} stats --no-stream --format '{{.ID}}|{{.CPUPerc}}|{{.MemUsage}}|{{.MemPerc}}|{{.NetIO}}|{{.BlockIO}}'`, EXEC_OPTS);
+        const now = Date.now();
+        const seen = new Set();
         for (const line of statsOut.split("\n")) {
             if (!line.trim())
                 continue;
-            const [id, cpuPerc, memUsage, memPerc] = line.split("|");
+            const [id, cpuPerc, memUsage, memPerc, netIO, blkIO] = line.split("|");
             const c = byId.get(id);
             if (!c)
                 continue;
@@ -67,7 +79,28 @@ async function collectContainers(bin) {
             c.mem = memToBytes(used);
             c.memLimit = memToBytes(limit);
             c.memPercent = parseFloat((memPerc || "").replace("%", "")) || 0;
+            const net = pairToBytes(netIO); // { a: rx, b: tx }
+            const blk = pairToBytes(blkIO); // { a: read, b: write }
+            seen.add(id);
+            const prev = ioPrev[id];
+            if (prev && now > prev.ts) {
+                const dt = (now - prev.ts) / 1000;
+                // Guard counter resets (container restart): negative delta → skip that field.
+                if (net.a >= prev.rx)
+                    c.netIn = Math.round((net.a - prev.rx) / dt);
+                if (net.b >= prev.tx)
+                    c.netOut = Math.round((net.b - prev.tx) / dt);
+                if (blk.a >= prev.rd)
+                    c.blkRead = Math.round((blk.a - prev.rd) / dt);
+                if (blk.b >= prev.wr)
+                    c.blkWrite = Math.round((blk.b - prev.wr) / dt);
+            }
+            ioPrev[id] = { rx: net.a, tx: net.b, rd: blk.a, wr: blk.b, ts: now };
         }
+        // Drop prev samples for containers no longer present.
+        for (const k of Object.keys(ioPrev))
+            if (!seen.has(k))
+                delete ioPrev[k];
     }
     catch (err) {
         console.error("docker: stats collection failed:", err.message);

package/dist/plugins/monitoring/TplinkPlugin.js

@@ -0,0 +1,151 @@
+import crypto from "node:crypto";
+import { createMonitoringPlugin } from "../../lib/MonitoringPlugin";
+// Live sessions per device IP — re-used across polls, rebuilt when they lapse.
+const sessions = {};
+function slug(s) {
+    return s.replace(/[^a-zA-Z0-9_.-]+/g, "-").replace(/^-+|-+$/g, "").toLowerCase();
+}
+const b64u = (hex) => Buffer.from(hex, "hex").toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+function headers(ip, page, cookie) {
+    return {
+        "Content-Type": "application/x-www-form-urlencoded; charset=UTF-8",
+        Referer: `http://${ip}/webpages/${page}`,
+        "X-Requested-With": "XMLHttpRequest",
+        ...(cookie ? { Cookie: `sysauth=${cookie}` } : {}),
+    };
+}
+async function post(url, hdrs, body, timeout) {
+    const res = await fetch(url, { method: "POST", headers: hdrs, body, signal: AbortSignal.timeout(timeout) });
+    return await res.json();
+}
+/** TP-Link RSA login → { stok, sysauth }. Throws on bad credentials. */
+async function login(d, timeout) {
+    const base = `http://${d.ip}/cgi-bin/luci/;stok=`;
+    const keyRes = await post(`${base}/login?form=login`, headers(d.ip, "login.html"), "operation=read", timeout);
+    const pair = keyRes?.data?.password;
+    if (!Array.isArray(pair) || pair.length < 2)
+        throw new Error("no RSA key from login form");
+    const pub = crypto.createPublicKey({
+        key: { kty: "RSA", n: b64u(pair[0]), e: b64u(pair[1]) },
+        format: "jwk",
+    });
+    const enc = crypto
+        .publicEncrypt({ key: pub, padding: crypto.constants.RSA_PKCS1_PADDING }, Buffer.from(d.password))
+        .toString("hex");
+    const res = await fetch(`${base}/login?form=login`, {
+        method: "POST",
+        headers: headers(d.ip, "login.html"),
+        body: `operation=login&password=${enc}`,
+        signal: AbortSignal.timeout(timeout),
+    });
+    const setCookie = res.headers.get("set-cookie") || "";
+    const body = await res.json();
+    const stok = body?.data?.stok;
+    const sysauth = (setCookie.match(/sysauth=([^;]+)/) || [])[1];
+    if (!stok || !sysauth) {
+        throw new Error(body?.errorcode === "login failed" ? "login failed (bad password?)" : "login rejected");
+    }
+    return { stok, sysauth };
+}
+/** Authenticated read, re-logging in once if the session has lapsed. */
+async function read(d, endpoint, timeout) {
+    const call = async (s) => post(`http://${d.ip}/cgi-bin/luci/;stok=${s.stok}/${endpoint}`, headers(d.ip, "index.html", s.sysauth), "operation=read", timeout);
+    let s = sessions[d.ip];
+    if (s) {
+        try {
+            const out = await call(s);
+            if (out?.success)
+                return out.data;
+        }
+        catch {
+            /* fall through to re-login */
+        }
+    }
+    s = await login(d, timeout);
+    sessions[d.ip] = s;
+    const out = await call(s);
+    if (!out?.success)
+        throw new Error(out?.errorcode || "read failed");
+    return out.data;
+}
+async function collect(d, timeout) {
+    try {
+        const status = await read(d, "admin/status?form=ap_status", timeout);
+        // Firmware is static — nice for drift, but never fail the poll over it.
+        let fw = {};
+        try {
+            fw = (await read(d, "admin/firmware?form=upgrade", timeout)) || {};
+        }
+        catch {
+            /* non-fatal */
+        }
+        const grid = status?.wirelessGrid;
+        const clients = Array.isArray(grid)
+            ? grid.map((c) => ({
+                name: c.name || c.hostname || "device",
+                mac: c.mac || "",
+                band: c.type || "",
+            }))
+            : [];
+        const radio2g = String(status?.wireless_2g_enable ?? "") === "on";
+        const radio5g = String(status?.wireless_5g_enable ?? "") === "on";
+        return {
+            name: d.name,
+            ip: d.ip,
+            kind: "extender",
+            reachable: true,
+            // The uplink — an extender with this down still pings but serves nobody.
+            internetStatus: status?.internet_status ?? undefined,
+            uplinkUp: status?.internet_status === "connected",
+            phyconn: status?.phyconn ?? undefined,
+            radio2g,
+            radio5g,
+            clientCount: typeof status?.wirelessCount === "number" ? status.wirelessCount : clients.length,
+            clients,
+            model: fw.model || undefined,
+            hardwareVersion: fw.hardware_version || undefined,
+            firmware: fw.firmware_version || undefined,
+        };
+    }
+    catch (e) {
+        delete sessions[d.ip]; // force a fresh login next pass
+        return {
+            name: d.name,
+            ip: d.ip,
+            kind: "extender",
+            reachable: false,
+            error: String(e?.message || e).slice(0, 160),
+        };
+    }
+}
+export function createTplinkPlugin() {
+    let refreshTimer = null;
+    const devicesOf = (plugin) => {
+        const cfg = (plugin.config || {});
+        return (Array.isArray(cfg.devices) ? cfg.devices : []).filter((d) => d?.ip && d?.password);
+    };
+    const refreshFn = async (plugin) => {
+        const cfg = (plugin.config || {});
+        const timeout = cfg.timeout || 8000;
+        await Promise.all(devicesOf(plugin).map(async (d) => {
+            const uid = d.uniqueId || `tplink-${slug(d.name || d.ip)}`;
+            try {
+                await plugin.send(await collect(d, timeout), uid);
+            }
+            catch (e) {
+                await plugin.send({ name: d.name, ip: d.ip, kind: "extender", reachable: false, error: String(e?.message || e).slice(0, 160) }, uid);
+            }
+        }));
+    };
+    const monitorFn = async (plugin) => {
+        await refreshFn(plugin);
+        refreshTimer = setInterval(() => refreshFn(plugin), plugin.config?.refreshInterval || 120000);
+    };
+    const teardownFn = async () => {
+        if (refreshTimer)
+            clearInterval(refreshTimer);
+        refreshTimer = null;
+    };
+    return createMonitoringPlugin("tplink", "tplink", "TP-Link extender/AP monitor (uplink, radios, clients, firmware)", async () => { }, monitorFn, refreshFn, teardownFn);
+}
+export default createTplinkPlugin;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@daemonitor/plugins",
-  "version": "1.1.16",
+  "version": "1.1.18",
   "description": "daemonitor plugins",
   "types": "types/index.d.ts",
   "main": "dist/index.js",