@nocville/npc 0.0.0-stage → 0.2.1

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

@@ -0,0 +1,22 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULTS = void 0;
+exports.DEFAULTS = {
+    pollInterval: 30000, // 30 seconds
+    dnsHosts: ['google.com', 'cloudflare.com'],
+    // 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'],
+    latencyHosts: [
+        { host: '8.8.8.8', port: 80 },
+        { host: '1.1.1.1', port: 80 },
+    ],
+    slowThreshold: 1000, // ms
+    httpTimeout: 5000, // ms
+    thresholds: {
+        dnsTime: { warning: 500, critical: 2000, direction: 'above' },
+        httpTime: { warning: 1000, critical: 3000, direction: 'above' },
+        latencyTime: { warning: 300, critical: 1000, direction: 'above' },
+    },
+};
+//# sourceMappingURL=defaults.js.map

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

@@ -0,0 +1,251 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.InternetConnectivityNPC = void 0;
+exports.evaluateConnectivityStatus = evaluateConnectivityStatus;
+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 checks_js_1 = require("./checks.js");
+const defaults_js_1 = require("./defaults.js");
+/**
+ * Derive overall status from live per-check thresholds. All checks failing is
+ * critical; any partial failure is at least a warning; slow-but-working checks
+ * escalate per their own thresholds.
+ */
+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]);
+}
+/** Scale a threshold set by a ratio, preserving direction. */
+function scaleThresholds(base, ratio) {
+    const scale = (t) => ({
+        warning: Math.round(t.warning * ratio),
+        critical: Math.round(t.critical * ratio),
+        direction: t.direction,
+    });
+    return {
+        dnsTime: scale(base.dnsTime),
+        httpTime: scale(base.httpTime),
+        latencyTime: scale(base.latencyTime),
+    };
+}
+class InternetConnectivityNPC extends polling_npc_js_1.PollingNPC {
+    dnsHosts;
+    httpUrls;
+    latencyHosts;
+    httpTimeout;
+    thresholds;
+    dnsHistory = [];
+    httpHistory = [];
+    latencyHistory = [];
+    constructor(config) {
+        super({
+            ...config,
+            pollInterval: config.pollInterval ?? defaults_js_1.DEFAULTS.pollInterval,
+        });
+        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;
+        // 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.
+        if (config.thresholds) {
+            this.thresholds = config.thresholds;
+        }
+        else if (config.slowThreshold && config.slowThreshold !== defaults_js_1.DEFAULTS.slowThreshold) {
+            this.thresholds = scaleThresholds(defaults_js_1.DEFAULTS.thresholds, config.slowThreshold / defaults_js_1.DEFAULTS.slowThreshold);
+        }
+        else {
+            this.thresholds = defaults_js_1.DEFAULTS.thresholds;
+        }
+    }
+    get name() {
+        return 'internet-connectivity';
+    }
+    get defaultDisplayName() {
+        return 'Internet';
+    }
+    get archetype() {
+        return 'gateway';
+    }
+    get behavior() {
+        return { idle: 'wander' };
+    }
+    get companion() {
+        return {
+            screenType: 'dashboard-wall',
+            size: { w: 2, h: 2 },
+            placement: 'adjacent-wall',
+            label: 'Internet',
+        };
+    }
+    async collect() {
+        const [dnsResults, httpResults, latencyResults] = await Promise.all([
+            (0, checks_js_1.checkDns)(this.dnsHosts),
+            (0, checks_js_1.checkHttp)(this.httpUrls, this.httpTimeout),
+            (0, checks_js_1.checkLatency)(this.latencyHosts),
+        ]);
+        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 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' },
+            ],
+        };
+        return {
+            status,
+            mood,
+            message,
+            subStatus: isOnline ? undefined : 'offline',
+            screenData,
+            metrics: {
+                dns_avg_ms: round(dnsAvg),
+                http_avg_ms: round(httpAvg),
+                latency_avg_ms: round(latencyAvg),
+                dns_ok_count: dnsOk,
+                dns_fail_count: dnsFail,
+                http_ok_count: httpOk,
+                http_fail_count: httpFail,
+                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'}`;
+    }
+    /**
+     * Build config from CLI flags. Merges with any programmatic overrides.
+     */
+    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 slowThreshold = (0, config_js_1.numberFlag)(flags, 'slow-threshold');
+        if (slowThreshold !== undefined)
+            config.slowThreshold = slowThreshold;
+        const pollInterval = (0, config_js_1.numberFlag)(flags, 'poll-interval');
+        if (pollInterval !== undefined)
+            config.pollInterval = pollInterval;
+        return config;
+    }
+}
+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 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';
+    }
+}
+/**
+ * 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 };
+    });
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,40 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.classifyLine = classifyLine;
+exports.pushRecent = pushRecent;
+exports.buildLogScreen = buildLogScreen;
+exports.shouldEmitBurst = shouldEmitBurst;
+/** Classify a raw log line against the error/warning patterns. */
+function classifyLine(line, errorRe, warningRe) {
+    if (errorRe.test(line))
+        return 'error';
+    if (warningRe.test(line))
+        return 'warning';
+    return 'info';
+}
+/**
+ * Push a line into the bounded ring buffer: each entry is capped at `cap`
+ * characters and the buffer keeps only the last `max` entries.
+ */
+function pushRecent(buffer, line, level, max = 12, cap = 80) {
+    buffer.push({ text: line.slice(0, cap), level });
+    if (buffer.length > max)
+        buffer.splice(0, buffer.length - max);
+    return buffer;
+}
+/** Build a log-terminal screen payload from the ring buffer, colored per level. */
+function buildLogScreen(buffer) {
+    return {
+        layout: 'log-terminal',
+        values: buffer.map((l) => ({
+            label: '',
+            value: l.text,
+            color: l.level === 'error' ? 'red' : l.level === 'warning' ? 'amber' : 'green',
+        })),
+    };
+}
+/** True when enough time has elapsed since the last burst push to emit again. */
+function shouldEmitBurst(lastEmit, now, windowMs = 5000) {
+    return now - lastEmit >= windowMs;
+}
+//# sourceMappingURL=buffer.js.map

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

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULTS = void 0;
+exports.DEFAULTS = {
+    reportInterval: 15000, // 15 seconds
+    windowSeconds: 300, // 5 minutes
+    errorPattern: 'ERROR|FATAL',
+    warningPattern: 'WARN',
+    errorWarn: 5, // errors in window before warning status
+    errorCrit: 20, // errors in window before critical status
+};
+//# sourceMappingURL=defaults.js.map

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

@@ -0,0 +1,161 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LogWatcherNPC = void 0;
+const node_path_1 = require("node:path");
+const base_npc_js_1 = require("../../core/base-npc.js");
+const thresholds_js_1 = require("../../core/thresholds.js");
+const text_js_1 = require("../../core/text.js");
+const tail_js_1 = require("./tail.js");
+const buffer_js_1 = require("./buffer.js");
+const defaults_js_1 = require("./defaults.js");
+class LogWatcherNPC extends base_npc_js_1.BaseNPC {
+    tailers = [];
+    timer = null;
+    entries = [];
+    recentLines = [];
+    lastBurstPush = 0;
+    errorRegex;
+    warningRegex;
+    windowMs;
+    errorWarn;
+    errorCrit;
+    reportInterval;
+    files;
+    constructor(config) {
+        super(config);
+        this.files = config.files;
+        this.errorRegex = new RegExp(config.errorPattern ?? defaults_js_1.DEFAULTS.errorPattern);
+        this.warningRegex = new RegExp(config.warningPattern ?? defaults_js_1.DEFAULTS.warningPattern);
+        this.windowMs = (config.windowSeconds ?? defaults_js_1.DEFAULTS.windowSeconds) * 1000;
+        this.errorWarn = config.errorWarn ?? defaults_js_1.DEFAULTS.errorWarn;
+        this.errorCrit = config.errorCrit ?? defaults_js_1.DEFAULTS.errorCrit;
+        this.reportInterval = config.reportInterval ?? defaults_js_1.DEFAULTS.reportInterval;
+    }
+    get name() {
+        return 'log-watcher';
+    }
+    get defaultDisplayName() {
+        const first = this.files[0];
+        return first ? `Logs: ${(0, node_path_1.basename)(first)}` : 'Logs';
+    }
+    get archetype() {
+        return 'service';
+    }
+    get heartbeatSeconds() {
+        return 30;
+    }
+    get behavior() {
+        return { idle: 'wander' };
+    }
+    get companion() {
+        return {
+            screenType: 'log-terminal',
+            size: { w: 2, h: 2 },
+            placement: 'adjacent-wall',
+            label: this.files[0] ? (0, node_path_1.basename)(this.files[0]) : 'log',
+        };
+    }
+    async onStart() {
+        for (const filePath of this.files) {
+            this.logger.info(`Tailing ${filePath}`);
+            const tailer = (0, tail_js_1.createTailer)(filePath, (line) => {
+                this.handleLine(line);
+            });
+            this.tailers.push(tailer);
+        }
+        // Report immediately, then on interval
+        await this.report();
+        this.timer = setInterval(() => {
+            void this.report();
+        }, this.reportInterval);
+    }
+    async onStop() {
+        if (this.timer) {
+            clearInterval(this.timer);
+            this.timer = null;
+        }
+        for (const tailer of this.tailers) {
+            tailer.close();
+        }
+        this.tailers = [];
+    }
+    handleLine(line) {
+        const now = Date.now();
+        const level = (0, buffer_js_1.classifyLine)(line, this.errorRegex, this.warningRegex);
+        // Ring buffer holds ALL lines (matched ones flagged) for the log TV.
+        (0, buffer_js_1.pushRecent)(this.recentLines, line, level);
+        if (level === 'error') {
+            this.entries.push({ timestamp: now, type: 'error', message: line });
+            this.onErrorBurst(line);
+        }
+        else if (level === 'warning') {
+            this.entries.push({ timestamp: now, type: 'warning', message: line });
+        }
+    }
+    /** A fresh error triggers an immediate push, debounced to at most once / 5s. */
+    onErrorBurst(line) {
+        const now = Date.now();
+        if (!(0, buffer_js_1.shouldEmitBurst)(this.lastBurstPush, now))
+            return;
+        this.lastBurstPush = now;
+        void this.pushReport((0, text_js_1.truncate)(line, 200), 'error');
+    }
+    pruneWindow() {
+        const cutoff = Date.now() - this.windowMs;
+        this.entries = this.entries.filter((e) => e.timestamp >= cutoff);
+    }
+    async report() {
+        if (this.state !== 'running')
+            return;
+        await this.pushReport();
+    }
+    /**
+     * Build and push the current status. If `overrideMessage` is set (burst push),
+     * it drives the bubble and the status floors at warning.
+     */
+    async pushReport(overrideMessage, subStatus) {
+        if (this.state !== 'running')
+            return;
+        this.pruneWindow();
+        const errorCount = this.entries.filter((e) => e.type === 'error').length;
+        const warningCount = this.entries.filter((e) => e.type === 'warning').length;
+        const windowSeconds = this.windowMs / 1000;
+        let status = (0, thresholds_js_1.evaluateThreshold)(errorCount, {
+            warning: this.errorWarn,
+            critical: this.errorCrit,
+            direction: 'above',
+        });
+        if (overrideMessage)
+            status = (0, thresholds_js_1.worstStatus)([status, 'warning']);
+        const mood = status === 'critical' ? 'stressed' : status === 'warning' ? 'concerned' : 'happy';
+        const lastError = this.entries.filter((e) => e.type === 'error').at(-1);
+        const message = overrideMessage ??
+            (errorCount > 0
+                ? `${errorCount} error${errorCount !== 1 ? 's' : ''} in last ${windowSeconds / 60}min across ${this.files.length} file${this.files.length !== 1 ? 's' : ''}`
+                : `No errors in last ${windowSeconds / 60}min`);
+        const metrics = {
+            status,
+            mood,
+            message,
+            subStatus,
+            screenData: (0, buffer_js_1.buildLogScreen)(this.recentLines),
+            metrics: {
+                error_count: errorCount,
+                warning_count: warningCount,
+                window_seconds: windowSeconds,
+                files_watched: this.files.length,
+                last_error_message: lastError?.message ?? '',
+            },
+        };
+        try {
+            await this.pushMetrics(metrics);
+        }
+        catch (err) {
+            this.logger.error('Failed to push metrics', {
+                error: err instanceof Error ? err.message : String(err),
+            });
+        }
+    }
+}
+exports.LogWatcherNPC = LogWatcherNPC;
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createTailer = createTailer;
+const node_fs_1 = require("node:fs");
+const node_readline_1 = require("node:readline");
+/**
+ * Tail a file by watching for changes and reading new lines from the last
+ * known byte offset. Handles file rotation (size shrinks -> reset to 0).
+ */
+function createTailer(filePath, onLine) {
+    let offset = 0;
+    let reading = false;
+    let watcher = null;
+    let closed = false;
+    async function init() {
+        // Start at the end of the file so we only read new lines
+        try {
+            const stats = await node_fs_1.promises.stat(filePath);
+            offset = stats.size;
+        }
+        catch {
+            // File may not exist yet; start at 0
+            offset = 0;
+        }
+        watcher = (0, node_fs_1.watch)(filePath, () => {
+            if (!closed) {
+                void readNewLines();
+            }
+        });
+        // Ignore watcher errors (e.g. file deleted then recreated)
+        watcher.on('error', () => { });
+    }
+    async function readNewLines() {
+        if (reading || closed)
+            return;
+        reading = true;
+        try {
+            const stats = await node_fs_1.promises.stat(filePath);
+            // File rotation detected: size smaller than our offset
+            if (stats.size < offset) {
+                offset = 0;
+            }
+            // Nothing new to read
+            if (stats.size === offset) {
+                reading = false;
+                return;
+            }
+            const stream = (0, node_fs_1.createReadStream)(filePath, {
+                start: offset,
+                encoding: 'utf-8',
+            });
+            const rl = (0, node_readline_1.createInterface)({ input: stream, crlfDelay: Infinity });
+            let bytesRead = 0;
+            for await (const line of rl) {
+                if (closed)
+                    break;
+                // Account for line content + newline character
+                bytesRead += Buffer.byteLength(line, 'utf-8') + 1;
+                onLine(line);
+            }
+            offset += bytesRead;
+        }
+        catch {
+            // File may have been removed; ignore and wait for next change
+        }
+        finally {
+            reading = false;
+        }
+    }
+    void init();
+    return {
+        close() {
+            closed = true;
+            if (watcher) {
+                watcher.close();
+                watcher = null;
+            }
+        },
+    };
+}
+//# sourceMappingURL=tail.js.map

package/dist/cjs/npcs/process-watcher/defaults.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULTS = void 0;
+exports.DEFAULTS = {
+    pollInterval: 15000, // 15 seconds
+    cpuWarn: 80, // percent
+    memWarn: 500, // MB
+};
+//# sourceMappingURL=defaults.js.map