@nocville/npc 0.2.2 → 0.2.3

package/dist/cjs/npcs/system-monitor/index.js

@@ -4,6 +4,7 @@ exports.SystemMonitorNPC = void 0;
 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 errors_js_1 = require("../../core/errors.js");
 const collectors_js_1 = require("./collectors.js");
 const defaults_js_1 = require("./defaults.js");
 class SystemMonitorNPC extends polling_npc_js_1.PollingNPC {
@@ -14,15 +15,21 @@ class SystemMonitorNPC extends polling_npc_js_1.PollingNPC {
     cpuSampler = (0, collectors_js_1.createCpuSampler)();
     cpuHistory = [];
     memHistory = [];
+    diskErrorLogged = false;
     constructor(config) {
         super({
             ...config,
             pollInterval: config.pollInterval ?? defaults_js_1.DEFAULTS.pollInterval,
         });
         this.diskPath = config.diskPath ?? defaults_js_1.DEFAULTS.diskPath;
-        this.cpuThreshold = config.cpuThreshold ?? defaults_js_1.DEFAULT_THRESHOLDS['cpu'];
-        this.memThreshold = config.memThreshold ?? defaults_js_1.DEFAULT_THRESHOLDS['mem'];
-        this.diskThreshold = config.diskThreshold ?? defaults_js_1.DEFAULT_THRESHOLDS['disk'];
+        this.cpuThreshold = config.cpuThreshold ?? defaults_js_1.DEFAULT_THRESHOLDS.cpu;
+        this.memThreshold = config.memThreshold ?? defaults_js_1.DEFAULT_THRESHOLDS.mem;
+        this.diskThreshold = config.diskThreshold ?? defaults_js_1.DEFAULT_THRESHOLDS.disk;
+        const problem = (0, thresholds_js_1.thresholdProblem)('CPU', this.cpuThreshold) ??
+            (0, thresholds_js_1.thresholdProblem)('Memory', this.memThreshold) ??
+            (0, thresholds_js_1.thresholdProblem)('Disk', this.diskThreshold);
+        if (problem)
+            throw new errors_js_1.NpcConfigError(problem);
     }
     get name() {
         return 'system-monitor';
@@ -33,9 +40,6 @@ class SystemMonitorNPC extends polling_npc_js_1.PollingNPC {
     get archetype() {
         return 'service';
     }
-    get heartbeatSeconds() {
-        return 30;
-    }
     get behavior() {
         return { idle: 'wander' };
     }
@@ -49,19 +53,20 @@ class SystemMonitorNPC extends polling_npc_js_1.PollingNPC {
     }
     async collect() {
         const cpu = this.cpuSampler.sample();
-        const mem = (0, collectors_js_1.collectMemory)();
-        const disk = await (0, collectors_js_1.collectDisk)(this.diskPath);
+        const mem = (0, collectors_js_1.collectMemory)(await (0, collectors_js_1.readAvailableMemory)());
+        const disk = await this.readDisk();
         const cpuStatus = (0, thresholds_js_1.evaluateThreshold)(cpu.percent, this.cpuThreshold);
         const memStatus = (0, thresholds_js_1.evaluateThreshold)(mem.percent, this.memThreshold);
-        const diskStatus = (0, thresholds_js_1.evaluateThreshold)(disk.percent, this.diskThreshold);
+        // An unreadable disk (unmounted volume, bad --disk-path) is a warning, not a crash.
+        const diskStatus = disk
+            ? (0, thresholds_js_1.evaluateThreshold)(disk.percent, this.diskThreshold)
+            : 'warning';
         const status = (0, thresholds_js_1.worstStatus)([cpuStatus, memStatus, diskStatus]);
-        const mood = status === 'critical'
-            ? 'stressed'
-            : status === 'warning'
-                ? 'concerned'
-                : 'happy';
         (0, screen_js_1.pushHistory)(this.cpuHistory, cpu.percent);
         (0, screen_js_1.pushHistory)(this.memHistory, mem.percent);
+        const diskText = disk ? `${disk.percent}%` : 'n/a';
+        // Windows has no load average (os.loadavg() is always zeros there).
+        const loadText = process.platform === 'win32' ? 'n/a' : cpu.loadAvg1m.toFixed(2);
         const screenData = {
             layout: 'multi-metric',
             values: [
@@ -77,29 +82,48 @@ class SystemMonitorNPC extends polling_npc_js_1.PollingNPC {
                     color: (0, screen_js_1.statusColor)(memStatus),
                     sparkline: [...this.memHistory],
                 },
-                { label: 'DISK', value: `${disk.percent}%`, color: (0, screen_js_1.statusColor)(diskStatus) },
-                { label: 'LOAD', value: cpu.loadAvg1m.toFixed(2), color: 'gray' },
+                { label: 'DISK', value: diskText, color: (0, screen_js_1.statusColor)(diskStatus) },
+                { label: 'LOAD', value: loadText, color: 'gray' },
             ],
         };
+        const metrics = {
+            cpu_percent: cpu.percent,
+            mem_percent: mem.percent,
+            mem_used_gb: mem.usedGb,
+            mem_total_gb: mem.totalGb,
+            load_avg_1m: cpu.loadAvg1m,
+        };
+        if (disk) {
+            metrics['disk_percent'] = disk.percent;
+            metrics['disk_used_gb'] = disk.usedGb;
+            metrics['disk_total_gb'] = disk.totalGb;
+        }
         return {
             status,
-            mood,
-            message: `CPU: ${cpu.percent}% | Mem: ${mem.percent}% | Disk: ${disk.percent}%`,
+            mood: (0, thresholds_js_1.moodForStatus)(status),
+            message: `CPU: ${cpu.percent}% | Mem: ${mem.percent}% | Disk: ${disk ? diskText : 'unavailable'}`,
             screenData,
             // When strained, go find a desk and get to work; otherwise wander.
             behavior: status !== 'healthy' ? { busy: 'seek-desk' } : undefined,
-            metrics: {
-                cpu_percent: cpu.percent,
-                mem_percent: mem.percent,
-                mem_used_gb: mem.usedGb,
-                mem_total_gb: mem.totalGb,
-                disk_percent: disk.percent,
-                disk_used_gb: disk.usedGb,
-                disk_total_gb: disk.totalGb,
-                load_avg_1m: cpu.loadAvg1m,
-            },
+            metrics,
         };
     }
+    async readDisk() {
+        try {
+            const disk = await (0, collectors_js_1.collectDisk)(this.diskPath);
+            this.diskErrorLogged = false;
+            return disk;
+        }
+        catch (err) {
+            if (!this.diskErrorLogged) {
+                this.diskErrorLogged = true;
+                this.logger.warn(`Cannot read disk usage for ${this.diskPath}`, {
+                    error: err instanceof Error ? err.message : String(err),
+                });
+            }
+            return null;
+        }
+    }
 }
 exports.SystemMonitorNPC = SystemMonitorNPC;
 //# sourceMappingURL=index.js.map

package/dist/cjs/npcs/web-page-watcher/basic-mode.js

@@ -4,10 +4,31 @@ exports.extractTitle = extractTitle;
 exports.statusFromHttp = statusFromHttp;
 exports.basicCheck = basicCheck;
 exports.hostnameOf = hostnameOf;
-/** Extract the <title> text from an HTML string (empty if none). */
+const http_js_1 = require("../../core/http.js");
+const text_js_1 = require("../../core/text.js");
+/** Bytes of HTML read to find the <title> (it lives in <head>). */
+const MAX_HTML_BYTES = 512 * 1024;
+const ENTITIES = {
+    amp: '&',
+    lt: '<',
+    gt: '>',
+    quot: '"',
+    apos: "'",
+    nbsp: ' ',
+};
+function decodeEntities(s) {
+    return s.replace(/&(#x[0-9a-f]+|#\d+|[a-z]+);/gi, (m, e) => {
+        if (e[0] === '#') {
+            const code = e[1] === 'x' || e[1] === 'X' ? parseInt(e.slice(2), 16) : parseInt(e.slice(1), 10);
+            return Number.isFinite(code) && code > 0 && code <= 0x10ffff ? String.fromCodePoint(code) : m;
+        }
+        return ENTITIES[e.toLowerCase()] ?? m;
+    });
+}
+/** Extract the <title> text from (untrusted) HTML: entities decoded, sanitized, ≤80 chars. */
 function extractTitle(html) {
     const m = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
-    return m ? m[1].replace(/\s+/g, ' ').trim().slice(0, 80) : '';
+    return m ? (0, text_js_1.sanitizeText)(decodeEntities(m[1]), 80) : '';
 }
 /** Map an HTTP status to NPC status: 2xx/3xx ok, 4xx/timeout warn, 5xx/refused crit. */
 function statusFromHttp(code, timedOut = false) {
@@ -21,17 +42,15 @@ function statusFromHttp(code, timedOut = false) {
 }
 /** Fetch a page and extract HTTP status + <title> (basic, no browser). */
 async function basicCheck(url, timeoutMs = 8000) {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
     try {
         const res = await fetch(url, {
-            signal: controller.signal,
-            headers: { 'User-Agent': 'nocville-npc' },
+            signal: AbortSignal.timeout(timeoutMs),
+            headers: { 'User-Agent': http_js_1.NPC_USER_AGENT },
             redirect: 'follow',
         });
         let title = '';
         try {
-            title = extractTitle(await res.text());
+            title = extractTitle((await (0, http_js_1.readTextCapped)(res, MAX_HTML_BYTES)).text);
         }
         catch {
             // body unavailable; leave title blank
@@ -39,20 +58,17 @@ async function basicCheck(url, timeoutMs = 8000) {
         return { status: res.status, title, ok: res.ok, timedOut: false };
     }
     catch (err) {
-        const timedOut = err instanceof Error && err.name === 'AbortError';
+        const timedOut = err instanceof Error && (err.name === 'TimeoutError' || err.name === 'AbortError');
         return { status: 0, title: '', ok: false, timedOut };
     }
-    finally {
-        clearTimeout(timer);
-    }
 }
-/** Best-effort hostname for a URL, falling back to the raw string. */
+/** Hostname of a URL for labels and service ids (never credentials or path). */
 function hostnameOf(url) {
     try {
-        return new URL(url).hostname;
+        return new URL(url).hostname || 'page';
     }
     catch {
-        return url.slice(0, 40);
+        return 'invalid-url';
     }
 }
 //# sourceMappingURL=basic-mode.js.map

package/dist/cjs/npcs/web-page-watcher/capture.js

@@ -1,6 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.findChrome = findChrome;
+exports.chromeArgs = chromeArgs;
+exports.runningAsRoot = runningAsRoot;
 exports.loadPuppeteer = loadPuppeteer;
 exports.browserConnected = browserConnected;
 const node_fs_1 = require("node:fs");
@@ -21,7 +23,11 @@ const LINUX_BINARIES = [
 ];
 function which(bin) {
     try {
-        const out = (0, node_child_process_1.execFileSync)('which', [bin], { encoding: 'utf-8' }).trim();
+        const out = (0, node_child_process_1.execFileSync)('which', [bin], {
+            encoding: 'utf-8',
+            timeout: 2000,
+            stdio: ['ignore', 'pipe', 'ignore'],
+        }).trim();
         return out || null;
     }
     catch {
@@ -54,6 +60,22 @@ function findChrome(explicit) {
     }
     return null;
 }
+/**
+ * Chrome launch flags. The watched page is untrusted content, so Chrome's
+ * sandbox stays on unless it can't work: as root on Linux (Chrome refuses to
+ * start sandboxed, typical in containers) or when explicitly disabled.
+ */
+function chromeArgs(opts) {
+    const args = ['--disable-gpu', '--hide-scrollbars', '--mute-audio', '--no-first-run'];
+    const sandboxed = opts.sandbox && !opts.isRoot;
+    if (!sandboxed)
+        args.push('--no-sandbox', '--disable-setuid-sandbox');
+    return { args, sandboxed };
+}
+/** True when this process runs as root (POSIX only). */
+function runningAsRoot() {
+    return typeof process.getuid === 'function' && process.getuid() === 0;
+}
 /**
  * Load the optional `puppeteer-core` peer dependency without a static import,
  * so the package builds and runs when it isn't installed. Returns null if the

package/dist/cjs/npcs/web-page-watcher/defaults.js

@@ -1,11 +1,17 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.DEFAULTS = void 0;
+exports.WAIT_UNTIL = exports.WATCH_MODES = exports.LIMITS = exports.DEFAULTS = void 0;
 exports.parseDimensions = parseDimensions;
+exports.screenSizeProblem = screenSizeProblem;
+exports.viewportProblem = viewportProblem;
 exports.DEFAULTS = {
     pollInterval: 60000, // 60s
     minPollInterval: 15000, // floor
     navTimeoutMs: 15000,
+    /** Extra time for screenshot + encode before a capture counts as hung. */
+    captureGraceMs: 15000,
+    /** Wait before relaunching Chrome after it failed to start. */
+    relaunchBackoffMs: 10 * 60 * 1000,
     maxColors: 32,
     /** Polls to keep the 'changed' sub-status active after a page change. */
     changedPolls: 2,
@@ -18,6 +24,21 @@ exports.DEFAULTS = {
     scaleDivisor: 8,
     waitUntil: 'networkidle2',
 };
+/**
+ * Size limits. The pixel payload is base64(W×H) and the API caps a screen value
+ * at 220 KB, so W×H must stay under ~165k; 320×240 leaves headroom. The
+ * viewport bound keeps Chrome's raster (and the PNG decode) to sane memory.
+ */
+exports.LIMITS = {
+    screenMin: 16,
+    screenMaxSide: 320,
+    screenMaxPixels: 320 * 240,
+    viewportMin: 64,
+    viewportMax: 4096,
+};
+exports.WATCH_MODES = ['auto', 'screenshot', 'basic'];
+/** puppeteer `waitUntil` values. */
+exports.WAIT_UNTIL = ['load', 'domcontentloaded', 'networkidle0', 'networkidle2'];
 /** Parse a "WxH" string into a {width, height} pair, or null if malformed. */
 function parseDimensions(s) {
     const m = s
@@ -26,6 +47,27 @@ function parseDimensions(s) {
         .match(/^(\d+)x(\d+)$/);
     if (!m)
         return null;
-    return { width: parseInt(m[1], 10), height: parseInt(m[2], 10) };
+    const width = parseInt(m[1], 10);
+    const height = parseInt(m[2], 10);
+    return width > 0 && height > 0 ? { width, height } : null;
+}
+/** Why a TV resolution is unusable, or null when it is fine. */
+function screenSizeProblem(w, h) {
+    const { screenMin, screenMaxSide, screenMaxPixels } = exports.LIMITS;
+    if (!Number.isInteger(w) || !Number.isInteger(h) || w < screenMin || h < screenMin) {
+        return `--screen must be at least ${screenMin}x${screenMin}`;
+    }
+    if (w > screenMaxSide || h > screenMaxSide || w * h > screenMaxPixels) {
+        return `--screen must fit within ${screenMaxSide}x${screenMaxSide} and ${screenMaxPixels} pixels (e.g. 320x240)`;
+    }
+    return null;
+}
+/** Why a browser viewport is unusable, or null when it is fine. */
+function viewportProblem(w, h) {
+    const { viewportMin, viewportMax } = exports.LIMITS;
+    const ok = (n) => Number.isInteger(n) && n >= viewportMin && n <= viewportMax;
+    return ok(w) && ok(h)
+        ? null
+        : `--viewport sides must be between ${viewportMin} and ${viewportMax} pixels`;
 }
 //# sourceMappingURL=defaults.js.map

package/dist/cjs/npcs/web-page-watcher/index.js

@@ -2,14 +2,23 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.WebPageWatcherNPC = void 0;
 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 errors_js_1 = require("../../core/errors.js");
+const http_js_1 = require("../../core/http.js");
 const defaults_js_1 = require("./defaults.js");
 const pixelate_js_1 = require("./pixelate.js");
 const capture_js_1 = require("./capture.js");
 const basic_mode_js_1 = require("./basic-mode.js");
+/** Thrown when a capture exceeds its deadline (the browser is then recycled). */
+class CaptureTimeout extends Error {
+}
 class WebPageWatcherNPC extends polling_npc_js_1.PollingNPC {
     url;
+    host;
     mode;
     chromePath;
+    chromeSandbox;
     viewportW;
     viewportH;
     screenW;
@@ -17,7 +26,10 @@ class WebPageWatcherNPC extends polling_npc_js_1.PollingNPC {
     waitUntil;
     puppeteer = null;
     browser = null;
-    browserUnavailable = false;
+    /** puppeteer-core or Chrome is missing: never retried. */
+    browserMissing = false;
+    /** Chrome failed to launch: retry after this time (epoch ms). */
+    nextLaunchAttempt = 0;
     chromeHintShown = false;
     lastHash = 0;
     changedPollsLeft = 0;
@@ -27,22 +39,41 @@ class WebPageWatcherNPC extends polling_npc_js_1.PollingNPC {
             // Floor the poll interval — screenshots are expensive.
             pollInterval: Math.max(config.pollInterval ?? defaults_js_1.DEFAULTS.pollInterval, defaults_js_1.DEFAULTS.minPollInterval),
         });
+        // The page is rendered and shown to the whole office: http(s) only, never
+        // file:, data:, chrome: or javascript: URLs.
+        if (!(0, http_js_1.isHttpUrl)(config.url)) {
+            throw new errors_js_1.NpcConfigError('--url must be an http(s) URL');
+        }
         this.url = config.url;
-        this.mode = config.mode ?? 'auto';
+        this.host = (0, basic_mode_js_1.hostnameOf)(config.url);
+        const mode = config.mode ?? 'auto';
+        if (!defaults_js_1.WATCH_MODES.includes(mode)) {
+            throw new errors_js_1.NpcConfigError(`--mode must be one of ${defaults_js_1.WATCH_MODES.join(', ')}`);
+        }
+        this.mode = mode;
+        const waitUntil = config.waitUntil ?? defaults_js_1.DEFAULTS.waitUntil;
+        if (!defaults_js_1.WAIT_UNTIL.includes(waitUntil)) {
+            throw new errors_js_1.NpcConfigError(`--wait-until must be one of ${defaults_js_1.WAIT_UNTIL.join(', ')}`);
+        }
+        this.waitUntil = waitUntil;
         this.chromePath = config.chromePath;
+        this.chromeSandbox = config.chromeSandbox ?? true;
         this.screenW = config.screenWidth ?? defaults_js_1.DEFAULTS.screenW;
         this.screenH = config.screenHeight ?? defaults_js_1.DEFAULTS.screenH;
         // Derive the viewport from the screen size for native downscaling unless the
         // user overrides it (in which case pngToPixelImage box-filters to screen).
         this.viewportW = config.viewportWidth ?? this.screenW * defaults_js_1.DEFAULTS.scaleDivisor;
         this.viewportH = config.viewportHeight ?? this.screenH * defaults_js_1.DEFAULTS.scaleDivisor;
-        this.waitUntil = config.waitUntil ?? defaults_js_1.DEFAULTS.waitUntil;
+        const sizeProblem = (0, defaults_js_1.screenSizeProblem)(this.screenW, this.screenH) ??
+            (0, defaults_js_1.viewportProblem)(this.viewportW, this.viewportH);
+        if (sizeProblem)
+            throw new errors_js_1.NpcConfigError(sizeProblem);
     }
     get name() {
         return 'web-page-watcher';
     }
     get defaultDisplayName() {
-        return (0, basic_mode_js_1.hostnameOf)(this.url);
+        return this.host;
     }
     get archetype() {
         return 'custom';
@@ -52,43 +83,58 @@ class WebPageWatcherNPC extends polling_npc_js_1.PollingNPC {
             screenType: 'web-view',
             size: { w: 4, h: 3 },
             placement: 'adjacent-wall',
-            label: (0, basic_mode_js_1.hostnameOf)(this.url),
+            label: this.host,
         };
     }
     async collect() {
         if (this.mode === 'basic')
-            return this.collectBasic();
+            return this.collectBasic(false);
         const browser = await this.ensureBrowser();
         if (!browser) {
-            // 'auto' silently degrades; explicit 'screenshot' warns once.
             this.maybeShowChromeHint();
-            return this.collectBasic();
+            return this.collectBasic(true);
+        }
+        try {
+            return await this.withDeadline(this.collectScreenshot(browser));
+        }
+        catch (err) {
+            if (this.state !== 'running')
+                throw err; // shutting down: nothing to report
+            // A crashed or wedged browser: recycle it and report this cycle from a plain fetch.
+            this.logger.warn('Screenshot failed; using a basic check this cycle', {
+                error: err instanceof Error ? err.message : String(err),
+            });
+            await this.closeBrowser();
+            return this.collectBasic(true);
         }
-        return this.collectScreenshot(browser);
     }
     async onStop() {
+        // Close Chrome first: it aborts an in-flight capture, so the base class
+        // doesn't wait out a slow page load before pushing offline.
+        await this.closeBrowser();
         await super.onStop();
-        if (this.browser) {
-            try {
-                await this.browser.close();
-            }
-            catch {
-                // best effort
-            }
-            this.browser = null;
-        }
     }
     // --- Screenshot mode ---
+    withDeadline(work) {
+        const ms = defaults_js_1.DEFAULTS.navTimeoutMs + defaults_js_1.DEFAULTS.captureGraceMs;
+        let timer;
+        const deadline = new Promise((_, reject) => {
+            timer = setTimeout(() => reject(new CaptureTimeout(`capture exceeded ${ms}ms`)), ms);
+        });
+        return Promise.race([work, deadline]).finally(() => clearTimeout(timer));
+    }
     async collectScreenshot(browser) {
         const page = await browser.newPage();
         try {
-            // deviceScaleFactor 0.125 makes Chrome rasterize the viewport down to the
-            // screen size natively (e.g. 1280×800 → 160×100); pngToPixelImage
+            // A page that alert()s would block navigation and the screenshot.
+            page.on?.('dialog', (dialog) => void dialog.dismiss().catch(() => undefined));
+            // deviceScaleFactor 1/8 makes Chrome rasterize the viewport down to the
+            // screen size natively (e.g. 1280×960 → 160×120); pngToPixelImage
             // box-filters as a fallback if it doesn't.
             await page.setViewport({
                 width: this.viewportW,
                 height: this.viewportH,
-                deviceScaleFactor: 0.125,
+                deviceScaleFactor: 1 / defaults_js_1.DEFAULTS.scaleDivisor,
             });
             let httpStatus = 0;
             let timedOut = false;
@@ -116,15 +162,14 @@ class WebPageWatcherNPC extends polling_npc_js_1.PollingNPC {
             else if (this.changedPollsLeft > 0)
                 this.changedPollsLeft--;
             const status = (0, basic_mode_js_1.statusFromHttp)(httpStatus, timedOut);
-            const host = (0, basic_mode_js_1.hostnameOf)(this.url);
             const message = changed
                 ? 'Page updated!'
                 : httpStatus
-                    ? `${host} ${httpStatus < 400 ? 'OK' : 'ERR'} (${httpStatus}, ${loadMs}ms)`
-                    : `${host} unreachable`;
+                    ? `${this.host} ${httpStatus < 400 ? 'OK' : 'ERR'} (${httpStatus}, ${loadMs}ms)`
+                    : `${this.host} ${timedOut ? 'timed out' : 'unreachable'}`;
             return {
                 status,
-                mood: moodFor(status),
+                mood: (0, thresholds_js_1.moodForStatus)(status),
                 message,
                 subStatus: this.changedPollsLeft > 0 ? 'changed' : undefined,
                 screenData,
@@ -141,74 +186,92 @@ class WebPageWatcherNPC extends polling_npc_js_1.PollingNPC {
         }
     }
     async ensureBrowser() {
-        if (this.browserUnavailable)
+        if (this.browserMissing || Date.now() < this.nextLaunchAttempt)
             return null;
         if (this.browser && (0, capture_js_1.browserConnected)(this.browser))
             return this.browser;
-        if (this.browser)
-            this.browser = null; // disconnected — relaunch
-        if (!this.puppeteer) {
-            this.puppeteer = await (0, capture_js_1.loadPuppeteer)();
-        }
+        this.browser = null; // absent or disconnected — (re)launch
+        this.puppeteer ??= await (0, capture_js_1.loadPuppeteer)();
         const chromePath = (0, capture_js_1.findChrome)(this.chromePath);
         if (!this.puppeteer || !chromePath) {
-            this.browserUnavailable = true;
+            this.browserMissing = true;
             return null;
         }
+        const { args, sandboxed } = (0, capture_js_1.chromeArgs)({
+            sandbox: this.chromeSandbox,
+            isRoot: (0, capture_js_1.runningAsRoot)(),
+        });
+        if (!sandboxed) {
+            this.logger.warn('Chrome sandbox disabled' +
+                (this.chromeSandbox ? ' (running as root)' : '') +
+                ': only watch pages you trust');
+        }
         try {
-            this.browser = await this.puppeteer.launch({
+            const browser = await this.puppeteer.launch({
                 executablePath: chromePath,
                 headless: true,
-                args: ['--no-sandbox', '--disable-setuid-sandbox', '--disable-gpu', '--hide-scrollbars'],
+                args,
             });
-            this.browser.on('disconnected', () => {
-                this.browser = null;
+            browser.on('disconnected', () => {
+                if (this.browser === browser)
+                    this.browser = null;
             });
-            return this.browser;
+            // Stopped while Chrome was starting: don't leave it running.
+            if (this.state !== 'running') {
+                await browser.close().catch(() => undefined);
+                return null;
+            }
+            this.browser = browser;
+            return browser;
         }
         catch (err) {
-            this.logger.warn('Failed to launch Chrome', {
+            this.logger.warn('Failed to launch Chrome; retrying in 10 minutes', {
                 error: err instanceof Error ? err.message : String(err),
             });
-            this.browserUnavailable = true;
+            this.nextLaunchAttempt = Date.now() + defaults_js_1.DEFAULTS.relaunchBackoffMs;
             return null;
         }
     }
+    async closeBrowser() {
+        const browser = this.browser;
+        this.browser = null;
+        if (browser)
+            await browser.close().catch(() => undefined);
+    }
     maybeShowChromeHint() {
-        if (this.chromeHintShown)
+        if (this.chromeHintShown || !this.browserMissing)
             return;
         this.chromeHintShown = true;
         this.logger.warn('Chrome/puppeteer-core unavailable — falling back to basic mode. ' +
             'Install `puppeteer-core` and Google Chrome (or set --chrome-path/CHROME_PATH) for the pixel-art TV.');
     }
     // --- Basic mode ---
-    async collectBasic() {
+    /**
+     * Plain fetch: HTTP status + page title on a ticker. When this is a fallback
+     * from screenshot mode (no Chrome), a healthy page is reported as a warning
+     * to nudge the Chrome setup; an explicit `--mode=basic` reports it healthy.
+     */
+    async collectBasic(fallback) {
         const loadStart = Date.now();
-        const check = await (0, basic_mode_js_1.basicCheck)(this.url);
+        const check = await (0, basic_mode_js_1.basicCheck)(this.url, defaults_js_1.DEFAULTS.navTimeoutMs);
         const loadMs = Date.now() - loadStart;
-        // Basic mode can't render the pixel TV, so it never reports fully healthy —
-        // a healthy HTTP result is downgraded to a warning to nudge Chrome setup.
-        let status = (0, basic_mode_js_1.statusFromHttp)(check.status, check.timedOut);
-        if (status === 'healthy')
-            status = 'warning';
-        const host = (0, basic_mode_js_1.hostnameOf)(this.url);
-        const message = check.title ? `${host}: ${check.title}` : `${host} (${check.status || 'ERR'})`;
+        const httpStatus = (0, basic_mode_js_1.statusFromHttp)(check.status, check.timedOut);
+        const status = fallback && httpStatus === 'healthy' ? 'warning' : httpStatus;
+        const message = check.title
+            ? `${this.host}: ${check.title}`
+            : `${this.host} (${check.status || (check.timedOut ? 'timed out' : 'ERR')})`;
         return {
             status,
-            mood: moodFor(status),
+            mood: (0, thresholds_js_1.moodForStatus)(status),
             message,
             screenData: {
                 layout: 'ticker',
                 values: [
-                    { label: 'URL', value: host },
+                    { label: 'URL', value: this.host },
                     {
                         label: 'HTTP',
                         value: check.status ? String(check.status) : 'ERR',
-                        color: check.status >= 200 && check.status < 400
-                            ? 'green'
-                            : check.status >= 500 || check.status === 0
-                                ? 'red'
-                                : 'amber',
+                        color: (0, screen_js_1.statusColor)(httpStatus),
                     },
                     { label: 'Title', value: check.title || '(no title)' },
                     { label: 'Mode', value: 'basic' },
@@ -219,16 +282,4 @@ class WebPageWatcherNPC extends polling_npc_js_1.PollingNPC {
     }
 }
 exports.WebPageWatcherNPC = WebPageWatcherNPC;
-function moodFor(status) {
-    switch (status) {
-        case 'healthy':
-            return 'happy';
-        case 'warning':
-            return 'concerned';
-        case 'critical':
-            return 'stressed';
-        default:
-            return 'idle';
-    }
-}
 //# sourceMappingURL=index.js.map

package/dist/cjs/npcs/web-page-watcher/pixelate.js

@@ -176,6 +176,7 @@ function pngToPixelImage(pngBuffer, maxColors = 32, targetW = exports.TARGET_W,
     const { palette, indices } = quantize(rgba, w * h, maxColors);
     const screenData = buildPixelImageScreen(w, h, palette, indices);
     const byteSize = screenData.values.reduce((sum, v) => sum + v.value.length, 0);
-    return { screenData, byteSize, hash: fnv1a(indices) };
+    // Hash the palette too: a recolour with the same layout is still a change.
+    return { screenData, byteSize, hash: fnv1a(Buffer.concat([palette, indices])) };
 }
 //# sourceMappingURL=pixelate.js.map