@nocville/npc 0.0.0-stage → 0.2.0

package/dist/npcs/github-watcher/index.js

@@ -0,0 +1,144 @@
+import { PollingNPC } from '../../core/polling-npc.js';
+import { truncate } from '../../core/text.js';
+import { DEFAULTS } from './defaults.js';
+import { fetchCommits, fetchDefaultBranch, newCommitsSince, commitsWithin } from './github-api.js';
+import { relativeTime } from './format.js';
+export class GitHubWatcherNPC extends PollingNPC {
+    repo;
+    token;
+    branch;
+    fetchFn;
+    etag = null;
+    lastSeenSha = null;
+    commits = [];
+    rateRemaining = null;
+    newCommitPollsLeft = 0;
+    constructor(config) {
+        super({ ...config, pollInterval: config.pollInterval ?? DEFAULTS.pollInterval });
+        this.repo = config.repo;
+        this.token = config.token;
+        this.branch = config.branch;
+        this.fetchFn = config.fetchFn;
+    }
+    get name() {
+        return 'github-watcher';
+    }
+    get defaultDisplayName() {
+        const repoName = this.repo.split('/').pop() || this.repo;
+        return `GitHub: ${repoName}`;
+    }
+    get archetype() {
+        return 'pipeline';
+    }
+    get companion() {
+        return {
+            screenType: 'commit-board',
+            size: { w: 3, h: 2 },
+            placement: 'adjacent-wall',
+            label: this.repo,
+        };
+    }
+    async onStart() {
+        // Resolve the default branch once if the user didn't pin one.
+        if (!this.branch) {
+            const def = await fetchDefaultBranch(this.repo, {
+                token: this.token,
+                timeoutMs: DEFAULTS.fetchTimeoutMs,
+                fetchFn: this.fetchFn,
+            });
+            if (def) {
+                this.branch = def;
+                this.logger.info(`Watching default branch "${def}"`);
+            }
+        }
+        await super.onStart();
+    }
+    async collect() {
+        const result = await fetchCommits(this.repo, {
+            token: this.token,
+            etag: this.etag,
+            branch: this.branch,
+            timeoutMs: DEFAULTS.fetchTimeoutMs,
+            perPage: DEFAULTS.perPage,
+            fetchFn: this.fetchFn,
+        });
+        if (result.rateRemaining !== null)
+            this.rateRemaining = result.rateRemaining;
+        if (result.status === 403) {
+            return this.report('warning', 'concerned', 'GitHub API rate-limited (403)', 'rate-limited');
+        }
+        if (result.status === 404) {
+            return this.report('warning', 'concerned', `Repo not found: ${this.repo}`, 'not-found');
+        }
+        if (result.status === 0 && this.commits.length === 0) {
+            return this.report('warning', 'concerned', 'GitHub API unreachable', 'unreachable');
+        }
+        if (result.notModified) {
+            return this.reportIdle();
+        }
+        if (result.commits.length > 0) {
+            const fresh = newCommitsSince(result.commits, this.lastSeenSha);
+            this.commits = result.commits;
+            this.etag = result.etag ?? this.etag;
+            if (this.lastSeenSha === null) {
+                this.lastSeenSha = result.commits[0].sha;
+                return this.reportIdle();
+            }
+            if (fresh.length > 0) {
+                this.lastSeenSha = result.commits[0].sha;
+                this.newCommitPollsLeft = DEFAULTS.newCommitPolls;
+                return this.reportNewCommits(fresh);
+            }
+        }
+        return this.reportIdle();
+    }
+    reportNewCommits(fresh) {
+        const newest = fresh[0];
+        const latest = `${newest.author}: ${truncate(newest.message, 120)} (${newest.sha.slice(0, 7)})`;
+        const message = fresh.length > 1 ? `${fresh.length} new commits — latest: ${latest}` : latest;
+        return this.report('healthy', 'happy', message, 'new-commit');
+    }
+    reportIdle() {
+        if (this.newCommitPollsLeft > 0)
+            this.newCommitPollsLeft--;
+        const subStatus = this.newCommitPollsLeft > 0 ? 'new-commit' : undefined;
+        const newest = this.commits[0];
+        const message = newest
+            ? `Last: ${truncate(newest.message, 80)} (${relativeTime(newest.date)})`
+            : `Watching ${this.repo}`;
+        return this.report('healthy', 'happy', message, subStatus);
+    }
+    report(status, mood, message, subStatus) {
+        const newest = this.commits[0];
+        const secondsSinceLast = newest && newest.date
+            ? Math.max(0, Math.round((Date.now() - Date.parse(newest.date)) / 1000))
+            : 0;
+        return {
+            status,
+            mood,
+            message,
+            subStatus,
+            screenData: this.buildBoard(),
+            metrics: {
+                seconds_since_last_commit: secondsSinceLast,
+                commits_last_24h: commitsWithin(this.commits, 24),
+                api_rate_remaining: this.rateRemaining ?? -1,
+            },
+        };
+    }
+    buildBoard() {
+        const now = Date.now();
+        const header = this.branch ? `${this.repo}@${this.branch}` : this.repo;
+        const values = [{ label: 'repo', value: header }];
+        for (const c of this.commits.slice(0, 8)) {
+            const recent = c.date && now - Date.parse(c.date) < 3600_000;
+            values.push({
+                label: c.sha.slice(0, 7),
+                value: truncate(`${c.author}: ${c.message}`, 60),
+                color: recent ? 'green' : 'gray',
+            });
+        }
+        return { layout: 'commit-board', values };
+    }
+}
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,24 @@
+import type { LatencyHost } from './defaults.js';
+export interface DnsCheckResult {
+    host: string;
+    ok: boolean;
+    timeMs: number;
+    error?: string;
+}
+export declare function checkDns(hosts: string[]): Promise<DnsCheckResult[]>;
+export interface HttpCheckResult {
+    url: string;
+    ok: boolean;
+    timeMs: number;
+    statusCode?: number;
+    error?: string;
+}
+export declare function checkHttp(urls: string[], timeout: number): Promise<HttpCheckResult[]>;
+export interface LatencyCheckResult {
+    host: string;
+    ok: boolean;
+    timeMs: number;
+    error?: string;
+}
+export declare function checkLatency(hosts: LatencyHost[]): Promise<LatencyCheckResult[]>;
+//# sourceMappingURL=checks.d.ts.map

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

@@ -0,0 +1,84 @@
+import { promises as dns } from 'node:dns';
+import net from 'node:net';
+export async function checkDns(hosts) {
+    return Promise.all(hosts.map(resolveSingleDns));
+}
+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();
+    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),
+        };
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+export async function checkLatency(hosts) {
+    return Promise.all(hosts.map(measureTcpConnect));
+}
+function measureTcpConnect(target) {
+    return new Promise((resolve) => {
+        const start = performance.now();
+        const socket = net.connect({ host: target.host, port: target.port });
+        const timeout = setTimeout(() => {
+            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,
+            });
+        });
+    });
+}
+//# sourceMappingURL=checks.js.map

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

@@ -0,0 +1,20 @@
+import type { ThresholdConfig } from '../../core/types.js';
+export interface LatencyHost {
+    host: string;
+    port: number;
+}
+export interface InternetConnectivityDefaults {
+    pollInterval: number;
+    dnsHosts: string[];
+    httpUrls: string[];
+    latencyHosts: LatencyHost[];
+    slowThreshold: number;
+    httpTimeout: number;
+    thresholds: {
+        dnsTime: ThresholdConfig;
+        httpTime: ThresholdConfig;
+        latencyTime: ThresholdConfig;
+    };
+}
+export declare const DEFAULTS: InternetConnectivityDefaults;
+//# sourceMappingURL=defaults.d.ts.map

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

@@ -0,0 +1,19 @@
+export const 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/npcs/internet-connectivity/index.d.ts

@@ -0,0 +1,55 @@
+import { PollingNPC } from '../../core/polling-npc.js';
+import type { PollingNpcConfig } from '../../core/polling-npc.js';
+import type { CollectedMetrics, Status, ThresholdConfig, Archetype, BehaviorHints, CompanionDecl } from '../../core/types.js';
+import type { LatencyHost } from './defaults.js';
+export interface ConnectivityThresholds {
+    dnsTime: ThresholdConfig;
+    httpTime: ThresholdConfig;
+    latencyTime: ThresholdConfig;
+}
+export interface InternetConnectivityConfig extends PollingNpcConfig {
+    dnsHosts?: string[];
+    httpUrls?: string[];
+    latencyHosts?: LatencyHost[] | string[];
+    slowThreshold?: number;
+    httpTimeout?: number;
+    thresholds?: ConnectivityThresholds;
+}
+interface ConnectivitySample {
+    allFailed: boolean;
+    anyFailed: boolean;
+    dnsAvg: number;
+    httpAvg: number;
+    latencyAvg: number;
+}
+/**
+ * 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.
+ */
+export declare function evaluateConnectivityStatus(sample: ConnectivitySample, thresholds: ConnectivityThresholds): Status;
+export declare class InternetConnectivityNPC extends PollingNPC {
+    private dnsHosts;
+    private httpUrls;
+    private latencyHosts;
+    private httpTimeout;
+    private thresholds;
+    private dnsHistory;
+    private httpHistory;
+    private latencyHistory;
+    constructor(config: InternetConnectivityConfig);
+    get name(): string;
+    protected get defaultDisplayName(): string;
+    get archetype(): Archetype;
+    get behavior(): BehaviorHints;
+    get companion(): CompanionDecl;
+    protected collect(): Promise<CollectedMetrics>;
+    private buildOnlineMessage;
+    private buildOfflineMessage;
+    /**
+     * Build config from CLI flags. Merges with any programmatic overrides.
+     */
+    static configFromFlags(flags: Record<string, string | boolean>): Partial<InternetConnectivityConfig>;
+}
+export {};
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1,246 @@
+import { PollingNPC } from '../../core/polling-npc.js';
+import { evaluateThreshold, worstStatus } from '../../core/thresholds.js';
+import { statusColor, pushHistory } from '../../core/screen.js';
+import { numberFlag, stringFlag } from '../../core/config.js';
+import { checkDns, checkHttp, checkLatency } from './checks.js';
+import { DEFAULTS } from './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.
+ */
+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]);
+}
+/** 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),
+    };
+}
+export class InternetConnectivityNPC extends PollingNPC {
+    dnsHosts;
+    httpUrls;
+    latencyHosts;
+    httpTimeout;
+    thresholds;
+    dnsHistory = [];
+    httpHistory = [];
+    latencyHistory = [];
+    constructor(config) {
+        super({
+            ...config,
+            pollInterval: config.pollInterval ?? DEFAULTS.pollInterval,
+        });
+        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;
+        // 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.slowThreshold) {
+            this.thresholds = scaleThresholds(DEFAULTS.thresholds, config.slowThreshold / DEFAULTS.slowThreshold);
+        }
+        else {
+            this.thresholds = 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([
+            checkDns(this.dnsHosts),
+            checkHttp(this.httpUrls, this.httpTimeout),
+            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);
+        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' },
+            ],
+        };
+        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 = 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 slowThreshold = numberFlag(flags, 'slow-threshold');
+        if (slowThreshold !== undefined)
+            config.slowThreshold = slowThreshold;
+        const pollInterval = numberFlag(flags, 'poll-interval');
+        if (pollInterval !== undefined)
+            config.pollInterval = pollInterval;
+        return config;
+    }
+}
+// ---------- 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/npcs/log-watcher/buffer.d.ts

@@ -0,0 +1,18 @@
+import type { ScreenData } from '../../core/types.js';
+export type LogLineLevel = 'error' | 'warning' | 'info';
+export interface RecentLine {
+    text: string;
+    level: LogLineLevel;
+}
+/** Classify a raw log line against the error/warning patterns. */
+export declare function classifyLine(line: string, errorRe: RegExp, warningRe: RegExp): LogLineLevel;
+/**
+ * Push a line into the bounded ring buffer: each entry is capped at `cap`
+ * characters and the buffer keeps only the last `max` entries.
+ */
+export declare function pushRecent(buffer: RecentLine[], line: string, level: LogLineLevel, max?: number, cap?: number): RecentLine[];
+/** Build a log-terminal screen payload from the ring buffer, colored per level. */
+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;
+//# sourceMappingURL=buffer.d.ts.map

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

@@ -0,0 +1,34 @@
+/** Classify a raw log line against the error/warning patterns. */
+export 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.
+ */
+export 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. */
+export 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. */
+export function shouldEmitBurst(lastEmit, now, windowMs = 5000) {
+    return now - lastEmit >= windowMs;
+}
+//# sourceMappingURL=buffer.js.map

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

@@ -0,0 +1,9 @@
+export declare const DEFAULTS: {
+    reportInterval: number;
+    windowSeconds: number;
+    errorPattern: string;
+    warningPattern: string;
+    errorWarn: number;
+    errorCrit: number;
+};
+//# sourceMappingURL=defaults.d.ts.map

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

@@ -0,0 +1,9 @@
+export const 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