@nocville/npc 0.2.1 → 0.2.3

package/dist/cjs/npcs/internet-connectivity/index.js

@@ -2,10 +2,13 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.InternetConnectivityNPC = void 0;
 exports.evaluateConnectivityStatus = evaluateConnectivityStatus;
+exports.parseLatencyHost = parseLatencyHost;
 const polling_npc_js_1 = require("../../core/polling-npc.js");
 const thresholds_js_1 = require("../../core/thresholds.js");
 const screen_js_1 = require("../../core/screen.js");
 const config_js_1 = require("../../core/config.js");
+const errors_js_1 = require("../../core/errors.js");
+const http_js_1 = require("../../core/http.js");
 const checks_js_1 = require("./checks.js");
 const defaults_js_1 = require("./defaults.js");
 /**
@@ -16,13 +19,15 @@ const defaults_js_1 = require("./defaults.js");
 function evaluateConnectivityStatus(sample, thresholds) {
     if (sample.allFailed)
         return 'critical';
-    const timeStatus = (0, thresholds_js_1.worstStatus)([
-        (0, thresholds_js_1.evaluateThreshold)(sample.dnsAvg, thresholds.dnsTime),
-        (0, thresholds_js_1.evaluateThreshold)(sample.httpAvg, thresholds.httpTime),
-        (0, thresholds_js_1.evaluateThreshold)(sample.latencyAvg, thresholds.latencyTime),
-    ]);
-    const failStatus = sample.anyFailed ? 'warning' : 'healthy';
-    return (0, thresholds_js_1.worstStatus)([timeStatus, failStatus]);
+    const statuses = [sample.anyFailed ? 'warning' : 'healthy'];
+    if (sample.dnsAvg !== null)
+        statuses.push((0, thresholds_js_1.evaluateThreshold)(sample.dnsAvg, thresholds.dnsTime));
+    if (sample.httpAvg !== null)
+        statuses.push((0, thresholds_js_1.evaluateThreshold)(sample.httpAvg, thresholds.httpTime));
+    if (sample.latencyAvg !== null) {
+        statuses.push((0, thresholds_js_1.evaluateThreshold)(sample.latencyAvg, thresholds.latencyTime));
+    }
+    return (0, thresholds_js_1.worstStatus)(statuses);
 }
 /** Scale a threshold set by a ratio, preserving direction. */
 function scaleThresholds(base, ratio) {
@@ -37,6 +42,30 @@ function scaleThresholds(base, ratio) {
         latencyTime: scale(base.latencyTime),
     };
 }
+/**
+ * Parse a latency target: "host", "host:port", "[ipv6]:port" or a bare IPv6
+ * address. Throws NpcConfigError on an out-of-range port.
+ */
+function parseLatencyHost(input, defaultPort = defaults_js_1.DEFAULTS.latencyPort) {
+    const s = input.trim();
+    const toPort = (raw) => {
+        const port = Number(raw);
+        if (!Number.isInteger(port) || port < 1 || port > 65535) {
+            throw new errors_js_1.NpcConfigError(`Invalid port in latency host "${s}"`);
+        }
+        return port;
+    };
+    const bracketed = s.match(/^\[([^\]]+)\](?::(\d*))?$/);
+    if (bracketed) {
+        return { host: bracketed[1], port: bracketed[2] ? toPort(bracketed[2]) : defaultPort };
+    }
+    const colons = s.split(':').length - 1;
+    if (colons === 1) {
+        const [host, port] = s.split(':');
+        return { host, port: toPort(port) };
+    }
+    return { host: s, port: defaultPort }; // plain host, or a bare IPv6 address
+}
 class InternetConnectivityNPC extends polling_npc_js_1.PollingNPC {
     dnsHosts;
     httpUrls;
@@ -53,10 +82,16 @@ class InternetConnectivityNPC extends polling_npc_js_1.PollingNPC {
         });
         this.dnsHosts = config.dnsHosts ?? defaults_js_1.DEFAULTS.dnsHosts;
         this.httpUrls = config.httpUrls ?? defaults_js_1.DEFAULTS.httpUrls;
-        this.latencyHosts = config.latencyHosts
-            ? parseLatencyHosts(config.latencyHosts)
-            : defaults_js_1.DEFAULTS.latencyHosts;
-        this.httpTimeout = config.httpTimeout ?? defaults_js_1.DEFAULTS.httpTimeout;
+        this.latencyHosts = (config.latencyHosts ?? defaults_js_1.DEFAULTS.latencyHosts).map((h) => typeof h === 'string' ? parseLatencyHost(h) : h);
+        // Every check must finish well inside the poll interval.
+        this.httpTimeout = Math.min(Math.max(500, config.httpTimeout ?? defaults_js_1.DEFAULTS.httpTimeout), this.pollInterval / 2);
+        const badUrl = this.httpUrls.find((u) => !(0, http_js_1.isHttpUrl)(u));
+        if (badUrl !== undefined) {
+            throw new errors_js_1.NpcConfigError(`--http-urls: "${badUrl}" is not an http(s) URL`);
+        }
+        if (this.dnsHosts.length === 0 && this.httpUrls.length === 0) {
+            throw new errors_js_1.NpcConfigError('internet-connectivity needs at least one DNS host or HTTP URL');
+        }
         // Threshold resolution: explicit thresholds win; else if the legacy
         // --slow-threshold differs from the default, scale the live thresholds by
         // that ratio for back-compat; else use the defaults.
@@ -92,115 +127,91 @@ class InternetConnectivityNPC extends polling_npc_js_1.PollingNPC {
     }
     async collect() {
         const [dnsResults, httpResults, latencyResults] = await Promise.all([
-            (0, checks_js_1.checkDns)(this.dnsHosts),
+            (0, checks_js_1.checkDns)(this.dnsHosts, this.httpTimeout),
             (0, checks_js_1.checkHttp)(this.httpUrls, this.httpTimeout),
-            (0, checks_js_1.checkLatency)(this.latencyHosts),
+            (0, checks_js_1.checkLatency)(this.latencyHosts, this.httpTimeout),
         ]);
-        const dnsOk = dnsResults.filter((r) => r.ok).length;
-        const dnsFail = dnsResults.length - dnsOk;
-        const httpOk = httpResults.filter((r) => r.ok).length;
-        const httpFail = httpResults.length - httpOk;
-        const dnsAvg = avgTime(dnsResults);
-        const httpAvg = avgTime(httpResults);
-        const latencyAvg = avgTime(latencyResults);
+        const dnsOk = countOk(dnsResults);
+        const httpOk = countOk(httpResults);
+        const latencyOk = countOk(latencyResults);
+        const dnsAvg = avgOkTime(dnsResults);
+        const httpAvg = avgOkTime(httpResults);
+        const latencyAvg = avgOkTime(latencyResults);
         const isOnline = dnsOk > 0 || httpOk > 0;
-        const allFailed = dnsOk === 0 && httpOk === 0;
-        const anyFailed = dnsResults.some((r) => !r.ok) ||
-            httpResults.some((r) => !r.ok) ||
-            latencyResults.some((r) => !r.ok);
-        const status = evaluateConnectivityStatus({ allFailed, anyFailed, dnsAvg, httpAvg, latencyAvg }, this.thresholds);
-        const mood = statusToMood(status);
-        const message = allFailed
-            ? this.buildOfflineMessage(dnsResults, httpResults)
-            : this.buildOnlineMessage(dnsAvg, httpAvg, latencyAvg);
-        (0, screen_js_1.pushHistory)(this.dnsHistory, round(dnsAvg));
-        (0, screen_js_1.pushHistory)(this.httpHistory, round(httpAvg));
-        (0, screen_js_1.pushHistory)(this.latencyHistory, round(latencyAvg));
-        const screenData = {
-            layout: 'multi-metric',
-            values: [
-                {
-                    label: 'DNS',
-                    value: `${round(dnsAvg)}ms`,
-                    color: (0, screen_js_1.statusColor)((0, thresholds_js_1.evaluateThreshold)(dnsAvg, this.thresholds.dnsTime)),
-                    sparkline: [...this.dnsHistory],
-                },
-                {
-                    label: 'HTTP',
-                    value: `${round(httpAvg)}ms`,
-                    color: (0, screen_js_1.statusColor)((0, thresholds_js_1.evaluateThreshold)(httpAvg, this.thresholds.httpTime)),
-                    sparkline: [...this.httpHistory],
-                },
-                {
-                    label: 'TCP',
-                    value: `${round(latencyAvg)}ms`,
-                    color: (0, screen_js_1.statusColor)((0, thresholds_js_1.evaluateThreshold)(latencyAvg, this.thresholds.latencyTime)),
-                    sparkline: [...this.latencyHistory],
-                },
-                { label: 'NET', value: isOnline ? 'ONLINE' : 'OFFLINE', color: isOnline ? 'green' : 'red' },
-            ],
-        };
+        const anyFailed = dnsOk < dnsResults.length || httpOk < httpResults.length || latencyOk < latencyResults.length;
+        const status = evaluateConnectivityStatus({ allFailed: !isOnline, anyFailed, dnsAvg, httpAvg, latencyAvg }, this.thresholds);
+        const message = isOnline
+            ? `Online | DNS: ${fmtMs(dnsAvg)} | HTTP: ${fmtMs(httpAvg)} | Latency: ${fmtMs(latencyAvg)}` +
+                (anyFailed ? ` | ${failureSummary(dnsResults, httpResults, latencyResults)}` : '')
+            : offlineMessage(dnsResults, httpResults);
         return {
             status,
-            mood,
+            mood: (0, thresholds_js_1.moodForStatus)(status),
             message,
             subStatus: isOnline ? undefined : 'offline',
-            screenData,
+            screenData: {
+                layout: 'multi-metric',
+                values: [
+                    this.panel('DNS', dnsResults, dnsAvg, this.dnsHistory, this.thresholds.dnsTime),
+                    this.panel('HTTP', httpResults, httpAvg, this.httpHistory, this.thresholds.httpTime),
+                    this.panel('TCP', latencyResults, latencyAvg, this.latencyHistory, this.thresholds.latencyTime),
+                    {
+                        label: 'NET',
+                        value: isOnline ? 'ONLINE' : 'OFFLINE',
+                        color: isOnline ? 'green' : 'red',
+                    },
+                ],
+            },
             metrics: {
-                dns_avg_ms: round(dnsAvg),
-                http_avg_ms: round(httpAvg),
-                latency_avg_ms: round(latencyAvg),
+                dns_avg_ms: round(dnsAvg ?? 0),
+                http_avg_ms: round(httpAvg ?? 0),
+                latency_avg_ms: round(latencyAvg ?? 0),
                 dns_ok_count: dnsOk,
-                dns_fail_count: dnsFail,
+                dns_fail_count: dnsResults.length - dnsOk,
                 http_ok_count: httpOk,
-                http_fail_count: httpFail,
+                http_fail_count: httpResults.length - httpOk,
+                latency_ok_count: latencyOk,
+                latency_fail_count: latencyResults.length - latencyOk,
                 is_online: isOnline ? 1 : 0,
             },
         };
     }
-    buildOnlineMessage(dnsAvg, httpAvg, latencyAvg) {
-        return `Online | DNS: ${round(dnsAvg)}ms | HTTP: ${round(httpAvg)}ms | Latency: ${round(latencyAvg)}ms`;
-    }
-    buildOfflineMessage(dnsResults, httpResults) {
-        const problems = [];
-        if (dnsResults.every((r) => !r.ok)) {
-            problems.push('DNS resolution failed');
-        }
-        if (httpResults.every((r) => !r.ok)) {
-            problems.push('no HTTP connectivity');
-        }
-        return `OFFLINE: ${problems.join(', ') || 'all checks failed'}`;
+    /**
+     * One dashboard panel. A category whose checks all failed shows FAIL in red
+     * (and a 0 sparkline sample) rather than a misleading latency; a partial
+     * failure is amber.
+     */
+    panel(label, results, avg, history, threshold) {
+        if (results.length === 0)
+            return { label, value: 'off', color: 'gray' };
+        (0, screen_js_1.pushHistory)(history, round(avg ?? 0));
+        const sparkline = [...history];
+        if (avg === null)
+            return { label, value: 'FAIL', color: 'red', sparkline };
+        const color = countOk(results) < results.length ? 'amber' : (0, screen_js_1.statusColor)((0, thresholds_js_1.evaluateThreshold)(avg, threshold));
+        return { label, value: fmtMs(avg), color, sparkline };
     }
     /**
-     * Build config from CLI flags. Merges with any programmatic overrides.
+     * Build config from CLI flags. List flags are comma-separated; latency
+     * hosts accept "host", "host:port" or "[ipv6]:port".
      */
     static configFromFlags(flags) {
         const config = {};
-        const dnsHostsRaw = (0, config_js_1.stringFlag)(flags, 'dns-hosts');
-        if (dnsHostsRaw) {
-            config.dnsHosts = dnsHostsRaw.split(',').map((s) => s.trim());
-        }
-        const httpUrlsRaw = (0, config_js_1.stringFlag)(flags, 'http-urls');
-        if (httpUrlsRaw) {
-            config.httpUrls = httpUrlsRaw.split(',').map((s) => s.trim());
-        }
-        const latencyHostsRaw = (0, config_js_1.stringFlag)(flags, 'latency-hosts');
-        if (latencyHostsRaw) {
-            config.latencyHosts = latencyHostsRaw.split(',').map((s) => {
-                const trimmed = s.trim();
-                const colonIndex = trimmed.lastIndexOf(':');
-                if (colonIndex !== -1) {
-                    const host = trimmed.slice(0, colonIndex);
-                    const port = Number(trimmed.slice(colonIndex + 1));
-                    if (!Number.isNaN(port))
-                        return { host, port };
-                }
-                return { host: trimmed, port: 80 };
-            });
-        }
+        const dnsHosts = (0, config_js_1.listFlag)(flags, 'dns-hosts');
+        if (dnsHosts)
+            config.dnsHosts = dnsHosts;
+        const httpUrls = (0, config_js_1.listFlag)(flags, 'http-urls');
+        if (httpUrls)
+            config.httpUrls = httpUrls;
+        const latencyHosts = (0, config_js_1.listFlag)(flags, 'latency-hosts');
+        if (latencyHosts)
+            config.latencyHosts = latencyHosts.map((h) => parseLatencyHost(h));
         const slowThreshold = (0, config_js_1.numberFlag)(flags, 'slow-threshold');
         if (slowThreshold !== undefined)
             config.slowThreshold = slowThreshold;
+        const timeout = (0, config_js_1.numberFlag)(flags, 'timeout');
+        if (timeout !== undefined)
+            config.httpTimeout = timeout;
         const pollInterval = (0, config_js_1.numberFlag)(flags, 'poll-interval');
         if (pollInterval !== undefined)
             config.pollInterval = pollInterval;
@@ -209,43 +220,35 @@ class InternetConnectivityNPC extends polling_npc_js_1.PollingNPC {
 }
 exports.InternetConnectivityNPC = InternetConnectivityNPC;
 // ---------- Helpers ----------
-function avgTime(results) {
-    if (results.length === 0)
-        return 0;
-    const sum = results.reduce((acc, r) => acc + r.timeMs, 0);
-    return sum / results.length;
+function countOk(results) {
+    return results.filter((r) => r.ok).length;
+}
+/** Mean time of the successful checks only — a 5s timeout is a failure, not a latency. */
+function avgOkTime(results) {
+    const ok = results.filter((r) => r.ok);
+    if (ok.length === 0)
+        return null;
+    return ok.reduce((acc, r) => acc + r.timeMs, 0) / ok.length;
 }
 function round(n) {
     return Math.round(n * 100) / 100;
 }
-function statusToMood(status) {
-    switch (status) {
-        case 'healthy':
-            return 'happy';
-        case 'warning':
-            return 'concerned';
-        case 'critical':
-            return 'stressed';
-        default:
-            return 'idle';
-    }
+function fmtMs(n) {
+    return n === null ? 'FAIL' : `${Math.round(n)}ms`;
 }
-/**
- * Normalise latency hosts from either string[] (CLI) or LatencyHost[].
- * String entries can be "host" or "host:port".
- */
-function parseLatencyHosts(input) {
-    return input.map((item) => {
-        if (typeof item === 'object')
-            return item;
-        const colonIndex = item.lastIndexOf(':');
-        if (colonIndex !== -1) {
-            const host = item.slice(0, colonIndex);
-            const port = Number(item.slice(colonIndex + 1));
-            if (!Number.isNaN(port))
-                return { host, port };
-        }
-        return { host: item, port: 80 };
-    });
+/** "failing: 8.8.8.8:443, dns.example" — names the targets, never error text. */
+function failureSummary(...groups) {
+    const failed = groups.flat().filter((r) => !r.ok);
+    return `failing: ${failed.map((r) => r.target).join(', ')}`;
+}
+function offlineMessage(dnsResults, httpResults) {
+    const problems = [];
+    if (dnsResults.length > 0 && dnsResults.every((r) => !r.ok)) {
+        problems.push('DNS resolution failed');
+    }
+    if (httpResults.length > 0 && httpResults.every((r) => !r.ok)) {
+        problems.push('no HTTP connectivity');
+    }
+    return `OFFLINE: ${problems.join(', ') || 'all checks failed'}`;
 }
 //# sourceMappingURL=index.js.map

package/dist/cjs/npcs/log-watcher/buffer.js

@@ -1,9 +1,13 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+exports.WindowCounter = void 0;
 exports.classifyLine = classifyLine;
+exports.cleanLogLine = cleanLogLine;
 exports.pushRecent = pushRecent;
 exports.buildLogScreen = buildLogScreen;
 exports.shouldEmitBurst = shouldEmitBurst;
+const text_js_1 = require("../../core/text.js");
+const activity_js_1 = require("../agent-common/activity.js");
 /** Classify a raw log line against the error/warning patterns. */
 function classifyLine(line, errorRe, warningRe) {
     if (errorRe.test(line))
@@ -12,6 +16,23 @@ function classifyLine(line, errorRe, warningRe) {
         return 'warning';
     return 'info';
 }
+// ANSI CSI/OSC escape sequences (colours, cursor moves, hyperlinks).
+// eslint-disable-next-line no-control-regex
+const ANSI = /\u001b(?:\[[0-?]*[ -/]*[@-~]|\][^\u0007\u001b]*(?:\u0007|\u001b\\))/g;
+// `password=…`, `"token": "…"`, `Authorization: …` style pairs common in logs
+// (redactSecrets covers CLI flags, bearer tokens, URL credentials and keys).
+const SECRET_PAIR = /\b([\w-]*(?:password|passwd|pwd|secret|token|api[_-]?key|access[_-]?key|authorization|cookie|session)[\w-]*)(["']?\s*[:=]\s*)("[^"]*"|'[^']*'|[^\s,;&]+)/gi;
+/**
+ * Prepare a log line for display to the whole team: strip terminal escapes,
+ * redact anything secret-looking, drop control characters and truncate.
+ * Log lines routinely contain tokens and passwords; only redacted text ever
+ * leaves the machine.
+ */
+function cleanLogLine(line, max = 200) {
+    const plain = line.replace(ANSI, '');
+    const redacted = (0, activity_js_1.redactSecrets)(plain).replace(SECRET_PAIR, (_m, key, sep) => `${key}${sep}***`);
+    return (0, text_js_1.sanitizeText)(redacted, max);
+}
 /**
  * Push a line into the bounded ring buffer: each entry is capped at `cap`
  * characters and the buffer keeps only the last `max` entries.
@@ -37,4 +58,44 @@ function buildLogScreen(buffer) {
 function shouldEmitBurst(lastEmit, now, windowMs = 5000) {
     return now - lastEmit >= windowMs;
 }
+/**
+ * Sliding-window error/warning counter in one-second buckets: memory is
+ * bounded by the window length, not by how many lines a runaway logger writes.
+ */
+class WindowCounter {
+    windowMs;
+    buckets = new Map();
+    constructor(windowMs) {
+        this.windowMs = windowMs;
+    }
+    add(level, now = Date.now()) {
+        const key = Math.floor(now / 1000);
+        const bucket = this.buckets.get(key) ?? { errors: 0, warnings: 0 };
+        if (level === 'error')
+            bucket.errors++;
+        else
+            bucket.warnings++;
+        this.buckets.set(key, bucket);
+        if (this.buckets.size > this.windowMs / 1000 + 2)
+            this.prune(now);
+    }
+    counts(now = Date.now()) {
+        this.prune(now);
+        let errors = 0;
+        let warnings = 0;
+        for (const b of this.buckets.values()) {
+            errors += b.errors;
+            warnings += b.warnings;
+        }
+        return { errors, warnings };
+    }
+    prune(now) {
+        const oldest = Math.floor((now - this.windowMs) / 1000);
+        for (const key of this.buckets.keys()) {
+            if (key < oldest)
+                this.buckets.delete(key);
+        }
+    }
+}
+exports.WindowCounter = WindowCounter;
 //# sourceMappingURL=buffer.js.map