@nocville/npc 0.0.0-stage → 0.2.0

package/dist/cjs/npcs/receptionist/weather.js

@@ -0,0 +1,129 @@
+"use strict";
+/**
+ * Keyless weather + geolocation via open-meteo, with ipapi.co IP fallback.
+ * All network helpers return null on failure so the receptionist can degrade
+ * to a time-only mode without erroring.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.describeWmo = describeWmo;
+exports.geocodeLocation = geocodeLocation;
+exports.autoGeo = autoGeo;
+exports.fetchWeather = fetchWeather;
+exports.toFahrenheit = toFahrenheit;
+exports.formatClock = formatClock;
+// WMO weather-interpretation codes → human text + a glyph keyword the
+// welcome-sign renderer understands (matched by /sun|clear|partly|rain|snow|storm|fog/).
+const WMO = {
+    0: { text: 'Clear', icon: 'clear' },
+    1: { text: 'Mainly clear', icon: 'partly' },
+    2: { text: 'Partly cloudy', icon: 'partly' },
+    3: { text: 'Overcast', icon: 'cloud' },
+    45: { text: 'Fog', icon: 'fog' },
+    48: { text: 'Rime fog', icon: 'fog' },
+    51: { text: 'Light drizzle', icon: 'drizzle' },
+    53: { text: 'Drizzle', icon: 'drizzle' },
+    55: { text: 'Heavy drizzle', icon: 'drizzle' },
+    56: { text: 'Freezing drizzle', icon: 'drizzle' },
+    57: { text: 'Freezing drizzle', icon: 'drizzle' },
+    61: { text: 'Light rain', icon: 'rain' },
+    63: { text: 'Rain', icon: 'rain' },
+    65: { text: 'Heavy rain', icon: 'rain' },
+    66: { text: 'Freezing rain', icon: 'rain' },
+    67: { text: 'Freezing rain', icon: 'rain' },
+    71: { text: 'Light snow', icon: 'snow' },
+    73: { text: 'Snow', icon: 'snow' },
+    75: { text: 'Heavy snow', icon: 'snow' },
+    77: { text: 'Snow grains', icon: 'snow' },
+    80: { text: 'Rain showers', icon: 'shower' },
+    81: { text: 'Rain showers', icon: 'shower' },
+    82: { text: 'Violent showers', icon: 'shower' },
+    85: { text: 'Snow showers', icon: 'snow' },
+    86: { text: 'Snow showers', icon: 'snow' },
+    95: { text: 'Thunderstorm', icon: 'storm' },
+    96: { text: 'Thunderstorm', icon: 'storm' },
+    99: { text: 'Thunderstorm', icon: 'storm' },
+};
+/** Map a WMO weather code to display text + a renderer glyph keyword. */
+function describeWmo(code) {
+    return WMO[code] ?? { text: 'Unknown', icon: 'cloud' };
+}
+async function fetchJson(url, timeoutMs) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const res = await fetch(url, {
+            signal: controller.signal,
+            headers: { 'User-Agent': 'nocville-npc' },
+        });
+        if (!res.ok)
+            return null;
+        return (await res.json());
+    }
+    catch {
+        return null;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+/** Resolve a place name to coordinates via the open-meteo geocoding API. */
+async function geocodeLocation(name, timeoutMs = 5000) {
+    const url = `https://geocoding-api.open-meteo.com/v1/search?name=${encodeURIComponent(name)}&count=1`;
+    const res = await fetchJson(url, timeoutMs);
+    const first = res?.['results']?.[0];
+    if (!first || typeof first['latitude'] !== 'number')
+        return null;
+    return {
+        lat: first['latitude'],
+        lon: first['longitude'],
+        label: first['name'] ?? name,
+    };
+}
+/** Best-effort IP geolocation via ipapi.co (keyless). */
+async function autoGeo(timeoutMs = 5000) {
+    const res = await fetchJson('https://ipapi.co/json/', timeoutMs);
+    if (!res || typeof res['latitude'] !== 'number')
+        return null;
+    return {
+        lat: res['latitude'],
+        lon: res['longitude'],
+        label: res['city'],
+    };
+}
+/** Fetch current temperature, weather code, and wind for coordinates. */
+async function fetchWeather(coords, timeoutMs = 5000) {
+    const url = `https://api.open-meteo.com/v1/forecast?latitude=${coords.lat}` +
+        `&longitude=${coords.lon}&current=temperature_2m,weather_code,wind_speed_10m`;
+    const res = await fetchJson(url, timeoutMs);
+    const cur = res?.['current'];
+    if (!cur || typeof cur['temperature_2m'] !== 'number')
+        return null;
+    const code = Number(cur['weather_code'] ?? 0);
+    const { text, icon } = describeWmo(code);
+    return {
+        tempC: Math.round(cur['temperature_2m']),
+        code,
+        text,
+        icon,
+        windKph: Math.round(Number(cur['wind_speed_10m'] ?? 0)),
+    };
+}
+/** Convert Celsius to Fahrenheit, rounded. */
+function toFahrenheit(c) {
+    return Math.round((c * 9) / 5 + 32);
+}
+const DAYS = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'];
+/** Format a Date into day/date/time parts for the welcome sign. */
+function formatClock(d) {
+    const day = DAYS[d.getDay()];
+    let h = d.getHours();
+    const m = d.getMinutes();
+    const ampm = h >= 12 ? 'PM' : 'AM';
+    h = h % 12;
+    if (h === 0)
+        h = 12;
+    const time = `${h}:${String(m).padStart(2, '0')} ${ampm}`;
+    const date = `${d.getMonth() + 1}/${d.getDate()}`;
+    return { day, date, time };
+}
+//# sourceMappingURL=weather.js.map

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

@@ -0,0 +1,68 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createCpuSampler = createCpuSampler;
+exports.collectMemory = collectMemory;
+exports.collectDisk = collectDisk;
+const node_os_1 = __importDefault(require("node:os"));
+const node_fs_1 = require("node:fs");
+function aggregate(cpus) {
+    let idle = 0;
+    let total = 0;
+    for (const cpu of cpus) {
+        const t = cpu.times;
+        idle += t.idle;
+        total += t.user + t.nice + t.sys + t.irq + t.idle;
+    }
+    return { idle, total };
+}
+/**
+ * Stateful CPU sampler that computes usage from the delta between consecutive
+ * `os.cpus()` snapshots — no blocking sleep. The first sample reports usage
+ * since system boot; subsequent samples report usage since the previous call.
+ *
+ * `readCpus`/`readLoad` are injectable for testing.
+ */
+function createCpuSampler(readCpus = () => node_os_1.default.cpus(), readLoad = () => node_os_1.default.loadavg()[0] ?? 0) {
+    let prev = null;
+    return {
+        sample() {
+            const cur = aggregate(readCpus());
+            const loadAvg1m = Math.round(readLoad() * 100) / 100;
+            const base = prev ?? { idle: 0, total: 0 };
+            const idleDiff = cur.idle - base.idle;
+            const totalDiff = cur.total - base.total;
+            prev = cur;
+            const percent = totalDiff > 0 ? Math.round((1 - idleDiff / totalDiff) * 100) : 0;
+            return { percent, loadAvg1m };
+        },
+    };
+}
+/**
+ * Collect memory usage from OS.
+ */
+function collectMemory() {
+    const totalBytes = node_os_1.default.totalmem();
+    const freeBytes = node_os_1.default.freemem();
+    const usedBytes = totalBytes - freeBytes;
+    const totalGb = Math.round((totalBytes / 1024 ** 3) * 100) / 100;
+    const usedGb = Math.round((usedBytes / 1024 ** 3) * 100) / 100;
+    const percent = Math.round((usedBytes / totalBytes) * 100);
+    return { percent, usedGb, totalGb };
+}
+/**
+ * Collect disk usage via fs.statfs (Node 18.15+).
+ */
+async function collectDisk(path) {
+    const stats = await node_fs_1.promises.statfs(path);
+    const totalBytes = stats.blocks * stats.bsize;
+    const freeBytes = stats.bavail * stats.bsize;
+    const usedBytes = totalBytes - freeBytes;
+    const totalGb = Math.round((totalBytes / 1024 ** 3) * 100) / 100;
+    const usedGb = Math.round((usedBytes / 1024 ** 3) * 100) / 100;
+    const percent = totalBytes > 0 ? Math.round((usedBytes / totalBytes) * 100) : 0;
+    return { percent, usedGb, totalGb };
+}
+//# sourceMappingURL=collectors.js.map

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

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_THRESHOLDS = exports.DEFAULTS = void 0;
+exports.DEFAULTS = {
+    pollInterval: 15000,
+    diskPath: '/',
+};
+exports.DEFAULT_THRESHOLDS = {
+    cpu: { warning: 75, critical: 90, direction: 'above' },
+    mem: { warning: 75, critical: 90, direction: 'above' },
+    disk: { warning: 75, critical: 90, direction: 'above' },
+};
+//# sourceMappingURL=defaults.js.map

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

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+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 collectors_js_1 = require("./collectors.js");
+const defaults_js_1 = require("./defaults.js");
+class SystemMonitorNPC extends polling_npc_js_1.PollingNPC {
+    diskPath;
+    cpuThreshold;
+    memThreshold;
+    diskThreshold;
+    cpuSampler = (0, collectors_js_1.createCpuSampler)();
+    cpuHistory = [];
+    memHistory = [];
+    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'];
+    }
+    get name() {
+        return 'system-monitor';
+    }
+    get defaultDisplayName() {
+        return 'System Monitor';
+    }
+    get archetype() {
+        return 'service';
+    }
+    get heartbeatSeconds() {
+        return 30;
+    }
+    get behavior() {
+        return { idle: 'wander' };
+    }
+    get companion() {
+        return {
+            screenType: 'dashboard-wall',
+            size: { w: 2, h: 2 },
+            placement: 'adjacent-wall',
+            label: 'System',
+        };
+    }
+    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 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);
+        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 screenData = {
+            layout: 'multi-metric',
+            values: [
+                {
+                    label: 'CPU',
+                    value: `${cpu.percent}%`,
+                    color: (0, screen_js_1.statusColor)(cpuStatus),
+                    sparkline: [...this.cpuHistory],
+                },
+                {
+                    label: 'MEM',
+                    value: `${mem.percent}%`,
+                    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' },
+            ],
+        };
+        return {
+            status,
+            mood,
+            message: `CPU: ${cpu.percent}% | Mem: ${mem.percent}% | Disk: ${disk.percent}%`,
+            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,
+            },
+        };
+    }
+}
+exports.SystemMonitorNPC = SystemMonitorNPC;
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractTitle = extractTitle;
+exports.statusFromHttp = statusFromHttp;
+exports.basicCheck = basicCheck;
+exports.hostnameOf = hostnameOf;
+/** Extract the <title> text from an HTML string (empty if none). */
+function extractTitle(html) {
+    const m = html.match(/<title[^>]*>([\s\S]*?)<\/title>/i);
+    return m ? m[1].replace(/\s+/g, ' ').trim().slice(0, 80) : '';
+}
+/** Map an HTTP status to NPC status: 2xx/3xx ok, 4xx/timeout warn, 5xx/refused crit. */
+function statusFromHttp(code, timedOut = false) {
+    if (code >= 200 && code < 400)
+        return 'healthy';
+    if (code >= 400 && code < 500)
+        return 'warning';
+    if (code >= 500)
+        return 'critical';
+    return timedOut ? 'warning' : 'critical'; // 0 = network error
+}
+/** 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' },
+            redirect: 'follow',
+        });
+        let title = '';
+        try {
+            title = extractTitle(await res.text());
+        }
+        catch {
+            // body unavailable; leave title blank
+        }
+        return { status: res.status, title, ok: res.ok, timedOut: false };
+    }
+    catch (err) {
+        const timedOut = err instanceof Error && 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. */
+function hostnameOf(url) {
+    try {
+        return new URL(url).hostname;
+    }
+    catch {
+        return url.slice(0, 40);
+    }
+}
+//# sourceMappingURL=basic-mode.js.map

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

@@ -0,0 +1,80 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findChrome = findChrome;
+exports.loadPuppeteer = loadPuppeteer;
+exports.browserConnected = browserConnected;
+const node_fs_1 = require("node:fs");
+const node_child_process_1 = require("node:child_process");
+const MAC_PATHS = [
+    '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome',
+    '/Applications/Google Chrome Canary.app/Contents/MacOS/Google Chrome Canary',
+    '/Applications/Chromium.app/Contents/MacOS/Chromium',
+    '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge',
+    '/Applications/Brave Browser.app/Contents/MacOS/Brave Browser',
+];
+const LINUX_BINARIES = [
+    'google-chrome',
+    'google-chrome-stable',
+    'chromium',
+    'chromium-browser',
+    'brave-browser',
+];
+function which(bin) {
+    try {
+        const out = (0, node_child_process_1.execFileSync)('which', [bin], { encoding: 'utf-8' }).trim();
+        return out || null;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Find a usable Chrome/Chromium executable: explicit path → CHROME_PATH env →
+ * platform-specific known locations (mac app bundles; `which` on linux).
+ */
+function findChrome(explicit) {
+    const envPath = process.env['CHROME_PATH'];
+    if (explicit && (0, node_fs_1.existsSync)(explicit))
+        return explicit;
+    if (envPath && (0, node_fs_1.existsSync)(envPath))
+        return envPath;
+    if (process.platform === 'darwin') {
+        for (const p of MAC_PATHS)
+            if ((0, node_fs_1.existsSync)(p))
+                return p;
+        return null;
+    }
+    if (process.platform === 'linux') {
+        for (const bin of LINUX_BINARIES) {
+            const resolved = which(bin);
+            if (resolved && (0, node_fs_1.existsSync)(resolved))
+                return resolved;
+        }
+        return null;
+    }
+    return null;
+}
+/**
+ * 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
+ * module is absent.
+ */
+async function loadPuppeteer() {
+    try {
+        const dynImport = new Function('m', 'return import(m)');
+        const mod = await dynImport('puppeteer-core');
+        return (mod.default ?? mod);
+    }
+    catch {
+        return null;
+    }
+}
+/** True if the browser reports a live connection. */
+function browserConnected(browser) {
+    if (typeof browser.connected === 'boolean')
+        return browser.connected;
+    if (typeof browser.isConnected === 'function')
+        return browser.isConnected();
+    return true;
+}
+//# sourceMappingURL=capture.js.map

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

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULTS = void 0;
+exports.parseDimensions = parseDimensions;
+exports.DEFAULTS = {
+    pollInterval: 60000, // 60s
+    minPollInterval: 15000, // floor
+    navTimeoutMs: 15000,
+    maxColors: 32,
+    /** Polls to keep the 'changed' sub-status active after a page change. */
+    changedPolls: 2,
+    // Default TV resolution (4:3, matches the 4×3 web-view companion). The client
+    // reads WxH from the pixel-image `fmt` string, so any size is self-consistent.
+    screenW: 160,
+    screenH: 120,
+    // deviceScaleFactor is 1/8, so the viewport defaults to screen × 8 → Chrome
+    // rasterizes the screen size natively (overridable via --viewport).
+    scaleDivisor: 8,
+    waitUntil: 'networkidle2',
+};
+/** Parse a "WxH" string into a {width, height} pair, or null if malformed. */
+function parseDimensions(s) {
+    const m = s
+        .trim()
+        .toLowerCase()
+        .match(/^(\d+)x(\d+)$/);
+    if (!m)
+        return null;
+    return { width: parseInt(m[1], 10), height: parseInt(m[2], 10) };
+}
+//# sourceMappingURL=defaults.js.map