@nocville/npc 0.2.2 → 0.3.0

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

@@ -1,49 +1,87 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.LogWatcherNPC = void 0;
+const node_fs_1 = require("node:fs");
 const node_path_1 = require("node:path");
-const base_npc_js_1 = require("../../core/base-npc.js");
+const polling_npc_js_1 = require("../../core/polling-npc.js");
 const thresholds_js_1 = require("../../core/thresholds.js");
-const text_js_1 = require("../../core/text.js");
+const errors_js_1 = require("../../core/errors.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 {
+/** Lines shown on the log terminal, and their width. */
+const SCREEN_LINES = 12;
+const SCREEN_LINE_CHARS = 80;
+function compilePattern(flag, source) {
+    try {
+        return new RegExp(source);
+    }
+    catch (err) {
+        throw new errors_js_1.NpcConfigError(`${flag}: invalid regular expression (${err instanceof Error ? err.message : String(err)})`);
+    }
+}
+/** "45s", "5min", "1.5h" */
+function formatWindow(seconds) {
+    if (seconds < 60)
+        return `${seconds}s`;
+    if (seconds < 3600)
+        return `${Math.round((seconds / 60) * 10) / 10}min`;
+    return `${Math.round((seconds / 3600) * 10) / 10}h`;
+}
+/**
+ * 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.
+ */
+class LogWatcherNPC extends polling_npc_js_1.PollingNPC {
     tailers = [];
-    timer = null;
-    entries = [];
+    counter;
     recentLines = [];
-    lastBurstPush = 0;
+    lastError = null;
+    /** The error line that triggered an immediate report, consumed by the next collect(). */
+    burstLine = null;
+    lastBurstAt = 0;
     errorRegex;
     warningRegex;
     windowMs;
-    errorWarn;
-    errorCrit;
-    reportInterval;
+    errorThreshold;
     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;
+        super({
+            ...config,
+            pollInterval: config.reportInterval ?? config.pollInterval ?? defaults_js_1.DEFAULTS.reportInterval,
+        });
+        this.files = [...new Set(config.files.map((f) => f.trim()).filter(Boolean))].map((f) => (0, node_path_1.resolve)(f));
+        if (this.files.length === 0) {
+            throw new errors_js_1.NpcConfigError('log-watcher needs at least one file (--files)');
+        }
+        this.errorRegex = compilePattern('--error-pattern', config.errorPattern ?? defaults_js_1.DEFAULTS.errorPattern);
+        this.warningRegex = compilePattern('--warning-pattern', config.warningPattern ?? defaults_js_1.DEFAULTS.warningPattern);
+        const windowSeconds = config.windowSeconds ?? defaults_js_1.DEFAULTS.windowSeconds;
+        if (!(windowSeconds > 0))
+            throw new errors_js_1.NpcConfigError('--window must be a positive number of seconds');
+        this.windowMs = windowSeconds * 1000;
+        this.counter = new buffer_js_1.WindowCounter(this.windowMs);
+        this.errorThreshold = {
+            warning: config.errorWarn ?? defaults_js_1.DEFAULTS.errorWarn,
+            critical: config.errorCrit ?? defaults_js_1.DEFAULTS.errorCrit,
+            direction: 'above',
+        };
+        const problem = (0, thresholds_js_1.thresholdProblem)('--error-warn/--error-crit', this.errorThreshold);
+        if (problem)
+            throw new errors_js_1.NpcConfigError(problem);
     }
     get name() {
         return 'log-watcher';
     }
     get defaultDisplayName() {
-        const first = this.files[0];
-        return first ? `Logs: ${(0, node_path_1.basename)(first)}` : 'Logs';
+        return `Logs: ${(0, node_path_1.basename)(this.files[0])}`;
     }
     get archetype() {
         return 'service';
     }
-    get heartbeatSeconds() {
-        return 30;
-    }
     get behavior() {
         return { idle: 'wander' };
     }
@@ -52,109 +90,77 @@ class LogWatcherNPC extends base_npc_js_1.BaseNPC {
             screenType: 'log-terminal',
             size: { w: 2, h: 2 },
             placement: 'adjacent-wall',
-            label: this.files[0] ? (0, node_path_1.basename)(this.files[0]) : 'log',
+            label: (0, node_path_1.basename)(this.files[0]),
         };
     }
     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);
+            if ((0, node_fs_1.existsSync)(filePath)) {
+                this.logger.info(`Tailing ${filePath}`);
+            }
+            else {
+                this.logger.warn(`${filePath} does not exist yet; will tail it once it appears`);
+            }
+            this.tailers.push((0, tail_js_1.createTailer)(filePath, (line) => this.handleLine(line), {
+                onError: (err) => this.logger.warn(`Cannot read ${filePath}`, { error: err.message }),
+            }));
         }
-        // Report immediately, then on interval
-        await this.report();
-        this.timer = setInterval(() => {
-            void this.report();
-        }, this.reportInterval);
+        await super.onStart();
     }
     async onStop() {
-        if (this.timer) {
-            clearInterval(this.timer);
-            this.timer = null;
-        }
-        for (const tailer of this.tailers) {
+        for (const tailer of this.tailers)
             tailer.close();
-        }
         this.tailers = [];
+        await super.onStop();
     }
-    handleLine(line) {
-        const now = Date.now();
+    /** Visible for tests: feed one raw line as if a tailer had read it. */
+    handleLine(line, 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))
+        // The ring buffer holds ALL lines (matched ones flagged) for the log TV.
+        (0, buffer_js_1.pushRecent)(this.recentLines, (0, buffer_js_1.cleanLogLine)(line, SCREEN_LINE_CHARS), level, SCREEN_LINES);
+        if (level === 'info')
             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')
+        this.counter.add(level, now);
+        if (level !== 'error')
             return;
-        await this.pushReport();
+        const text = (0, buffer_js_1.cleanLogLine)(line);
+        this.lastError = { text, at: now };
+        if ((0, buffer_js_1.shouldEmitBurst)(this.lastBurstAt, now)) {
+            this.lastBurstAt = now;
+            this.burstLine = text;
+            this.collectNow();
+        }
     }
-    /**
-     * 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)
+    async collect() {
+        const now = Date.now();
+        const { errors, warnings } = this.counter.counts(now);
+        const window = formatWindow(this.windowMs / 1000);
+        const burst = this.burstLine;
+        this.burstLine = null;
+        let status = (0, thresholds_js_1.evaluateThreshold)(errors, this.errorThreshold);
+        // A burst report drives the bubble with the error itself and floors at warning.
+        if (burst)
             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 = {
+        const fileCount = `${this.files.length} file${this.files.length !== 1 ? 's' : ''}`;
+        const message = burst ??
+            (errors > 0
+                ? `${errors} error${errors !== 1 ? 's' : ''} in last ${window} across ${fileCount}`
+                : `No errors in last ${window}`);
+        const lastErrorInWindow = this.lastError && now - this.lastError.at <= this.windowMs ? this.lastError.text : '';
+        return {
             status,
-            mood,
+            mood: (0, thresholds_js_1.moodForStatus)(status),
             message,
-            subStatus,
+            subStatus: burst ? 'error' : undefined,
             screenData: (0, buffer_js_1.buildLogScreen)(this.recentLines),
             metrics: {
-                error_count: errorCount,
-                warning_count: warningCount,
-                window_seconds: windowSeconds,
+                error_count: errors,
+                warning_count: warnings,
+                window_seconds: this.windowMs / 1000,
                 files_watched: this.files.length,
-                last_error_message: lastError?.message ?? '',
+                last_error_message: lastErrorInWindow,
             },
         };
-        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;

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

@@ -2,79 +2,126 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createTailer = createTailer;
 const node_fs_1 = require("node:fs");
-const node_readline_1 = require("node:readline");
+const node_string_decoder_1 = require("node:string_decoder");
+const DEFAULTS = {
+    pollMs: 1000,
+    maxLineChars: 16 * 1024,
+    maxReadBytes: 1024 * 1024,
+    maxBacklogBytes: 8 * 1024 * 1024,
+};
+function isNotFound(err) {
+    return err?.code === 'ENOENT';
+}
 /**
- * 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).
+ * Follow a growing file like `tail -F`: emit each complete new line, starting
+ * from the end of the file as it is now (or from the start of a file created
+ * later).
+ *
+ * Polls with `stat` instead of `fs.watch`: watchers follow the inode, so they
+ * go deaf after logrotate's rename-and-recreate, and they throw for files that
+ * don't exist yet. Rotation (new inode) and truncation (size shrinks) restart
+ * from offset 0. Reads are bounded per poll, a partial last line is held until
+ * its newline arrives, over-long lines are cut, and a backlog beyond
+ * `maxBacklogBytes` (a runaway logger) is skipped so the watcher stays current.
  */
-function createTailer(filePath, onLine) {
+function createTailer(filePath, onLine, options = {}) {
+    const opts = { ...DEFAULTS, ...options };
     let offset = 0;
-    let reading = false;
-    let watcher = null;
+    let inode = null;
+    let partial = '';
+    let decoder = new node_string_decoder_1.StringDecoder('utf8');
+    let busy = false;
     let closed = false;
-    async function init() {
-        // Start at the end of the file so we only read new lines
+    /** False until the first successful stat (or ENOENT) fixes the starting offset. */
+    let started = false;
+    let lastError = '';
+    const reset = () => {
+        offset = 0;
+        partial = '';
+        decoder = new node_string_decoder_1.StringDecoder('utf8');
+    };
+    const reportError = (err) => {
+        const error = err instanceof Error ? err : new Error(String(err));
+        if (error.message === lastError)
+            return;
+        lastError = error.message;
+        opts.onError?.(error);
+    };
+    const emitText = (text) => {
+        const pieces = (partial + text).split('\n');
+        partial = pieces.pop().slice(0, opts.maxLineChars);
+        for (const piece of pieces) {
+            if (closed)
+                return;
+            onLine(piece.replace(/\r$/, '').slice(0, opts.maxLineChars));
+        }
+    };
+    async function readNew(size) {
+        if (size - offset > opts.maxBacklogBytes) {
+            // Too far behind: jump to the newest data rather than lag forever.
+            offset = size - opts.maxReadBytes;
+            partial = '';
+            decoder = new node_string_decoder_1.StringDecoder('utf8');
+        }
+        const length = Math.min(size - offset, opts.maxReadBytes);
+        const handle = await node_fs_1.promises.open(filePath, 'r');
         try {
-            const stats = await node_fs_1.promises.stat(filePath);
-            offset = stats.size;
+            const buf = Buffer.alloc(length);
+            const { bytesRead } = await handle.read(buf, 0, length, offset);
+            offset += bytesRead;
+            emitText(decoder.write(buf.subarray(0, bytesRead)));
         }
-        catch {
-            // File may not exist yet; start at 0
-            offset = 0;
+        finally {
+            await handle.close();
         }
-        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)
+    async function poll() {
+        if (busy || closed)
             return;
-        reading = true;
+        busy = 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;
+            const st = await node_fs_1.promises.stat(filePath);
+            if (!started) {
+                // Start at the current end of the file so only new lines are reported.
+                started = true;
+                inode = st.ino;
+                offset = st.size;
+                lastError = '';
                 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;
+            if (inode !== null && st.ino !== inode)
+                reset(); // rotated: a new file took the name
+            inode = st.ino;
+            if (st.size < offset)
+                reset(); // truncated in place
+            if (st.size > offset)
+                await readNew(st.size);
+            lastError = '';
         }
-        catch {
-            // File may have been removed; ignore and wait for next change
+        catch (err) {
+            if (isNotFound(err)) {
+                started = true;
+                // Rotated away and not yet recreated (or never created): start the
+                // replacement from its first byte.
+                if (inode !== null)
+                    reportError(new Error(`${filePath} disappeared; waiting for it`));
+                inode = null;
+                reset();
+            }
+            else {
+                reportError(err);
+            }
         }
         finally {
-            reading = false;
+            busy = false;
         }
     }
-    void init();
+    const timer = setInterval(() => void poll(), opts.pollMs);
+    void poll();
     return {
         close() {
             closed = true;
-            if (watcher) {
-                watcher.close();
-                watcher = null;
-            }
+            clearInterval(timer);
         },
     };
 }

package/dist/cjs/npcs/office-characters/index.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OFFICE_CHARACTER_NPCS = exports.OutOfTouchExecutiveNPC = exports.ITTechnicianNPC = exports.PlantCaretakerNPC = exports.OfficeDogNPC = exports.OfficeCatNPC = exports.BaristaNPC = exports.JanitorNPC = void 0;
+const polling_npc_js_1 = require("../../core/polling-npc.js");
+/** Quiet heartbeats; the authoritative server drives routines and conversation. */
+class OfficeCharacterNPC extends polling_npc_js_1.PollingNPC {
+    constructor(config) {
+        super({ ...config, pollInterval: config.pollInterval ?? 60_000 });
+    }
+    get archetype() {
+        return 'custom';
+    }
+    get behavior() {
+        return { role: this.name, activity: 'idle', idlePose: 'stand' };
+    }
+    async collect() {
+        return { status: 'healthy', mood: 'happy', message: '', metrics: {} };
+    }
+}
+class JanitorNPC extends OfficeCharacterNPC {
+    get name() {
+        return 'janitor';
+    }
+    get defaultDisplayName() {
+        return 'Janitor';
+    }
+}
+exports.JanitorNPC = JanitorNPC;
+class BaristaNPC extends OfficeCharacterNPC {
+    get name() {
+        return 'barista';
+    }
+    get defaultDisplayName() {
+        return 'Barista';
+    }
+}
+exports.BaristaNPC = BaristaNPC;
+class OfficeCatNPC extends OfficeCharacterNPC {
+    get name() {
+        return 'office-cat';
+    }
+    get defaultDisplayName() {
+        return 'Office Cat';
+    }
+}
+exports.OfficeCatNPC = OfficeCatNPC;
+class OfficeDogNPC extends OfficeCharacterNPC {
+    get name() {
+        return 'office-dog';
+    }
+    get defaultDisplayName() {
+        return 'Office Dog';
+    }
+}
+exports.OfficeDogNPC = OfficeDogNPC;
+class PlantCaretakerNPC extends OfficeCharacterNPC {
+    get name() {
+        return 'plant-caretaker';
+    }
+    get defaultDisplayName() {
+        return 'Plant Caretaker';
+    }
+}
+exports.PlantCaretakerNPC = PlantCaretakerNPC;
+class ITTechnicianNPC extends OfficeCharacterNPC {
+    get name() {
+        return 'it-technician';
+    }
+    get defaultDisplayName() {
+        return 'IT Technician';
+    }
+}
+exports.ITTechnicianNPC = ITTechnicianNPC;
+class OutOfTouchExecutiveNPC extends OfficeCharacterNPC {
+    get name() {
+        return 'out-of-touch-executive';
+    }
+    get defaultDisplayName() {
+        return 'Out-of-Touch Executive';
+    }
+}
+exports.OutOfTouchExecutiveNPC = OutOfTouchExecutiveNPC;
+exports.OFFICE_CHARACTER_NPCS = {
+    janitor: JanitorNPC,
+    barista: BaristaNPC,
+    'office-cat': OfficeCatNPC,
+    'office-dog': OfficeDogNPC,
+    'plant-caretaker': PlantCaretakerNPC,
+    'it-technician': ITTechnicianNPC,
+    'out-of-touch-executive': OutOfTouchExecutiveNPC,
+};
+//# sourceMappingURL=index.js.map