@nocville/npc 0.2.2 → 0.3.0

package/dist/npcs/internet-connectivity/checks.js

@@ -1,84 +1,87 @@
 import { promises as dns } from 'node:dns';
 import net from 'node:net';
-export async function checkDns(hosts) {
-    return Promise.all(hosts.map(resolveSingleDns));
+import { NPC_USER_AGENT, discardBody, displayUrl } from '../../core/http.js';
+function errorText(err) {
+    return err instanceof Error ? err.message : String(err);
 }
-async function resolveSingleDns(host) {
-    const start = performance.now();
-    try {
-        await dns.resolve(host);
-        return { host, ok: true, timeMs: performance.now() - start };
-    }
-    catch (err) {
-        return {
-            host,
-            ok: false,
-            timeMs: performance.now() - start,
-            error: err instanceof Error ? err.message : String(err),
-        };
-    }
-}
-export async function checkHttp(urls, timeout) {
-    return Promise.all(urls.map((url) => fetchSingleUrl(url, timeout)));
-}
-async function fetchSingleUrl(url, timeout) {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeout);
-    const start = performance.now();
+// ---------- DNS ----------
+/**
+ * Resolve each host's A records through a dedicated resolver with a bounded
+ * timeout (the default resolver retries for tens of seconds when DNS is down).
+ */
+export async function checkDns(hosts, timeoutMs) {
+    const resolver = new dns.Resolver({
+        timeout: Math.max(250, Math.floor(timeoutMs / 2)),
+        tries: 2,
+    });
+    let timer;
+    const deadline = new Promise((resolve) => {
+        timer = setTimeout(() => resolve('timeout'), timeoutMs);
+    });
     try {
-        const response = await fetch(url, { signal: controller.signal });
-        // Consume body to ensure connection is completed
-        await response.text();
-        return {
-            url,
-            ok: response.ok,
-            timeMs: performance.now() - start,
-            statusCode: response.status,
-        };
-    }
-    catch (err) {
-        return {
-            url,
-            ok: false,
-            timeMs: performance.now() - start,
-            error: err instanceof Error ? err.message : String(err),
-        };
+        return await Promise.all(hosts.map(async (host) => {
+            const start = performance.now();
+            try {
+                const outcome = await Promise.race([resolver.resolve4(host), deadline]);
+                if (outcome === 'timeout')
+                    return { target: host, ok: false, timeMs: 0, error: 'timeout' };
+                return { target: host, ok: true, timeMs: performance.now() - start };
+            }
+            catch (err) {
+                return { target: host, ok: false, timeMs: 0, error: errorText(err) };
+            }
+        }));
     }
     finally {
         clearTimeout(timer);
+        resolver.cancel();
     }
 }
-export async function checkLatency(hosts) {
-    return Promise.all(hosts.map(measureTcpConnect));
+// ---------- HTTP ----------
+/**
+ * Time to response headers for each URL. The body is discarded unread, so a
+ * large or endless response costs nothing. Only 2xx counts as reachable.
+ */
+export async function checkHttp(urls, timeoutMs) {
+    return Promise.all(urls.map(async (url) => {
+        const target = displayUrl(url); // never echo credentials or query tokens
+        const start = performance.now();
+        try {
+            const res = await fetch(url, {
+                signal: AbortSignal.timeout(timeoutMs),
+                headers: { 'User-Agent': NPC_USER_AGENT },
+            });
+            const timeMs = performance.now() - start;
+            await discardBody(res);
+            return res.ok
+                ? { target, ok: true, timeMs }
+                : { target, ok: false, timeMs: 0, error: `HTTP ${res.status}` };
+        }
+        catch (err) {
+            return { target, ok: false, timeMs: 0, error: errorText(err) };
+        }
+    }));
+}
+// ---------- Latency (TCP connect) ----------
+/** Time to establish a TCP connection to each host:port. */
+export async function checkLatency(hosts, timeoutMs) {
+    return Promise.all(hosts.map((h) => measureTcpConnect(h, timeoutMs)));
 }
-function measureTcpConnect(target) {
+function measureTcpConnect(target, timeoutMs) {
+    const label = target.host.includes(':')
+        ? `[${target.host}]:${target.port}`
+        : `${target.host}:${target.port}`;
     return new Promise((resolve) => {
         const start = performance.now();
         const socket = net.connect({ host: target.host, port: target.port });
-        const timeout = setTimeout(() => {
+        const finish = (result) => {
+            clearTimeout(timer);
             socket.destroy();
-            resolve({
-                host: target.host,
-                ok: false,
-                timeMs: performance.now() - start,
-                error: 'Connection timed out',
-            });
-        }, 5000);
-        socket.on('connect', () => {
-            clearTimeout(timeout);
-            const timeMs = performance.now() - start;
-            socket.destroy();
-            resolve({ host: target.host, ok: true, timeMs });
-        });
-        socket.on('error', (err) => {
-            clearTimeout(timeout);
-            resolve({
-                host: target.host,
-                ok: false,
-                timeMs: performance.now() - start,
-                error: err.message,
-            });
-        });
+            resolve(result);
+        };
+        const timer = setTimeout(() => finish({ target: label, ok: false, timeMs: 0, error: 'Connection timed out' }), timeoutMs);
+        socket.once('connect', () => finish({ target: label, ok: true, timeMs: performance.now() - start }));
+        socket.once('error', (err) => finish({ target: label, ok: false, timeMs: 0, error: err.message }));
     });
 }
 //# sourceMappingURL=checks.js.map

package/dist/npcs/internet-connectivity/defaults.d.ts

@@ -8,7 +8,10 @@ export interface InternetConnectivityDefaults {
     dnsHosts: string[];
     httpUrls: string[];
     latencyHosts: LatencyHost[];
+    /** Port for a `--latency-hosts` entry given without one. */
+    latencyPort: number;
     slowThreshold: number;
+    /** Per-check timeout (DNS, HTTP and TCP) in ms. */
     httpTimeout: number;
     thresholds: {
         dnsTime: ThresholdConfig;

package/dist/npcs/internet-connectivity/defaults.js

@@ -4,10 +4,13 @@ export const DEFAULTS = {
     // gstatic generate_204 is a stable, low-latency 204 endpoint used by many
     // OSes for connectivity checks (replaces the flaky httpbin.org default).
     httpUrls: ['https://1.1.1.1/cdn-cgi/trace', 'https://www.gstatic.com/generate_204'],
+    // 443, not 80: Google's 8.8.8.8 doesn't listen on port 80, so that default
+    // timed out on every poll and pinned the NPC at warning.
     latencyHosts: [
-        { host: '8.8.8.8', port: 80 },
-        { host: '1.1.1.1', port: 80 },
+        { host: '8.8.8.8', port: 443 },
+        { host: '1.1.1.1', port: 443 },
     ],
+    latencyPort: 80,
     slowThreshold: 1000, // ms
     httpTimeout: 5000, // ms
     thresholds: {

package/dist/npcs/internet-connectivity/index.d.ts

@@ -10,17 +10,20 @@ export interface ConnectivityThresholds {
 export interface InternetConnectivityConfig extends PollingNpcConfig {
     dnsHosts?: string[];
     httpUrls?: string[];
+    /** `{host, port}` pairs, or "host" / "host:port" / "[v6]:port" strings. */
     latencyHosts?: LatencyHost[] | string[];
     slowThreshold?: number;
+    /** Per-check timeout in ms (DNS, HTTP and TCP). */
     httpTimeout?: number;
     thresholds?: ConnectivityThresholds;
 }
 interface ConnectivitySample {
     allFailed: boolean;
     anyFailed: boolean;
-    dnsAvg: number;
-    httpAvg: number;
-    latencyAvg: number;
+    /** Mean time of the successful checks of each kind; null when none succeeded. */
+    dnsAvg: number | null;
+    httpAvg: number | null;
+    latencyAvg: number | null;
 }
 /**
  * Derive overall status from live per-check thresholds. All checks failing is
@@ -28,6 +31,11 @@ interface ConnectivitySample {
  * escalate per their own thresholds.
  */
 export declare function evaluateConnectivityStatus(sample: ConnectivitySample, thresholds: ConnectivityThresholds): Status;
+/**
+ * Parse a latency target: "host", "host:port", "[ipv6]:port" or a bare IPv6
+ * address. Throws NpcConfigError on an out-of-range port.
+ */
+export declare function parseLatencyHost(input: string, defaultPort?: number): LatencyHost;
 export declare class InternetConnectivityNPC extends PollingNPC {
     private dnsHosts;
     private httpUrls;
@@ -44,10 +52,15 @@ export declare class InternetConnectivityNPC extends PollingNPC {
     get behavior(): BehaviorHints;
     get companion(): CompanionDecl;
     protected collect(): Promise<CollectedMetrics>;
-    private buildOnlineMessage;
-    private buildOfflineMessage;
     /**
-     * Build config from CLI flags. Merges with any programmatic overrides.
+     * 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.
+     */
+    private panel;
+    /**
+     * Build config from CLI flags. List flags are comma-separated; latency
+     * hosts accept "host", "host:port" or "[ipv6]:port".
      */
     static configFromFlags(flags: Record<string, string | boolean>): Partial<InternetConnectivityConfig>;
 }

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

@@ -1,7 +1,9 @@
 import { PollingNPC } from '../../core/polling-npc.js';
-import { evaluateThreshold, worstStatus } from '../../core/thresholds.js';
+import { evaluateThreshold, worstStatus, moodForStatus } from '../../core/thresholds.js';
 import { statusColor, pushHistory } from '../../core/screen.js';
-import { numberFlag, stringFlag } from '../../core/config.js';
+import { listFlag, numberFlag } from '../../core/config.js';
+import { NpcConfigError } from '../../core/errors.js';
+import { isHttpUrl } from '../../core/http.js';
 import { checkDns, checkHttp, checkLatency } from './checks.js';
 import { DEFAULTS } from './defaults.js';
 /**
@@ -12,13 +14,15 @@ import { DEFAULTS } from './defaults.js';
 export function evaluateConnectivityStatus(sample, thresholds) {
     if (sample.allFailed)
         return 'critical';
-    const timeStatus = worstStatus([
-        evaluateThreshold(sample.dnsAvg, thresholds.dnsTime),
-        evaluateThreshold(sample.httpAvg, thresholds.httpTime),
-        evaluateThreshold(sample.latencyAvg, thresholds.latencyTime),
-    ]);
-    const failStatus = sample.anyFailed ? 'warning' : 'healthy';
-    return worstStatus([timeStatus, failStatus]);
+    const statuses = [sample.anyFailed ? 'warning' : 'healthy'];
+    if (sample.dnsAvg !== null)
+        statuses.push(evaluateThreshold(sample.dnsAvg, thresholds.dnsTime));
+    if (sample.httpAvg !== null)
+        statuses.push(evaluateThreshold(sample.httpAvg, thresholds.httpTime));
+    if (sample.latencyAvg !== null) {
+        statuses.push(evaluateThreshold(sample.latencyAvg, thresholds.latencyTime));
+    }
+    return worstStatus(statuses);
 }
 /** Scale a threshold set by a ratio, preserving direction. */
 function scaleThresholds(base, ratio) {
@@ -33,6 +37,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.
+ */
+export function parseLatencyHost(input, defaultPort = DEFAULTS.latencyPort) {
+    const s = input.trim();
+    const toPort = (raw) => {
+        const port = Number(raw);
+        if (!Number.isInteger(port) || port < 1 || port > 65535) {
+            throw new 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
+}
 export class InternetConnectivityNPC extends PollingNPC {
     dnsHosts;
     httpUrls;
@@ -49,10 +77,16 @@ export class InternetConnectivityNPC extends PollingNPC {
         });
         this.dnsHosts = config.dnsHosts ?? DEFAULTS.dnsHosts;
         this.httpUrls = config.httpUrls ?? DEFAULTS.httpUrls;
-        this.latencyHosts = config.latencyHosts
-            ? parseLatencyHosts(config.latencyHosts)
-            : DEFAULTS.latencyHosts;
-        this.httpTimeout = config.httpTimeout ?? DEFAULTS.httpTimeout;
+        this.latencyHosts = (config.latencyHosts ?? 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.httpTimeout), this.pollInterval / 2);
+        const badUrl = this.httpUrls.find((u) => !isHttpUrl(u));
+        if (badUrl !== undefined) {
+            throw new NpcConfigError(`--http-urls: "${badUrl}" is not an http(s) URL`);
+        }
+        if (this.dnsHosts.length === 0 && this.httpUrls.length === 0) {
+            throw new 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.
@@ -88,115 +122,91 @@ export class InternetConnectivityNPC extends PollingNPC {
     }
     async collect() {
         const [dnsResults, httpResults, latencyResults] = await Promise.all([
-            checkDns(this.dnsHosts),
+            checkDns(this.dnsHosts, this.httpTimeout),
             checkHttp(this.httpUrls, this.httpTimeout),
-            checkLatency(this.latencyHosts),
+            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);
-        pushHistory(this.dnsHistory, round(dnsAvg));
-        pushHistory(this.httpHistory, round(httpAvg));
-        pushHistory(this.latencyHistory, round(latencyAvg));
-        const screenData = {
-            layout: 'multi-metric',
-            values: [
-                {
-                    label: 'DNS',
-                    value: `${round(dnsAvg)}ms`,
-                    color: statusColor(evaluateThreshold(dnsAvg, this.thresholds.dnsTime)),
-                    sparkline: [...this.dnsHistory],
-                },
-                {
-                    label: 'HTTP',
-                    value: `${round(httpAvg)}ms`,
-                    color: statusColor(evaluateThreshold(httpAvg, this.thresholds.httpTime)),
-                    sparkline: [...this.httpHistory],
-                },
-                {
-                    label: 'TCP',
-                    value: `${round(latencyAvg)}ms`,
-                    color: statusColor(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: 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' };
+        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' : statusColor(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 = stringFlag(flags, 'dns-hosts');
-        if (dnsHostsRaw) {
-            config.dnsHosts = dnsHostsRaw.split(',').map((s) => s.trim());
-        }
-        const httpUrlsRaw = stringFlag(flags, 'http-urls');
-        if (httpUrlsRaw) {
-            config.httpUrls = httpUrlsRaw.split(',').map((s) => s.trim());
-        }
-        const latencyHostsRaw = 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 = listFlag(flags, 'dns-hosts');
+        if (dnsHosts)
+            config.dnsHosts = dnsHosts;
+        const httpUrls = listFlag(flags, 'http-urls');
+        if (httpUrls)
+            config.httpUrls = httpUrls;
+        const latencyHosts = listFlag(flags, 'latency-hosts');
+        if (latencyHosts)
+            config.latencyHosts = latencyHosts.map((h) => parseLatencyHost(h));
         const slowThreshold = numberFlag(flags, 'slow-threshold');
         if (slowThreshold !== undefined)
             config.slowThreshold = slowThreshold;
+        const timeout = numberFlag(flags, 'timeout');
+        if (timeout !== undefined)
+            config.httpTimeout = timeout;
         const pollInterval = numberFlag(flags, 'poll-interval');
         if (pollInterval !== undefined)
             config.pollInterval = pollInterval;
@@ -204,43 +214,35 @@ export class InternetConnectivityNPC extends PollingNPC {
     }
 }
 // ---------- 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/npcs/log-watcher/buffer.d.ts

@@ -6,6 +6,13 @@ export interface RecentLine {
 }
 /** Classify a raw log line against the error/warning patterns. */
 export declare function classifyLine(line: string, errorRe: RegExp, warningRe: RegExp): LogLineLevel;
+/**
+ * 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.
+ */
+export declare function cleanLogLine(line: string, max?: number): string;
 /**
  * Push a line into the bounded ring buffer: each entry is capped at `cap`
  * characters and the buffer keeps only the last `max` entries.
@@ -15,4 +22,19 @@ export declare function pushRecent(buffer: RecentLine[], line: string, level: Lo
 export declare function buildLogScreen(buffer: RecentLine[]): ScreenData;
 /** True when enough time has elapsed since the last burst push to emit again. */
 export declare function shouldEmitBurst(lastEmit: number, now: number, windowMs?: number): boolean;
+/**
+ * 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.
+ */
+export declare class WindowCounter {
+    private readonly windowMs;
+    private buckets;
+    constructor(windowMs: number);
+    add(level: 'error' | 'warning', now?: number): void;
+    counts(now?: number): {
+        errors: number;
+        warnings: number;
+    };
+    private prune;
+}
 //# sourceMappingURL=buffer.d.ts.map