@daemonitor/plugins 1.1.46 → 1.1.51

package/dist/plugins/index.js

@@ -18,6 +18,7 @@ import { createGa4Plugin } from "./monitoring/Ga4Plugin.js";
 import { createNagiosPlugin } from "./monitoring/NagiosPlugin.js";
 import { createTplinkSwitchPlugin } from "./monitoring/TplinkSwitchPlugin.js";
 import { createCostPlugin } from "./monitoring/CostPlugin.js";
+import { createSupabasePlugin } from "./monitoring/SupabasePlugin.js";
 // In future, implement other plugin factory functions using the same pattern
 // import { createOSPlugin } from "./monitoring/OSPlugin.js"
 // import { createMongoDBPlugin } from "./monitoring/MongoDBPlugin.js"
@@ -47,6 +48,7 @@ export default {
     Nagios: createNagiosPlugin,
     TplinkSwitch: createTplinkSwitchPlugin,
     Cost: createCostPlugin,
+    Supabase: createSupabasePlugin,
     // CloudflarePlugin: createCloudflarePlugin,
     // EwelinkPlugin: createEwelinkPlugin,
     // MongoDBPlugin: createMongoDBPlugin,

package/dist/plugins/monitoring/Ga4Plugin.js

@@ -175,6 +175,20 @@ async function inBatches(items, size, fn) {
         out.push(...(await Promise.all(items.slice(i, i + size).map(fn))));
     return out;
 }
+/**
+ * One more try after a timeout, so a slow moment doesn't warn for a whole poll.
+ * Only timeouts: a 403 or a quota error will say the same thing again.
+ */
+export async function retryTimeout(fn) {
+    try {
+        return await fn();
+    }
+    catch (e) {
+        if (e?.name !== "TimeoutError")
+            throw e;
+        return fn();
+    }
+}
 export function createGa4Plugin() {
     let refreshTimer = null;
     const collect = async (cfg) => {
@@ -203,7 +217,7 @@ export function createGa4Plugin() {
                 // One property failing (no access to its data, quota) must not hide the rest.
                 try {
                     const [batch, realtime, streams] = await Promise.all([
-                        post(`${DATA}/properties/${p.id}:batchRunReports`, batchBody(cfg.excludePages)),
+                        retryTimeout(() => post(`${DATA}/properties/${p.id}:batchRunReports`, batchBody(cfg.excludePages))),
                         post(`${DATA}/properties/${p.id}:runRealtimeReport`, { metrics: [{ name: "activeUsers" }] }).catch(() => null),
                         get(`${ADMIN}/properties/${p.id}/dataStreams?pageSize=50`).catch(() => null),
                     ]);

package/dist/plugins/monitoring/NetScanPlugin.js

@@ -36,6 +36,57 @@ async function pingHost(ip, count, timeout) {
         return { up: false };
     }
 }
+/**
+ * Read one neighbour-table entry from `ip -j neigh show <ip>` output.
+ * REACHABLE means the device answered ARP within the last few seconds.
+ */
+export function neighState(json) {
+    try {
+        const e = JSON.parse(json)?.[0];
+        if (!e)
+            return null;
+        const state = Array.isArray(e.state) ? e.state[0] : String(e.state || "");
+        return { state, ...(e.lladdr ? { mac: String(e.lladdr) } : {}) };
+    }
+    catch {
+        return null;
+    }
+}
+let ipMissing = false;
+/**
+ * Is the device on the wire even though it ignored ping? The failed ping still
+ * made the kernel ARP for it, and a device that drops ICMP almost always
+ * answers ARP, leaving a REACHABLE neighbour entry. DELAY and PROBE mean the
+ * kernel is still checking a stale entry, so look again after it has had time.
+ * Linux only, and needs the `ip` command (iproute2); anything else says no.
+ */
+export async function arpReachable(ip) {
+    if (process.platform !== "linux" || ipMissing)
+        return null;
+    for (let attempt = 0; attempt < 3; attempt++) {
+        let stdout;
+        try {
+            ;
+            ({ stdout } = await pexec("ip", ["-j", "neigh", "show", ip], { timeout: 3000 }));
+        }
+        catch (e) {
+            if (e?.code === "ENOENT") {
+                ipMissing = true;
+                console.warn("netscan: `ip` (iproute2) is not installed, so devices that ignore ping can't be confirmed by ARP");
+            }
+            return null;
+        }
+        const n = neighState(stdout);
+        if (!n)
+            return null;
+        if (n.state === "REACHABLE")
+            return { mac: n.mac };
+        if (n.state !== "DELAY" && n.state !== "PROBE")
+            return null;
+        await new Promise((r) => setTimeout(r, 2000));
+    }
+    return null;
+}
 export function createNetScanPlugin() {
     let refreshTimer = null;
     const devicesOf = (plugin) => {
@@ -51,12 +102,18 @@ export function createNetScanPlugin() {
         // refresh interval.
         await Promise.all(devices.map(async (d) => {
             const r = await pingHost(d.ip, count, timeout);
+            if (!r.up && d.arp !== false) {
+                const arp = await arpReachable(d.ip);
+                if (arp)
+                    Object.assign(r, { up: true, via: "arp", ...(arp.mac ? { mac: arp.mac } : {}) });
+            }
             await plugin.send({
                 name: d.name,
                 ip: d.ip,
                 type: d.type || "host",
-                mac: d.mac,
+                mac: d.mac || r.mac,
                 up: r.up,
+                ...(r.via ? { via: r.via } : {}),
                 latency: r.latency,
                 loss: r.loss,
                 warnMs: d.warnMs ?? 200,

package/dist/plugins/monitoring/OSPlugin.js

@@ -125,6 +125,34 @@ function availableMem() {
     }
     return freemem();
 }
+// Swap and page cache, in bytes. Swap in use on a box that still has RAM
+// available is old pages pushed out, not pressure, so the card shows both.
+// Linux reads /proc/meminfo; macOS has swap only (sysctl vm.swapusage).
+function memDetail() {
+    if (platform() === "linux") {
+        try {
+            const info = readFileSync("/proc/meminfo", "utf8");
+            const kb = (key) => parseInt(info.match(new RegExp(`^${key}:\\s+(\\d+)\\s*kB`, "m"))?.[1] || "0", 10) * 1024;
+            const swapTotal = kb("SwapTotal");
+            return { swapTotal, swapUsed: swapTotal - kb("SwapFree"), cached: kb("Cached") + kb("Buffers") };
+        }
+        catch {
+            return undefined;
+        }
+    }
+    if (platform() === "darwin") {
+        try {
+            // "total = 2048.00M  used = 1024.50M  free = 1023.50M  (encrypted)"
+            const out = execSync("sysctl -n vm.swapusage", { encoding: "utf8", timeout: 4000 });
+            const mb = (key) => parseFloat(out.match(new RegExp(`${key} = ([\\d.]+)M`))?.[1] || "0") * 1024 * 1024;
+            return { swapTotal: Math.round(mb("total")), swapUsed: Math.round(mb("used")) };
+        }
+        catch {
+            return undefined;
+        }
+    }
+    return undefined;
+}
 // Cumulative rx/tx byte counters summed across real interfaces (Linux
 // /proc/net/dev). Loopback and virtual bridges (docker/veth/lxc/br-) are skipped
 // so the figure reflects actual host network traffic, not container-to-host
@@ -220,6 +248,7 @@ export function createOSPlugin() {
             totalmem: totalmem(),
             freemem: freemem(),
             available: availableMem(),
+            memory: memDetail(),
             disks: collectDisks(),
             processes: collectProcesses(),
             network,

package/dist/plugins/monitoring/SupabasePlugin.js

@@ -0,0 +1,151 @@
+import { createMonitoringPlugin } from "../../lib/MonitoringPlugin.js";
+const DEFAULTS = {
+    services: ["auth", "db", "pooler", "realtime", "rest", "storage"],
+    diskWarnPct: 80,
+    diskCritPct: 90,
+    connWarnPct: 85,
+    requestTimeout: 10000,
+};
+const MGMT = "https://api.supabase.com/v1";
+/** Prometheus text exposition format, samples only. Comments and blanks are skipped. */
+export function parseProm(text) {
+    const out = [];
+    for (const line of String(text || "").split("\n")) {
+        const m = /^([a-zA-Z_:][\w:]*)(?:\{(.*)\})?\s+(\S+)/.exec(line);
+        if (!m)
+            continue;
+        const value = Number(m[3]);
+        if (!Number.isFinite(value))
+            continue;
+        const labels = {};
+        for (const l of (m[2] || "").matchAll(/(\w+)="((?:[^"\\]|\\.)*)"/g))
+            labels[l[1]] = l[2];
+        out.push({ name: m[1], labels, value });
+    }
+    return out;
+}
+/**
+ * The handful of figures worth a tile, from the ~200 series the endpoint
+ * serves. Every one is null when its series is absent, never 0: a missing
+ * series means "not measured", and 0% disk would read as healthy.
+ */
+export function pickMetrics(samples) {
+    const all = (name) => samples.filter((s) => s.name === name);
+    const sum = (name) => {
+        const rows = all(name);
+        return rows.length ? rows.reduce((n, s) => n + s.value, 0) : null;
+    };
+    // Supabase keeps Postgres on its own volume at /data. Root is the fallback
+    // for an image that does not split them.
+    const onMount = (name) => {
+        const rows = all(name);
+        return (rows.find((s) => s.labels.mountpoint === "/data") ?? rows.find((s) => s.labels.mountpoint === "/"))?.value ?? null;
+    };
+    const pct = (used, total) => used != null && total ? Math.round((used / total) * 1000) / 10 : null;
+    const diskTotal = onMount("node_filesystem_size_bytes");
+    const diskAvail = onMount("node_filesystem_avail_bytes");
+    const diskUsed = diskTotal != null && diskAvail != null ? diskTotal - diskAvail : null;
+    const memTotal = sum("node_memory_MemTotal_bytes");
+    const memAvail = sum("node_memory_MemAvailable_bytes");
+    return {
+        diskTotalBytes: diskTotal,
+        diskUsedBytes: diskUsed,
+        diskPct: pct(diskUsed, diskTotal),
+        memPct: pct(memTotal != null && memAvail != null ? memTotal - memAvail : null, memTotal),
+        load1: sum("node_load1"),
+        connections: sum("pg_stat_database_num_backends"),
+        maxConnections: sum("pg_settings_max_connections"),
+        dbSizeBytes: sum("pg_database_size_bytes"),
+    };
+}
+async function get(url, headers, timeout) {
+    const res = await fetch(url, { headers, signal: AbortSignal.timeout(timeout) });
+    if (!res.ok)
+        throw new Error(`HTTP ${res.status} from ${new URL(url).host}${new URL(url).pathname}`);
+    return res;
+}
+export async function collectProject(p, cfg) {
+    const token = p.accessToken || cfg.accessToken;
+    const timeout = cfg.requestTimeout ?? DEFAULTS.requestTimeout;
+    const base = { kind: "supabase", ref: p.ref, name: p.name || p.ref, timestamp: Date.now() };
+    if (!token && !p.serviceKey) {
+        return { ...base, reachable: false, error: "supabase project needs an accessToken or a serviceKey" };
+    }
+    const bearer = { Authorization: `Bearer ${token}`, Accept: "application/json" };
+    const services = (cfg.services?.length ? cfg.services : DEFAULTS.services).join(",");
+    const skipped = Promise.resolve(null);
+    // Asked together, and one failing must not hide the others: a token that has
+    // expired still leaves the disk figures worth reporting.
+    const [project, health, prom] = await Promise.allSettled([
+        token ? get(`${MGMT}/projects/${p.ref}`, bearer, timeout).then((r) => r.json()) : skipped,
+        token ? get(`${MGMT}/projects/${p.ref}/health?services=${services}`, bearer, timeout).then((r) => r.json()) : skipped,
+        p.serviceKey
+            ? get(`https://${p.ref}.supabase.co/customer/v1/privileged/metrics`, { Authorization: `Basic ${Buffer.from(`service_role:${p.serviceKey}`).toString("base64")}` }, timeout).then((r) => r.text())
+            : skipped,
+    ]);
+    const results = [project, health, prom];
+    const errors = results
+        .filter((r) => r.status === "rejected")
+        .map((r) => String(r.reason?.message || r.reason).slice(0, 160));
+    const value = (r) => (r.status === "fulfilled" ? r.value : null);
+    const proj = value(project);
+    const got = results.filter((r) => r.status === "fulfilled" && r.value != null).length;
+    if (!got)
+        return { ...base, reachable: false, error: errors[0] || "no response" };
+    const healthList = Array.isArray(value(health)) ? value(health) : [];
+    const promText = value(prom);
+    return {
+        ...base,
+        name: p.name || proj?.name || p.ref,
+        reachable: true,
+        projectStatus: proj?.status ?? null,
+        region: proj?.region ?? null,
+        pgVersion: proj?.database?.version ?? null,
+        services: healthList.map((s) => ({
+            name: String(s?.name ?? "unknown"),
+            healthy: s?.healthy === true,
+            status: String(s?.status ?? "UNKNOWN"),
+            error: s?.error ? String(s.error).slice(0, 160) : undefined,
+        })),
+        metrics: promText ? pickMetrics(parseProm(promText)) : null,
+        // A source that was configured and failed. The report is partial, and the
+        // server says so instead of showing a green tile with half its figures.
+        errors,
+        diskWarnPct: cfg.diskWarnPct ?? DEFAULTS.diskWarnPct,
+        diskCritPct: cfg.diskCritPct ?? DEFAULTS.diskCritPct,
+        connWarnPct: cfg.connWarnPct ?? DEFAULTS.connWarnPct,
+    };
+}
+export function createSupabasePlugin() {
+    let refreshTimer = null;
+    const refreshFn = async (plugin) => {
+        const cfg = (plugin.config || {});
+        const projects = (cfg.projects || []).filter((p) => p?.ref);
+        if (!projects.length) {
+            await plugin.send({ kind: "supabase", reachable: false, error: "supabase plugin needs at least one project ref" });
+            return;
+        }
+        // Sequential: a handful of projects, and one slow account must not be able
+        // to starve the rest of their timeout.
+        for (const p of projects) {
+            const uid = `supabase-${p.ref}`;
+            try {
+                await plugin.send(await collectProject(p, cfg), uid);
+            }
+            catch (e) {
+                await plugin.send({ kind: "supabase", ref: p.ref, name: p.name || p.ref, reachable: false, error: String(e?.message || e).slice(0, 200), timestamp: Date.now() }, uid);
+            }
+        }
+    };
+    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("supabase", "supabase", "Supabase cloud project monitor (project status, service health, disk, connections)", async () => { }, monitorFn, refreshFn, teardownFn);
+}
+export default createSupabasePlugin;

package/dist/plugins/monitoring/SynologyPlugin.js

@@ -12,6 +12,20 @@ const AUTH_ERRORS = {
 /** A login DSM refused. Retrying every pass would trip its auto block. */
 export const authErrorText = (code) => AUTH_ERRORS[Number(code)];
 const apiErrorText = (api, code) => Number(code) === 105 ? `${api}: this account lacks permission, it may need to be an administrator` : `${api}: DSM error ${code}`;
+// "SID not found". DSM drops about 1% of sessions it has just opened, on the
+// first call after a successful login. Why isn't known; a new login works.
+const SESSION_LOST = 119;
+/** Run a whole login-to-logout pass, again if DSM lost the session. Once only. */
+export async function retryLostSession(pass) {
+    try {
+        return await pass();
+    }
+    catch (e) {
+        if (e?.dsmCode !== SESSION_LOST)
+            throw e;
+        return pass();
+    }
+}
 function post(url, form, cfg) {
     return new Promise((resolve, reject) => {
         const body = new URLSearchParams(form).toString();
@@ -109,7 +123,7 @@ export function summarise(storage, usb, system, util, cfg = {}) {
 async function collect(call, cfg) {
     const storage = await call("SYNO.Storage.CGI.Storage", "load_info", 1);
     if (!storage.success)
-        throw new Error(apiErrorText("storage", storage.error?.code));
+        throw Object.assign(new Error(apiErrorText("storage", storage.error?.code)), { dsmCode: storage.error?.code });
     // Extras: the card is still worth drawing without them.
     const [usb, system, util] = await Promise.all([
         call("SYNO.Core.ExternalDevice.Storage.USB", "list", 1, { additional: '["all"]' }).catch(() => null),
@@ -136,25 +150,27 @@ export function createSynologyPlugin() {
                 throw new Error("config needs account and password");
             if (Date.now() < lockedUntil)
                 throw new Error(lockedReason);
-            const login = await post(cfg.url, { api: "SYNO.API.Auth", version: "6", method: "login", account: cfg.account, passwd: cfg.password, format: "sid" }, cfg);
-            if (!login.success) {
-                const code = login.error?.code;
-                const refused = authErrorText(code);
-                if (refused) {
-                    lockedUntil = Date.now() + REAUTH_AFTER_MS;
-                    lockedReason = `login refused: ${refused}. Next try within the hour, or restart the agent`;
-                    throw new Error(lockedReason);
+            await report(await retryLostSession(async () => {
+                const login = await post(cfg.url, { api: "SYNO.API.Auth", version: "6", method: "login", account: cfg.account, passwd: cfg.password, format: "sid" }, cfg);
+                if (!login.success) {
+                    const code = login.error?.code;
+                    const refused = authErrorText(code);
+                    if (refused) {
+                        lockedUntil = Date.now() + REAUTH_AFTER_MS;
+                        lockedReason = `login refused: ${refused}. Next try within the hour, or restart the agent`;
+                        throw new Error(lockedReason);
+                    }
+                    throw new Error(`login failed: DSM error ${code}`);
+                }
+                const sid = String(login.data?.sid);
+                const call = (api, method, version, extra = {}) => post(cfg.url, { api, method, version: String(version), _sid: sid, ...extra }, cfg);
+                try {
+                    return await collect(call, cfg);
+                }
+                finally {
+                    await call("SYNO.API.Auth", "logout", 6).catch(() => { });
                 }
-                throw new Error(`login failed: DSM error ${code}`);
-            }
-            const sid = String(login.data?.sid);
-            const call = (api, method, version, extra = {}) => post(cfg.url, { api, method, version: String(version), _sid: sid, ...extra }, cfg);
-            try {
-                await report(await collect(call, cfg));
-            }
-            finally {
-                await call("SYNO.API.Auth", "logout", 6).catch(() => { });
-            }
+            }));
         }
         catch (e) {
             await report({ kind: "qnap", reachable: false, error: String(e?.message || e).slice(0, 120) });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@daemonitor/plugins",
-  "version": "1.1.46",
+  "version": "1.1.51",
   "description": "daemonitor plugins",
   "types": "types/index.d.ts",
   "main": "dist/index.js",
@@ -30,18 +30,14 @@
   "packageManager": "pnpm@9.15.9",
   "devDependencies": {
     "@types/node": "^26.1.1",
-    "nuxt": "^3.15.4",
-    "typescript": "^5.8.3",
-    "vue": "^3.5.13",
-    "vue-router": "^4.5.0"
+    "typescript": "^5.8.3"
   },
   "dependencies": {
     "@daemonitor/common": "^1.0.0",
     "dotenv": "^16.0.3",
     "ewelink-api": "^3.1.1",
     "node-machine-id": "^1.1.12",
-    "ohmyfetch": "^0.4.21",
-    "pm2": "^6.0.5",
+    "pm2": "^7.1.1",
     "string-to-color": "^2.2.2",
     "ts-node": "^10.9.1",
     "tsconfig-paths": "^4.2.0"