@nocville/npc 0.2.1 → 0.2.3

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

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

@@ -1,3 +1,5 @@
+import { sanitizeText } from '../../core/text.js';
+import { redactSecrets } from '../agent-common/activity.js';
 /** Classify a raw log line against the error/warning patterns. */
 export function classifyLine(line, errorRe, warningRe) {
     if (errorRe.test(line))
@@ -6,6 +8,23 @@ export 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.
+ */
+export function cleanLogLine(line, max = 200) {
+    const plain = line.replace(ANSI, '');
+    const redacted = redactSecrets(plain).replace(SECRET_PAIR, (_m, key, sep) => `${key}${sep}***`);
+    return 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.
@@ -31,4 +50,43 @@ export function buildLogScreen(buffer) {
 export 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.
+ */
+export 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);
+        }
+    }
+}
 //# sourceMappingURL=buffer.js.map

package/dist/npcs/log-watcher/index.d.ts

@@ -1,45 +1,46 @@
-import { BaseNPC } from '../../core/base-npc.js';
-import type { NpcConfig, Archetype, BehaviorHints, CompanionDecl } from '../../core/types.js';
-export interface LogWatcherConfig extends NpcConfig {
+import { PollingNPC } from '../../core/polling-npc.js';
+import type { PollingNpcConfig } from '../../core/polling-npc.js';
+import type { CollectedMetrics, Archetype, BehaviorHints, CompanionDecl } from '../../core/types.js';
+export interface LogWatcherConfig extends PollingNpcConfig {
     files: string[];
     errorPattern?: string;
     warningPattern?: string;
     windowSeconds?: number;
     errorWarn?: number;
     errorCrit?: number;
+    /** Report interval in ms (alias of pollInterval, kept for compatibility). */
     reportInterval?: number;
 }
-export declare class LogWatcherNPC extends BaseNPC {
+/**
+ * Tails log files and reports error bursts. A periodic report (every
+ * `reportInterval`) carries the error count over the sliding window and the
+ * last lines for the log terminal; a fresh error line also triggers an
+ * immediate report, debounced to one per 5s, so a burst shows up at once.
+ * Every report is one composed push, never a push per line.
+ */
+export declare class LogWatcherNPC extends PollingNPC {
     private tailers;
-    private timer;
-    private entries;
+    private counter;
     private recentLines;
-    private lastBurstPush;
+    private lastError;
+    /** The error line that triggered an immediate report, consumed by the next collect(). */
+    private burstLine;
+    private lastBurstAt;
     private errorRegex;
     private warningRegex;
     private windowMs;
-    private errorWarn;
-    private errorCrit;
-    private reportInterval;
+    private errorThreshold;
     private files;
     constructor(config: LogWatcherConfig);
     get name(): string;
     protected get defaultDisplayName(): string;
     get archetype(): Archetype;
-    get heartbeatSeconds(): number;
     get behavior(): BehaviorHints;
     get companion(): CompanionDecl;
     protected onStart(): Promise<void>;
     protected onStop(): Promise<void>;
-    private handleLine;
-    /** A fresh error triggers an immediate push, debounced to at most once / 5s. */
-    private onErrorBurst;
-    private pruneWindow;
-    private report;
-    /**
-     * Build and push the current status. If `overrideMessage` is set (burst push),
-     * it drives the bubble and the status floors at warning.
-     */
-    private pushReport;
+    /** Visible for tests: feed one raw line as if a tailer had read it. */
+    protected handleLine(line: string, now?: number): void;
+    protected collect(): Promise<CollectedMetrics>;
 }
 //# sourceMappingURL=index.d.ts.map