@daemonitor/plugins 1.1.32 → 1.1.34

package/dist/plugins/index.js

@@ -12,6 +12,9 @@ import { createThreeCXPlugin } from "./monitoring/ThreeCXPlugin.js";
 import { createTplinkPlugin } from "./monitoring/TplinkPlugin.js";
 import { createPatroniPlugin } from "./monitoring/PatroniPlugin.js";
 import { createAdsensePlugin } from "./monitoring/AdsensePlugin.js";
+import { createGa4Plugin } from "./monitoring/Ga4Plugin.js";
+import { createNagiosPlugin } from "./monitoring/NagiosPlugin.js";
+import { createTplinkSwitchPlugin } from "./monitoring/TplinkSwitchPlugin.js";
 // In future, implement other plugin factory functions using the same pattern
 // import { createOSPlugin } from "./monitoring/OSPlugin.js"
 // import { createMongoDBPlugin } from "./monitoring/MongoDBPlugin.js"
@@ -35,6 +38,9 @@ export default {
     Tplink: createTplinkPlugin,
     Patroni: createPatroniPlugin,
     Adsense: createAdsensePlugin,
+    Ga4: createGa4Plugin,
+    Nagios: createNagiosPlugin,
+    TplinkSwitch: createTplinkSwitchPlugin,
     // CloudflarePlugin: createCloudflarePlugin,
     // EwelinkPlugin: createEwelinkPlugin,
     // MongoDBPlugin: createMongoDBPlugin,

package/dist/plugins/monitoring/AdsensePlugin.js

@@ -30,8 +30,12 @@ export function reportStart(today) {
     const back = shiftDate(today, -29);
     return back < monthStart ? back : monthStart;
 }
-export function reportUrl(account, start, end) {
+export function reportUrl(account, start, end, bySite = false) {
     const q = new URLSearchParams({ dateRange: "CUSTOM", reportingTimeZone: "ACCOUNT_TIME_ZONE", dimensions: "DATE" });
+    // DOMAIN_NAME, not OWNED_SITE_DOMAIN_NAME: the owned-site rows nest (archpaper.com
+    // contains www.archpaper.com and jobs.archpaper.com), so they double count.
+    if (bySite)
+        q.append("dimensions", "DOMAIN_NAME");
     for (const [k, v] of [["startDate", start], ["endDate", end]]) {
         const [y, m, d] = v.split("-").map(Number);
         q.set(`${k}.year`, String(y));
@@ -40,13 +44,14 @@ export function reportUrl(account, start, end) {
     }
     q.append("metrics", "ESTIMATED_EARNINGS");
     q.append("metrics", "PAGE_VIEWS");
+    q.append("metrics", "CLICKS");
     return `${API}/${account}/reports:generate?${q}`;
 }
 /** reports:generate response -> per-day rows. Columns are found by header name, not position. */
 export function parseReport(report) {
     const headers = Array.isArray(report?.headers) ? report.headers : [];
     const col = (name) => headers.findIndex((h) => h?.name === name);
-    const [iDate, iEarn, iViews] = [col("DATE"), col("ESTIMATED_EARNINGS"), col("PAGE_VIEWS")];
+    const [iDate, iEarn, iViews, iClicks] = [col("DATE"), col("ESTIMATED_EARNINGS"), col("PAGE_VIEWS"), col("CLICKS")];
     if (iDate < 0 || iEarn < 0)
         throw new Error("unexpected report shape (no DATE/ESTIMATED_EARNINGS column)");
     // A day with no traffic has no row at all, so an empty report is valid.
@@ -57,14 +62,61 @@ export function parseReport(report) {
             date: String(r?.cells?.[iDate]?.value || ""),
             earnings: Number(r?.cells?.[iEarn]?.value) || 0,
             pageViews: iViews < 0 ? 0 : Number(r?.cells?.[iViews]?.value) || 0,
+            clicks: iClicks < 0 ? 0 : Number(r?.cells?.[iClicks]?.value) || 0,
         })),
     };
 }
+/** A DATE x DOMAIN_NAME report -> per-day rows keyed by site (hostname without a leading www). */
+export function parseSiteReport(report) {
+    const headers = Array.isArray(report?.headers) ? report.headers : [];
+    const iDomain = headers.findIndex((h) => h?.name === "DOMAIN_NAME");
+    const out = new Map();
+    if (iDomain < 0)
+        return out;
+    const { days } = parseReport(report);
+    const rows = Array.isArray(report?.rows) ? report.rows : [];
+    rows.forEach((r, i) => {
+        // www.example.com and example.com are one site to a reader, so they merge.
+        const domain = String(r?.cells?.[iDomain]?.value || "").replace(/^www\./, "");
+        if (!domain)
+            return;
+        if (!out.has(domain))
+            out.set(domain, []);
+        const list = out.get(domain);
+        const same = list.find((d) => d.date === days[i].date);
+        if (same) {
+            same.earnings += days[i].earnings;
+            same.pageViews += days[i].pageViews;
+            same.clicks += days[i].clicks;
+        }
+        else
+            list.push({ ...days[i] });
+    });
+    return out;
+}
+const MAX_SITES = 20;
+/**
+ * Per-site figures, biggest earner first. Domains that earned nothing in the
+ * window are dropped: AdSense lists every hostname an ad tag loaded on, which
+ * includes admin hosts and previews that are noise here. `daily` is earnings
+ * only, to keep the payload small.
+ */
+export function summarizeSites(bySite, today) {
+    return [...bySite.entries()]
+        .map(([domain, days]) => {
+        const sum = summarize(days, today);
+        return { domain, ...sum, daily: sum.daily.map((d) => cents(d.earnings)), window: days.reduce((t, d) => t + d.earnings, 0) };
+    })
+        .filter((s) => s.window > 0)
+        .sort((a, b) => b.window - a.window)
+        .slice(0, MAX_SITES)
+        .map(({ window: _window, ...site }) => site);
+}
 const cents = (n) => Math.round(n * 100) / 100;
 /** Roll per-day rows up into the figures the tile shows. `last7` includes today, as AdSense's own "Last 7 days" does. */
 export function summarize(days, today) {
     const by = new Map(days.map((d) => [d.date, d]));
-    const day = (date) => by.get(date) || { date, earnings: 0, pageViews: 0 };
+    const day = (date) => by.get(date) || { date, earnings: 0, pageViews: 0, clicks: 0 };
     const span = (n) => Array.from({ length: n }, (_, i) => day(shiftDate(today, i - n + 1)));
     const week = span(7);
     const last7 = week.reduce((s, d) => s + d.earnings, 0);
@@ -76,13 +128,14 @@ export function summarize(days, today) {
         last7: cents(last7),
         monthToDate: cents(days.filter((d) => d.date.startsWith(month)).reduce((s, d) => s + d.earnings, 0)),
         pageViews7,
+        clicks7: week.reduce((s, d) => s + d.clicks, 0),
         // Page RPM over the same 7 days: earnings per thousand page views.
         rpm: pageViews7 ? cents((last7 / pageViews7) * 1000) : 0,
         // Gap-filled so the sparkline has one point per day, oldest first.
         daily: span(30),
     };
 }
-async function getJson(url, init, timeout) {
+export async function getJson(url, init, timeout) {
     const res = await fetch(url, { ...init, signal: AbortSignal.timeout(timeout) });
     const body = await res.json().catch(() => ({}));
     if (!res.ok) {
@@ -92,33 +145,53 @@ async function getJson(url, init, timeout) {
     }
     return body;
 }
+/** Trade a refresh token for a one-hour access token. Shared with the ga4 plugin. */
+export async function googleAccessToken(cfg, timeout) {
+    const tok = await getJson(TOKEN_URL, {
+        method: "POST",
+        headers: { "Content-Type": "application/x-www-form-urlencoded" },
+        body: new URLSearchParams({
+            grant_type: "refresh_token",
+            client_id: cfg.clientId || "",
+            client_secret: cfg.clientSecret || "",
+            refresh_token: cfg.refreshToken || "",
+        }).toString(),
+    }, timeout);
+    return tok.access_token;
+}
 export function createAdsensePlugin() {
     let refreshTimer = null;
     // Resolved once: the account and its time zone do not change between polls.
     let account = null;
     const collect = async (cfg) => {
         const timeout = cfg.timeout || 15000;
-        const tok = await getJson(TOKEN_URL, {
-            method: "POST",
-            headers: { "Content-Type": "application/x-www-form-urlencoded" },
-            body: new URLSearchParams({
-                grant_type: "refresh_token",
-                client_id: cfg.clientId || "",
-                client_secret: cfg.clientSecret || "",
-                refresh_token: cfg.refreshToken || "",
-            }).toString(),
-        }, timeout);
-        const auth = { headers: { Authorization: `Bearer ${tok.access_token}` } };
+        const auth = { headers: { Authorization: `Bearer ${await googleAccessToken(cfg, timeout)}` } };
         if (!account) {
             const list = (await getJson(`${API}/accounts`, auth, timeout))?.accounts || [];
             const a = cfg.accountId ? list.find((x) => x.name === cfg.accountId) : list[0];
             if (!a)
                 throw new Error(cfg.accountId ? `account ${cfg.accountId} not visible to this token` : "no AdSense account visible to this token");
-            account = { name: a.name, timeZone: a.timeZone?.id };
+            account = { name: a.name, displayName: a.displayName, timeZone: a.timeZone?.id };
         }
         const today = todayIn(account.timeZone);
-        const { currency, days } = parseReport(await getJson(reportUrl(account.name, reportStart(today), today), auth, timeout));
-        return { accountId: account.name, currency, asOf: today, ...summarize(days, today) };
+        const start = reportStart(today);
+        const { currency, days } = parseReport(await getJson(reportUrl(account.name, start, today), auth, timeout));
+        // The per-site breakdown is extra: if it fails, the account totals still report.
+        let sites = [];
+        try {
+            sites = summarizeSites(parseSiteReport(await getJson(reportUrl(account.name, start, today, true), auth, timeout)), today);
+        }
+        catch { /* totals only */ }
+        return {
+            // The account's own name ("The Architect's Newspaper") labels the service.
+            // It overrides the plugin's instance name, which only says "AdSense".
+            ...(account.displayName ? { name: account.displayName } : {}),
+            accountId: account.name,
+            currency,
+            asOf: today,
+            ...summarize(days, today),
+            sites,
+        };
     };
     const refreshFn = async (plugin) => {
         const cfg = (plugin.config || {});
@@ -140,9 +213,9 @@ export function createAdsensePlugin() {
     };
     const monitorFn = async (plugin) => {
         await refreshFn(plugin);
-        // AdSense figures lag by hours; 10 minutes keeps the row inside the
-        // server's 15-minute staleness window without spending API quota.
-        refreshTimer = setInterval(() => refreshFn(plugin), plugin.config?.refreshInterval || 600000);
+        // AdSense figures lag by hours, so 15 minutes loses nothing. The server
+        // allows these rows 30 minutes of silence before calling them offline.
+        refreshTimer = setInterval(() => refreshFn(plugin), plugin.config?.refreshInterval || 900000);
     };
     const teardownFn = async () => {
         if (refreshTimer)

package/dist/plugins/monitoring/Ga4Plugin.js

@@ -0,0 +1,164 @@
+import { createMonitoringPlugin } from "../../lib/MonitoringPlugin.js";
+import { getJson, googleAccessToken, shiftDate, todayIn } from "./AdsensePlugin.js";
+// Google Analytics 4 overview across every account and property the Google
+// login can see.
+//
+// Runs on a user refresh token with scope analytics.readonly, minted the same
+// way as the adsense plugin's (client/etc/adsense-auth.mjs --source=ga4).
+//
+// Each poll lists the account/property tree from the Admin API, then for each
+// property asks the Data API for: active users right now (realtime), users,
+// sessions and page views for today, yesterday and the last 7 days, and 30
+// days of daily figures. 7-day users come from GA itself, never from summing
+// days: one person on three days is one user, not three.
+//
+// The report carries its own 30-day history, so the server stores no history
+// rows for this type. Hiding properties and nicknames live in the portal.
+const ADMIN = "https://analyticsadmin.googleapis.com/v1beta";
+const DATA = "https://analyticsdata.googleapis.com/v1beta";
+const DAYS = 30;
+// Parallel property requests. GA quotas are per property, so this only bounds
+// how hard one poll hits the network.
+const CONCURRENCY = 4;
+const ZERO = { users: 0, sessions: 0, views: 0 };
+const METRICS = [{ name: "activeUsers" }, { name: "sessions" }, { name: "screenPageViews" }];
+/** accountSummaries response -> accounts with their GA4 properties. */
+export function parseAccounts(summaries) {
+    return (summaries || []).map((a) => ({
+        id: String(a?.account || "").replace(/^accounts\//, ""),
+        name: String(a?.displayName || a?.account || ""),
+        properties: (a?.propertySummaries || [])
+            .filter((p) => !p?.propertyType || p.propertyType === "PROPERTY_TYPE_ORDINARY")
+            .map((p) => ({ id: String(p?.property || "").replace(/^properties\//, ""), name: String(p?.displayName || p?.property || "") })),
+    }));
+}
+const num = (v) => Number(v?.value) || 0;
+const totals = (row) => row ? { users: num(row.metricValues?.[0]), sessions: num(row.metricValues?.[1]), views: num(row.metricValues?.[2]) } : { ...ZERO };
+/**
+ * batchRunReports response -> the figures the portal shows.
+ * Report 0: no dimensions, three named date ranges (today, yesterday, last7).
+ * Report 1: one row per date over the last 30 days.
+ */
+export function parseProperty(batch, now = new Date()) {
+    const [summary, byDate] = batch?.reports || [];
+    // A multi-range report adds a "dateRange" dimension holding each range's name.
+    const range = (name) => totals((summary?.rows || []).find((r) => r?.dimensionValues?.[0]?.value === name));
+    // Gap-fill the 30 days in the property's own time zone: GA leaves days with
+    // no traffic out entirely.
+    const today = todayIn(byDate?.metadata?.timeZone || summary?.metadata?.timeZone, now);
+    const by = new Map();
+    for (const r of byDate?.rows || []) {
+        const d = String(r?.dimensionValues?.[0]?.value || "");
+        if (d.length === 8)
+            by.set(`${d.slice(0, 4)}-${d.slice(4, 6)}-${d.slice(6)}`, totals(r));
+    }
+    const dates = Array.from({ length: DAYS }, (_, i) => shiftDate(today, i - DAYS + 1));
+    const days = dates.map((d) => by.get(d) || ZERO);
+    return {
+        asOf: today,
+        today: range("today"),
+        yesterday: range("yesterday"),
+        last7: range("last7"),
+        daily: {
+            start: dates[0],
+            users: days.map((d) => d.users),
+            sessions: days.map((d) => d.sessions),
+            views: days.map((d) => d.views),
+        },
+    };
+}
+/** runRealtimeReport -> users active in the last 30 minutes. No rows means zero. */
+export const parseRealtime = (r) => num(r?.rows?.[0]?.metricValues?.[0]);
+export const BATCH_BODY = {
+    requests: [
+        {
+            dateRanges: [
+                { startDate: "today", endDate: "today", name: "today" },
+                { startDate: "yesterday", endDate: "yesterday", name: "yesterday" },
+                { startDate: "6daysAgo", endDate: "today", name: "last7" },
+            ],
+            metrics: METRICS,
+        },
+        {
+            dateRanges: [{ startDate: `${DAYS - 1}daysAgo`, endDate: "today" }],
+            dimensions: [{ name: "date" }],
+            metrics: METRICS,
+            limit: DAYS + 5,
+        },
+    ],
+};
+async function inBatches(items, size, fn) {
+    const out = [];
+    for (let i = 0; i < items.length; i += size)
+        out.push(...(await Promise.all(items.slice(i, i + size).map(fn))));
+    return out;
+}
+export function createGa4Plugin() {
+    let refreshTimer = null;
+    const collect = async (cfg) => {
+        const timeout = cfg.timeout || 20000;
+        const token = await googleAccessToken(cfg, timeout);
+        const get = (url) => getJson(url, { headers: { Authorization: `Bearer ${token}` } }, timeout);
+        const post = (url, body) => getJson(url, {
+            method: "POST",
+            headers: { Authorization: `Bearer ${token}`, "Content-Type": "application/json" },
+            body: JSON.stringify(body),
+        }, timeout);
+        // Every account and property this login can see, across pages.
+        const summaries = [];
+        let page = "";
+        do {
+            const r = await get(`${ADMIN}/accountSummaries?pageSize=200${page ? `&pageToken=${encodeURIComponent(page)}` : ""}`);
+            summaries.push(...(r?.accountSummaries || []));
+            page = r?.nextPageToken || "";
+        } while (page);
+        const allow = Array.isArray(cfg.accounts) && cfg.accounts.length ? new Set(cfg.accounts.map(String)) : null;
+        // Filtered before any report is requested: an account outside the list is
+        // never queried, so its figures never reach this customer.
+        const accounts = parseAccounts(summaries).filter((a) => !allow || allow.has(a.id));
+        for (const account of accounts) {
+            account.properties = await inBatches(account.properties, CONCURRENCY, async (p) => {
+                // One property failing (no access to its data, quota) must not hide the rest.
+                try {
+                    const [batch, realtime] = await Promise.all([
+                        post(`${DATA}/properties/${p.id}:batchRunReports`, BATCH_BODY),
+                        post(`${DATA}/properties/${p.id}:runRealtimeReport`, { metrics: [{ name: "activeUsers" }] }).catch(() => null),
+                    ]);
+                    return { ...p, ...parseProperty(batch), activeNow: realtime ? parseRealtime(realtime) : null };
+                }
+                catch (e) {
+                    return { ...p, error: String(e?.message || e).slice(0, 160) };
+                }
+            });
+        }
+        const properties = accounts.reduce((n, a) => n + a.properties.length, 0);
+        return { name: "Google Analytics", accounts, properties };
+    };
+    const refreshFn = async (plugin) => {
+        const cfg = (plugin.config || {});
+        if (!cfg.clientId || !cfg.clientSecret || !cfg.refreshToken) {
+            await plugin.send({ error: "ga4 plugin needs clientId, clientSecret and refreshToken" });
+            return;
+        }
+        try {
+            await plugin.send(await collect(cfg));
+        }
+        catch (e) {
+            await plugin.send({
+                error: String(e?.message || e).slice(0, 160),
+                ...(e?.code === "invalid_grant" ? { authExpired: true } : {}),
+            });
+        }
+    };
+    const monitorFn = async (plugin) => {
+        await refreshFn(plugin);
+        refreshTimer = setInterval(() => refreshFn(plugin), plugin.config?.refreshInterval || 900000);
+    };
+    const teardownFn = async () => {
+        if (refreshTimer)
+            clearInterval(refreshTimer);
+        refreshTimer = null;
+    };
+    return createMonitoringPlugin("ga4", "ga4", "Google Analytics 4 overview (active now, users, sessions and views per property)", async () => { }, monitorFn, refreshFn, teardownFn);
+}
+export default createGa4Plugin;

package/dist/plugins/monitoring/NagiosPlugin.js

@@ -0,0 +1,138 @@
+import { execFile } from "node:child_process";
+import { createMonitoringPlugin } from "../../lib/MonitoringPlugin.js";
+const STATES = ["ok", "warning", "critical", "unknown"];
+// Output is capped: a check printing a megabyte would otherwise be sent every
+// minute and stored in history.
+const MAX_OUTPUT = 4000;
+export function stateOf(exitCode) {
+    return exitCode != null && exitCode >= 0 && exitCode <= 3 ? STATES[exitCode] : "unknown";
+}
+const num = (s) => (s == null || s === "" || Number.isNaN(Number(s)) ? undefined : Number(s));
+/**
+ * Parse performance data: space-separated `'label'=value[UOM];[warn];[crit];[min];[max]`.
+ * Labels may be quoted to contain spaces, with '' standing for a literal quote.
+ * Malformed items are skipped rather than failing the whole check.
+ */
+export function parsePerfdata(raw) {
+    const out = [];
+    const re = /\s*('(?:[^']|'')+'|[^\s=']+)=(\S+)/g;
+    let m;
+    while ((m = re.exec(raw))) {
+        const label = m[1].startsWith("'") ? m[1].slice(1, -1).replace(/''/g, "'") : m[1];
+        const [valueUom, warn, crit, min, max] = m[2].split(";");
+        const vm = valueUom.match(/^(-?[\d.]+(?:[eE][-+]?\d+)?)([a-zA-Z%]*)$/);
+        if (!vm)
+            continue; // "U" (undetermined) or garbage
+        out.push({
+            label,
+            value: Number(vm[1]),
+            ...(vm[2] ? { uom: vm[2] } : {}),
+            ...(warn ? { warn } : {}),
+            ...(crit ? { crit } : {}),
+            ...(num(min) != null ? { min: num(min) } : {}),
+            ...(num(max) != null ? { max: num(max) } : {}),
+        });
+    }
+    return out;
+}
+/**
+ * Split plugin output into the status line, the long output and perfdata.
+ * Perfdata can follow "|" on the first line and on any long-output line after
+ * a "|" there (the Nagios 3 multi-line form).
+ */
+export function parseOutput(stdout) {
+    const lines = stdout.replace(/\r/g, "").replace(/\n+$/, "").split("\n");
+    const [first = "", ...rest] = lines;
+    const [output, firstPerf = ""] = splitPipe(first);
+    let perf = firstPerf;
+    const long = [];
+    let inPerf = false;
+    for (const line of rest) {
+        if (inPerf) {
+            perf += " " + line;
+            continue;
+        }
+        const [text, more] = splitPipe(line);
+        if (text.trim())
+            long.push(text.trimEnd());
+        if (more != null) {
+            perf += " " + more;
+            inPerf = true;
+        }
+    }
+    return {
+        output: output.trim(),
+        ...(long.length ? { longOutput: long.join("\n").slice(0, MAX_OUTPUT) } : {}),
+        perfdata: parsePerfdata(perf),
+    };
+}
+function splitPipe(line) {
+    const i = line.indexOf("|");
+    return i < 0 ? [line] : [line.slice(0, i), line.slice(i + 1)];
+}
+export async function runCheck(check, defaults = {}) {
+    const [bin, ...args] = check.command;
+    const resolved = defaults.pluginDir && !bin.includes("/") ? `${defaults.pluginDir.replace(/\/$/, "")}/${bin}` : bin;
+    const timeoutMs = (check.timeout ?? defaults.timeout ?? 30) * 1000;
+    const started = Date.now();
+    return new Promise((resolve) => {
+        execFile(resolved, args, { timeout: timeoutMs, maxBuffer: 256 * 1024, env: { ...process.env, ...(check.env || {}) }, killSignal: "SIGKILL" }, (err, stdout, stderr) => {
+            const durationMs = Date.now() - started;
+            const base = { name: check.name, command: bin.split("/").pop() || bin, durationMs };
+            // A non-zero exit is the plugin reporting a state, not a failure to run.
+            const exitCode = err ? (typeof err.code === "number" ? err.code : null) : 0;
+            if (err && err.killed) {
+                return resolve({ ...base, state: "unknown", exitCode: null, output: `Check timed out after ${timeoutMs / 1000}s`, perfdata: [], timedOut: true });
+            }
+            if (err && exitCode == null) {
+                // Couldn't start it at all: ENOENT, EACCES and so on.
+                return resolve({ ...base, state: "unknown", exitCode: null, output: `Could not run ${base.command}: ${err.code || err.message}`, perfdata: [], error: String(err.message || err).slice(0, 300) });
+            }
+            const parsed = parseOutput(String(stdout || stderr || "").slice(0, MAX_OUTPUT));
+            resolve({ ...base, state: stateOf(exitCode), exitCode, ...parsed, output: parsed.output || "(no output)" });
+        });
+    });
+}
+function slug(s) {
+    return s.toLowerCase().replace(/[^a-z0-9_.-]+/g, "-").replace(/^-+|-+$/g, "");
+}
+export function createNagiosPlugin() {
+    let refreshTimer = null;
+    let running = false;
+    const checksOf = (plugin) => {
+        const cfg = (plugin.config || {});
+        return (Array.isArray(cfg.checks) ? cfg.checks : []).filter((c) => c?.name && Array.isArray(c.command) && c.command.length && c.command.every((a) => typeof a === "string"));
+    };
+    const refreshFn = async (plugin) => {
+        // A slow check must not pile up overlapping runs of itself.
+        if (running)
+            return;
+        running = true;
+        try {
+            const cfg = (plugin.config || {});
+            await Promise.all(checksOf(plugin).map(async (check) => {
+                const result = await runCheck(check, cfg);
+                // The interval tells the dashboard how long silence is normal, so a
+                // check that runs every 10 minutes doesn't read OFFLINE in between.
+                await plugin.send({ ...result, intervalMs: cfg.refreshInterval || 60000 }, `nagios-${slug(check.name)}`);
+            }));
+        }
+        finally {
+            running = false;
+        }
+    };
+    const monitorFn = async (plugin) => {
+        const n = checksOf(plugin).length;
+        if (!n)
+            console.warn("nagios: no valid checks configured (each needs a name and a command array)");
+        await refreshFn(plugin);
+        refreshTimer = setInterval(() => refreshFn(plugin), plugin.config?.refreshInterval || 60000);
+    };
+    const teardownFn = async () => {
+        if (refreshTimer)
+            clearInterval(refreshTimer);
+        refreshTimer = null;
+    };
+    return createMonitoringPlugin("nagios", "nagios", "Nagios-compatible check commands", async () => { }, monitorFn, refreshFn, teardownFn);
+}
+export default createNagiosPlugin;

package/dist/plugins/monitoring/TplinkSwitchPlugin.js

@@ -0,0 +1,161 @@
+import { createHash } from "node:crypto";
+import { createMonitoringPlugin } from "../../lib/MonitoringPlugin.js";
+const HEADERS = { "Content-Type": "application/json;charset=utf-8", "X-Requested-With": "XMLHttpRequest", SourceType: "switch_web" };
+const LOOP = { "0": "normal", "1": "blocked", "2": "loop" };
+export const md5Upper = (s) => createHash("md5").update(s).digest("hex").toUpperCase();
+/** Build the report from the raw API results. Pure, so the check can drive it. */
+export function buildReport(target, raw, rates) {
+    const info = raw.info || {};
+    const trafficById = new Map((raw.traffic?.port_list || []).map((p) => [p.port_id, p]));
+    const loopById = new Map((raw.loops?.port_list || []).map((p) => [p.port_id, p]));
+    const interfaces = (raw.ports?.port_list || []).map((p) => {
+        const speed = String(p.port_speed_actual || "");
+        const up = !!speed && speed !== "Link Down";
+        const t = trafficById.get(p.port_id);
+        const r = rates.get(p.port_id) || {};
+        return {
+            name: `port ${p.port_id}`,
+            up,
+            adminUp: p.port_state_cfg !== "0",
+            ...(up ? { speed, duplex: p.port_duplex_actual } : {}),
+            ...(t ? { rxBytes: t.rx_bytes, txBytes: t.tx_bytes } : {}),
+            ...(r.inBps != null ? { inBps: r.inBps, outBps: r.outBps } : {}),
+            loop: LOOP[String(loopById.get(p.port_id)?.port_state ?? "0")] || "normal",
+        };
+    });
+    const portIds = (raw.ports?.port_list || []).map((p) => p.port_id);
+    const downUplinks = (target.uplinkPorts || []).filter((id) => {
+        const i = portIds.indexOf(id);
+        return i < 0 || !interfaces[i].up;
+    });
+    return {
+        ip: target.host,
+        name: target.name || info.des || target.host,
+        kind: "switch",
+        model: info.hw_ver || info.des,
+        serial: info.serial_number,
+        mac: info.sys_mac_addr,
+        firmware: info.fw_ver,
+        sysDescr: [info.hw_ver || info.des, info.fw_ver && `firmware ${info.fw_ver}`].filter(Boolean).join(", "),
+        reachable: true,
+        portsUp: interfaces.filter((i) => i.up).length,
+        portsTotal: interfaces.length,
+        interfaces,
+        loops: interfaces.filter((i) => i.loop === "loop").map((i) => i.name),
+        blocked: interfaces.filter((i) => i.loop === "blocked").map((i) => i.name),
+        downUplinks: downUplinks.map((id) => `port ${id}`),
+    };
+}
+/** Byte rates from two counter readings. A counter that went backwards (reboot, clear) gives no rate. */
+export function ratesBetween(prev, now) {
+    const out = new Map();
+    if (!prev)
+        return out;
+    const dt = (now.at - prev.at) / 1000;
+    if (dt <= 0)
+        return out;
+    for (const [id, c] of now.ports) {
+        const p = prev.ports.get(id);
+        if (!p || c.rx < p.rx || c.tx < p.tx)
+            continue;
+        out.set(id, { inBps: Math.round((c.rx - p.rx) / dt), outBps: Math.round((c.tx - p.tx) / dt) });
+    }
+    return out;
+}
+export class LoginRefused extends Error {
+}
+async function call(host, path, opts) {
+    const res = await fetch(`http://${host}${path}`, {
+        method: opts.body !== undefined ? "POST" : "GET",
+        headers: opts.token ? { ...HEADERS, Authorization: opts.token } : HEADERS,
+        ...(opts.body !== undefined ? { body: JSON.stringify(opts.body) } : {}),
+        signal: AbortSignal.timeout(opts.timeoutMs),
+    });
+    if (!res.ok)
+        throw new Error(`${path} returned HTTP ${res.status}`);
+    const json = await res.json();
+    if (json?.error_code)
+        throw Object.assign(new Error(`${path} error_code ${json.error_code}`), { code: json.error_code });
+    return json?.result || {};
+}
+export const newSwitchState = () => ({ counters: new Map(), refusedUntil: new Map() });
+/** Log in, read one switch, log out. Throws LoginRefused or a network error. */
+export async function readSwitch(target, cfg, state) {
+    const { counters, refusedUntil } = state;
+    const timeoutMs = cfg.timeoutMs || 8000;
+    const wait = refusedUntil.get(target.host);
+    if (wait && Date.now() < wait) {
+        throw new LoginRefused(`login refused earlier; not retrying until ${new Date(wait).toISOString()} so the switch doesn't lock the account`);
+    }
+    let login;
+    try {
+        login = await call(target.host, "/login/status", { body: { login_user: target.username, login_pwd: md5Upper(target.password) }, timeoutMs });
+    }
+    catch (e) {
+        if (e?.code) {
+            refusedUntil.set(target.host, Date.now() + (cfg.loginBackoffMs || 30 * 60 * 1000));
+            throw new LoginRefused(`login refused (error_code ${e.code}); check the username and password`);
+        }
+        throw e;
+    }
+    refusedUntil.delete(target.host);
+    const token = login.token;
+    try {
+        const [info, ports, traffic, loops] = await Promise.all([
+            call(target.host, "/system_summary/system_information_status", { token, timeoutMs }),
+            call(target.host, "/switching/port_settings_status", { token, timeoutMs }),
+            call(target.host, "/traffic_summary/traffic_summary_port_status", { token, timeoutMs }),
+            call(target.host, "/loop_detection/loop_detection_status", { token, timeoutMs }).catch(() => ({})),
+        ]);
+        const now = {
+            at: Date.now(),
+            ports: new Map((traffic.port_list || []).map((p) => [p.port_id, { rx: Number(p.rx_bytes) || 0, tx: Number(p.tx_bytes) || 0 }])),
+        };
+        const rates = ratesBetween(counters.get(target.host), now);
+        counters.set(target.host, now);
+        return buildReport(target, { info, ports, traffic, loops }, rates);
+    }
+    finally {
+        // Log out every time: these switches allow few admin sessions, and an
+        // idle one held by the agent could lock someone out of the web UI.
+        await call(target.host, "/show_up/logout_status", { token, body: {}, timeoutMs }).catch(() => { });
+    }
+}
+export function createTplinkSwitchPlugin() {
+    let refreshTimer = null;
+    const state = newSwitchState();
+    const refreshFn = async (plugin) => {
+        const cfg = (plugin.config || {});
+        const targets = (cfg.switches || []).filter((s) => s?.host && s.username && s.password);
+        await Promise.all(targets.map(async (target) => {
+            let report;
+            try {
+                report = await readSwitch(target, cfg, state);
+            }
+            catch (e) {
+                report = {
+                    ip: target.host,
+                    name: target.name || target.host,
+                    kind: "switch",
+                    reachable: e instanceof LoginRefused,
+                    error: String(e?.message || e).slice(0, 200),
+                };
+            }
+            await plugin.send(report, `tplinkswitch-${target.host.replace(/[^0-9a-zA-Z]+/g, "-")}`);
+        }));
+    };
+    const monitorFn = async (plugin) => {
+        const cfg = (plugin.config || {});
+        if (!(cfg.switches || []).length)
+            console.warn("tplinkswitch: no switches configured");
+        await refreshFn(plugin);
+        refreshTimer = setInterval(() => refreshFn(plugin), cfg.refreshInterval || 60000);
+    };
+    const teardownFn = async () => {
+        if (refreshTimer)
+            clearInterval(refreshTimer);
+        refreshTimer = null;
+    };
+    return createMonitoringPlugin("tplinkswitch", "tplinkswitch", "TP-Link Omada Easy Managed switch (web API)", async () => { }, monitorFn, refreshFn, teardownFn);
+}
+export default createTplinkSwitchPlugin;

package/dist/plugins/monitoring/WebsitePlugin.js

@@ -130,7 +130,7 @@ export function createWebsitePlugin() {
         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" });
+            const res = await fetch(ep.url, { signal: ctrl.signal, redirect: "follow", headers: ep.headers });
             if (t)
                 clearTimeout(t);
             const body = await res.text();
@@ -180,6 +180,7 @@ export function createWebsitePlugin() {
                     unexpectedStrings: cfg.unexpectedStrings,
                     expectedStatusCode: cfg.expectedStatusCode,
                     timeout: cfg.timeout,
+                    headers: cfg.headers,
                     origin: cfg.origin,
                 }];
         }

package/package.json

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