@nocville/npc 0.2.2 → 0.3.0

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

@@ -4,6 +4,7 @@ exports.ProcessWatcherNPC = 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 process_scanner_js_1 = require("./process-scanner.js");
 const defaults_js_1 = require("./defaults.js");
 /** Max per-process panels on the companion dashboard. */
@@ -15,14 +16,16 @@ class ProcessWatcherNPC extends polling_npc_js_1.PollingNPC {
     cpuHistories = new Map();
     previousRunning = null;
     constructor(config) {
-        if (process.platform === 'win32') {
-            throw new Error('process-watcher is not supported on Windows (relies on the POSIX `ps` command). ' +
-                'Run it under WSL/Linux, or use system-monitor instead.');
-        }
         super(config);
-        this.processes = config.processes;
+        this.processes = [...new Set(config.processes.map((p) => p.trim()).filter(Boolean))];
+        if (this.processes.length === 0) {
+            throw new errors_js_1.NpcConfigError('process-watcher needs at least one process name (--processes)');
+        }
         this.cpuWarn = config.cpuWarn ?? defaults_js_1.DEFAULTS.cpuWarn;
         this.memWarn = config.memWarn ?? defaults_js_1.DEFAULTS.memWarn;
+        if (!(this.cpuWarn > 0) || !(this.memWarn > 0)) {
+            throw new errors_js_1.NpcConfigError('--cpu-warn and --mem-warn must be positive numbers');
+        }
     }
     get name() {
         return 'process-watcher';
@@ -33,9 +36,6 @@ class ProcessWatcherNPC extends polling_npc_js_1.PollingNPC {
     get archetype() {
         return 'service';
     }
-    get heartbeatSeconds() {
-        return 30;
-    }
     get companion() {
         return {
             screenType: 'dashboard-wall',
@@ -45,22 +45,28 @@ class ProcessWatcherNPC extends polling_npc_js_1.PollingNPC {
         };
     }
     async collect() {
-        const infos = await (0, process_scanner_js_1.scanProcesses)(this.processes);
+        let infos;
+        try {
+            infos = await (0, process_scanner_js_1.scanProcesses)(this.processes);
+        }
+        catch (err) {
+            // Not knowing is different from "everything died": report unknown and
+            // leave the transition baseline alone so recovery doesn't say "is back".
+            return this.scanFailed(err);
+        }
         const statuses = [];
-        const messageParts = [];
+        const problems = [];
         const metrics = {};
         const panels = [];
         let totalRunning = 0;
-        let totalMissing = 0;
         for (const info of infos) {
             const safeKey = info.name.replace(/[^a-zA-Z0-9_]/g, '_');
             if (!info.running) {
                 statuses.push('critical');
-                messageParts.push(`${info.name}: NOT FOUND`);
+                problems.push(`${info.name} DOWN`);
                 metrics[`${safeKey}_running`] = 0;
                 metrics[`${safeKey}_cpu`] = 0;
                 metrics[`${safeKey}_mem_mb`] = 0;
-                totalMissing++;
                 if (panels.length < MAX_PANELS) {
                     panels.push({ label: info.name, value: 'DOWN', color: 'red' });
                 }
@@ -68,73 +74,76 @@ class ProcessWatcherNPC extends polling_npc_js_1.PollingNPC {
             }
             totalRunning++;
             const cpu = info.cpuPercent ?? 0;
+            const memMb = info.memMb ?? 0;
             metrics[`${safeKey}_running`] = 1;
             metrics[`${safeKey}_cpu`] = cpu;
-            metrics[`${safeKey}_mem_mb`] = info.memMb ?? 0;
+            metrics[`${safeKey}_mem_mb`] = memMb;
             const history = this.cpuHistories.get(info.name) ?? [];
             (0, screen_js_1.pushHistory)(history, cpu);
             this.cpuHistories.set(info.name, history);
-            const cpuHigh = cpu >= this.cpuWarn;
-            const memHigh = (info.memMb ?? 0) >= this.memWarn;
-            if (cpuHigh || memHigh) {
-                statuses.push('warning');
-                const warnings = [];
-                if (cpuHigh)
-                    warnings.push(`cpu=${cpu}%`);
-                if (memHigh)
-                    warnings.push(`mem=${info.memMb}MB`);
-                messageParts.push(`${info.name}: WARN (${warnings.join(', ')})`);
-            }
-            else {
-                statuses.push('healthy');
-                messageParts.push(`${info.name}: OK`);
+            // Single warning thresholds: no critical level for resource use.
+            const cpuStatus = (0, thresholds_js_1.evaluateThreshold)(cpu, { warning: this.cpuWarn, critical: Infinity });
+            const memStatus = (0, thresholds_js_1.evaluateThreshold)(memMb, { warning: this.memWarn, critical: Infinity });
+            const status = (0, thresholds_js_1.worstStatus)([cpuStatus, memStatus]);
+            statuses.push(status);
+            if (status !== 'healthy') {
+                const high = [];
+                if (cpuStatus !== 'healthy')
+                    high.push(`cpu ${cpu}%`);
+                if (memStatus !== 'healthy')
+                    high.push(`mem ${Math.round(memMb)}MB`);
+                problems.push(`${info.name} high ${high.join(', ')}`);
             }
             if (panels.length < MAX_PANELS) {
                 panels.push({
                     label: info.name,
                     value: `${cpu}%`,
-                    color: cpuHigh || memHigh ? 'amber' : 'green',
+                    color: (0, screen_js_1.statusColor)(status),
                     sparkline: [...history],
                 });
             }
         }
+        const totalMissing = infos.length - totalRunning;
         metrics['total_watched'] = this.processes.length;
         metrics['total_running'] = totalRunning;
         metrics['total_missing'] = totalMissing;
         // Transition speech: compare the running set to last poll's. On the first
         // poll we only seed the set (no bogus "is back" for already-running procs).
         const currentRunning = new Set(infos.filter((i) => i.running).map((i) => i.name));
-        let transitions = [];
-        if (this.previousRunning !== null) {
-            transitions = (0, process_scanner_js_1.detectTransitions)(this.previousRunning, currentRunning);
-        }
+        const transitions = this.previousRunning === null ? [] : (0, process_scanner_js_1.detectTransitions)(this.previousRunning, currentRunning);
         this.previousRunning = currentRunning;
         const status = (0, thresholds_js_1.worstStatus)(statuses);
-        const mood = deriveMood(status);
-        // A death message takes over the bubble this cycle so it reads as an alert.
-        const message = transitions.length > 0 ? transitions.join(' · ') : messageParts.join(' | ');
-        const screenData = { layout: 'multi-metric', values: panels };
+        const summary = problems.length === 0
+            ? `All ${infos.length} running`
+            : `${totalRunning}/${infos.length} running · ${problems.join(' · ')}`;
+        // A death/return takes over the bubble this cycle so it reads as an alert.
+        const message = transitions.length > 0 ? transitions.join(' · ') : summary;
         return {
             status,
-            mood,
+            mood: (0, thresholds_js_1.moodForStatus)(status),
             message,
             subStatus: totalMissing > 0 ? 'process-down' : undefined,
-            screenData,
+            screenData: { layout: 'multi-metric', values: panels },
             metrics,
         };
     }
-}
-exports.ProcessWatcherNPC = ProcessWatcherNPC;
-function deriveMood(status) {
-    switch (status) {
-        case 'healthy':
-            return 'happy';
-        case 'warning':
-            return 'concerned';
-        case 'critical':
-            return 'stressed';
-        default:
-            return 'idle';
+    scanFailed(err) {
+        const reason = err instanceof Error ? err.message : String(err);
+        this.logger.warn('Cannot list processes', { error: reason });
+        return {
+            status: 'unknown',
+            mood: (0, thresholds_js_1.moodForStatus)('unknown'),
+            message: 'Cannot list processes (ps failed)',
+            subStatus: 'scan-failed',
+            screenData: {
+                layout: 'multi-metric',
+                values: this.processes
+                    .slice(0, MAX_PANELS)
+                    .map((name) => ({ label: name, value: '?', color: 'gray' })),
+            },
+            metrics: { total_watched: this.processes.length },
+        };
     }
 }
+exports.ProcessWatcherNPC = ProcessWatcherNPC;
 //# sourceMappingURL=index.js.map

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

@@ -1,10 +1,22 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.detectTransitions = detectTransitions;
+exports.parsePsOutput = parsePsOutput;
+exports.matchesName = matchesName;
+exports.listProcesses = listProcesses;
+exports.parseWindowsProcesses = parseWindowsProcesses;
+exports.matchProcesses = matchProcesses;
 exports.scanProcesses = scanProcesses;
 const node_child_process_1 = require("node:child_process");
 const node_util_1 = require("node:util");
+const node_os_1 = require("node:os");
+const node_path_1 = require("node:path");
 const execFileAsync = (0, node_util_1.promisify)(node_child_process_1.execFile);
+/** Bounds on the `ps` call: a wedged or enormous process table can't stall or flood us. */
+const PS_TIMEOUT_MS = 5000;
+const PS_MAX_BUFFER = 16 * 1024 * 1024;
+/** Linux truncates `comm` to 15 characters (TASK_COMM_LEN - 1). */
+const LINUX_COMM_LEN = 15;
 /**
  * Compare the previous and current running-process sets and return speech
  * strings for any transitions: "<name> died!" when a process disappears and
@@ -23,92 +35,112 @@ function detectTransitions(prev, curr) {
     return messages;
 }
 /**
- * Parse the output of `ps` into structured entries.
- * Expects columns: PID, %CPU, RSS (KB), COMMAND
+ * Parse header-less `ps -eo pid=,pcpu=,rss=,comm=` output. COMMAND is the rest
+ * of the line, so macOS paths with spaces ("Google Chrome") survive intact.
  */
 function parsePsOutput(stdout) {
-    const lines = stdout.trim().split('\n');
-    // Skip the header line
     const entries = [];
-    for (let i = 1; i < lines.length; i++) {
-        const line = lines[i].trim();
-        if (!line)
+    for (const line of stdout.split('\n')) {
+        const m = line.match(/^\s*(\d+)\s+([\d.]+)\s+(\d+)\s+(.+?)\s*$/);
+        if (!m)
             continue;
-        // Fields are whitespace-separated: PID, %CPU, RSS, COMMAND (may contain spaces)
-        const parts = line.split(/\s+/);
-        if (parts.length < 4)
-            continue;
-        const pid = parseInt(parts[0], 10);
-        const cpu = parseFloat(parts[1]);
-        const memKb = parseInt(parts[2], 10);
-        // COMMAND is everything from the 4th column onward
-        const comm = parts.slice(3).join(' ');
-        if (Number.isNaN(pid) || Number.isNaN(cpu) || Number.isNaN(memKb))
-            continue;
-        entries.push({ pid, cpu, memKb, comm });
+        entries.push({
+            pid: Number(m[1]),
+            cpu: Number(m[2]),
+            memKb: Number(m[3]),
+            comm: m[4],
+        });
     }
     return entries;
 }
 /**
- * Match a process name against a ps COMMAND column.
- * Matches if the basename of the command path equals the search name,
- * or if the command contains the search name.
+ * Does a ps COMMAND entry match a watched name? Case-insensitive on the
+ * executable's basename:
+ * - exact: `nginx` matches `/usr/sbin/nginx`;
+ * - version suffix: `python` matches `python3` and `python3.11`;
+ * - Linux truncation: a name longer than 15 chars matches its 15-char prefix;
+ * - a name containing `/` must equal the full path (macOS reports paths).
+ * Unlike a substring match, `sh` does not match `bash` or `ssh-agent`.
  */
 function matchesName(comm, searchName) {
-    // Get the basename of the command (strip path and arguments)
-    const basename = comm.split('/').pop()?.split(/\s/)[0] ?? '';
-    if (basename === searchName)
+    if (/[\\/]/.test(searchName))
+        return comm === searchName;
+    const base = (comm.split(/[\\/]/).pop() ?? comm).toLowerCase().replace(/\.exe$/, '');
+    const name = searchName.toLowerCase().replace(/\.exe$/, '');
+    if (base === name)
         return true;
-    // Also check if the full command string contains the name
-    // (handles cases like "python my-script.py" when searching for "python")
-    return comm.toLowerCase().includes(searchName.toLowerCase());
+    if (name.length > LINUX_COMM_LEN && base === name.slice(0, LINUX_COMM_LEN))
+        return true;
+    return base.startsWith(name) && /^\d[\d.]*$/.test(base.slice(name.length));
 }
-/**
- * Scan for processes by name and return their status and resource usage.
- * Works on macOS and Linux by using `ps` to list all processes.
- */
-async function scanProcesses(names) {
-    let psArgs;
-    if (process.platform === 'darwin') {
-        // macOS: -e selects all processes, -o specifies output columns
-        psArgs = ['-eo', 'pid,pcpu,rss,comm'];
-    }
-    else {
-        // Linux: -eo with similar columns
-        psArgs = ['-eo', 'pid,pcpu,rss,comm'];
-    }
-    let entries;
-    try {
-        const { stdout } = await execFileAsync('ps', psArgs);
-        entries = parsePsOutput(stdout);
-    }
-    catch {
-        // If ps fails, report all processes as unknown / not running
-        return names.map((name) => ({ name, running: false }));
+/** List every process. Throws if `ps` fails — callers must not read that as "all dead". */
+async function listProcesses() {
+    if (process.platform === 'win32') {
+        // Fixed command, no user strings interpolated. Performance counters report a
+        // sampling interval (Get-Process.CPU is lifetime CPU seconds, not a percent).
+        const executable = (0, node_path_1.join)(process.env['SystemRoot'] || 'C:\\Windows', 'System32', 'WindowsPowerShell', 'v1.0', 'powershell.exe');
+        const { stdout } = await execFileAsync(executable, [
+            '-NoProfile',
+            '-NonInteractive',
+            '-Command',
+            '$ErrorActionPreference="Stop"; Get-CimInstance Win32_PerfFormattedData_PerfProc_Process | Select-Object IDProcess,Name,PercentProcessorTime,WorkingSetPrivate | ConvertTo-Json -Compress',
+        ], { timeout: PS_TIMEOUT_MS, maxBuffer: PS_MAX_BUFFER, windowsHide: true });
+        return parseWindowsProcesses(stdout, (0, node_os_1.cpus)().length);
     }
-    const results = [];
-    for (const name of names) {
-        // Find all matching entries for this process name
+    const { stdout } = await execFileAsync('ps', ['-eo', 'pid=,pcpu=,rss=,comm='], {
+        timeout: PS_TIMEOUT_MS,
+        maxBuffer: PS_MAX_BUFFER,
+        // Some locales print %CPU with a decimal comma ("1,5"); force "1.5".
+        env: { ...process.env, LC_ALL: 'C' },
+    });
+    return parsePsOutput(stdout);
+}
+/** Windows instance suffixes (#1, #2) distinguish copies of the same executable. */
+function parseWindowsProcesses(stdout, cores = 1) {
+    const value = JSON.parse(stdout.replace(/^\uFEFF/, ''));
+    const rows = Array.isArray(value) ? value : value ? [value] : [];
+    return rows.flatMap((row) => {
+        const pid = Number(row.IDProcess);
+        const cpu = Number(row.PercentProcessorTime);
+        const bytes = Number(row.WorkingSetPrivate);
+        if (!(pid > 0) ||
+            !Number.isFinite(cpu) ||
+            !Number.isFinite(bytes) ||
+            typeof row.Name !== 'string')
+            return [];
+        return [
+            {
+                pid,
+                cpu: cpu / Math.max(1, cores),
+                memKb: bytes / 1024,
+                comm: row.Name.replace(/#\d+$/, ''),
+            },
+        ];
+    });
+}
+/** Summarise each watched name against a process list (CPU and memory summed per name). */
+function matchProcesses(names, entries) {
+    return names.map((name) => {
         const matching = entries.filter((e) => matchesName(e.comm, name));
-        if (matching.length === 0) {
-            results.push({ name, running: false });
-            continue;
-        }
-        // Aggregate: take the first matching PID, sum CPU and memory across all instances
-        let totalCpu = 0;
-        let totalMemKb = 0;
-        for (const entry of matching) {
-            totalCpu += entry.cpu;
-            totalMemKb += entry.memKb;
-        }
-        results.push({
+        if (matching.length === 0)
+            return { name, running: false };
+        const totalCpu = matching.reduce((sum, e) => sum + e.cpu, 0);
+        const totalMemKb = matching.reduce((sum, e) => sum + e.memKb, 0);
+        return {
             name,
             running: true,
             pid: matching[0].pid,
+            count: matching.length,
             cpuPercent: Math.round(totalCpu * 100) / 100,
             memMb: Math.round((totalMemKb / 1024) * 100) / 100,
-        });
-    }
-    return results;
+        };
+    });
+}
+/**
+ * Scan for processes by name and return their status and resource usage.
+ * Uses `ps` on macOS/Linux and CIM on Windows. Throws when the process list is unavailable.
+ */
+async function scanProcesses(names) {
+    return matchProcesses(names, await listProcesses());
 }
 //# sourceMappingURL=process-scanner.js.map

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

@@ -4,6 +4,10 @@ exports.DEFAULTS = void 0;
 exports.DEFAULTS = {
     pollInterval: 60000, // 60s clock tick
     weatherRefreshMs: 15 * 60 * 1000, // refresh weather every 15 minutes
+    /** Drop a reading this old (repeated refresh failures) rather than show stale weather. */
+    weatherMaxAgeMs: 2 * 60 * 60 * 1000,
+    /** Wait this long before retrying a failed geocode / IP geo / weather call. */
+    retryBackoffMs: 5 * 60 * 1000,
     fetchTimeoutMs: 5000,
 };
 //# sourceMappingURL=defaults.js.map

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

@@ -2,24 +2,9 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.ReceptionistNPC = void 0;
 const polling_npc_js_1 = require("../../core/polling-npc.js");
-const defaults_js_1 = require("./defaults.js");
-const weather_js_1 = require("./weather.js");
 class ReceptionistNPC extends polling_npc_js_1.PollingNPC {
-    explicitCoords;
-    location;
-    fahrenheit;
-    coords = null;
-    geoAttempted = false;
-    weather = null;
-    lastWeatherFetch = 0;
     constructor(config) {
-        super({ ...config, pollInterval: config.pollInterval ?? defaults_js_1.DEFAULTS.pollInterval });
-        this.explicitCoords =
-            config.lat !== undefined && config.lon !== undefined
-                ? { lat: config.lat, lon: config.lon }
-                : null;
-        this.location = config.location;
-        this.fahrenheit = config.fahrenheit ?? false;
+        super({ ...config, pollInterval: config.pollInterval ?? 60_000 });
     }
     get name() {
         return 'receptionist';
@@ -32,88 +17,16 @@ class ReceptionistNPC extends polling_npc_js_1.PollingNPC {
     }
     get behavior() {
         return {
+            role: 'receptionist',
+            activity: 'idle',
             greetPlayers: true,
-            patrol: { everyMinutes: [15, 30], stops: 5 },
             idle: 'stay',
-            home: { near: 'entrance' },
-        };
-    }
-    get companion() {
-        return {
-            screenType: 'welcome-sign',
-            size: { w: 2, h: 1 },
-            placement: 'adjacent-wall',
-            label: 'Welcome',
+            idlePose: 'sit',
         };
     }
     async collect() {
-        await this.refreshWeather();
-        const now = new Date();
-        const { day, date, time } = (0, weather_js_1.formatClock)(now);
-        const values = [
-            { label: 'time', value: time },
-            { label: 'day', value: day },
-            { label: 'date', value: date },
-        ];
-        let message = `${day} ${time}`;
-        const metrics = { weather_ok: this.weather ? 1 : 0 };
-        if (this.weather) {
-            const temp = this.fahrenheit
-                ? `${(0, weather_js_1.toFahrenheit)(this.weather.tempC)}°F`
-                : `${this.weather.tempC}°C`;
-            message += ` • ${temp} ${this.weather.text}`;
-            values.push({ label: 'temp', value: temp }, { label: 'condition', value: this.weather.text }, { label: 'icon', value: this.weather.icon });
-            metrics['temp_c'] = this.weather.tempC;
-            metrics['weather_code'] = this.weather.code;
-            metrics['wind_kph'] = this.weather.windKph;
-        }
-        // The receptionist is a greeter/clock — it stays healthy even when weather
-        // is unavailable (degraded time-only mode).
-        return {
-            status: 'healthy',
-            mood: 'happy',
-            message,
-            screenData: { layout: 'welcome-sign', values },
-            metrics,
-        };
-    }
-    async refreshWeather() {
-        if (!this.coords) {
-            await this.resolveCoords();
-        }
-        if (!this.coords)
-            return;
-        const now = Date.now();
-        if (this.weather && now - this.lastWeatherFetch < defaults_js_1.DEFAULTS.weatherRefreshMs)
-            return;
-        const w = await (0, weather_js_1.fetchWeather)(this.coords, defaults_js_1.DEFAULTS.fetchTimeoutMs);
-        if (w) {
-            this.weather = w;
-            this.lastWeatherFetch = now;
-        }
-    }
-    async resolveCoords() {
-        if (this.explicitCoords) {
-            this.coords = this.explicitCoords;
-            return;
-        }
-        // Only attempt geocoding/geo-IP once per (failed) resolution to avoid
-        // hammering the keyless endpoints every poll.
-        if (this.geoAttempted)
-            return;
-        this.geoAttempted = true;
-        if (this.location) {
-            this.coords = await (0, weather_js_1.geocodeLocation)(this.location, defaults_js_1.DEFAULTS.fetchTimeoutMs);
-            if (this.coords)
-                return;
-            this.logger.warn(`Could not geocode "${this.location}", falling back to IP geo`);
-        }
-        this.coords = await (0, weather_js_1.autoGeo)(defaults_js_1.DEFAULTS.fetchTimeoutMs);
-        if (!this.coords) {
-            this.logger.warn('Weather geo unavailable — running in time-only mode');
-            // Allow a later retry.
-            this.geoAttempted = false;
-        }
+        // The server handles conversation and movement. Heartbeats stay quiet.
+        return { status: 'healthy', mood: 'happy', message: '', metrics: {} };
     }
 }
 exports.ReceptionistNPC = ReceptionistNPC;

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

@@ -1,16 +1,20 @@
 "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.validCoords = validCoords;
 exports.geocodeLocation = geocodeLocation;
 exports.autoGeo = autoGeo;
 exports.fetchWeather = fetchWeather;
 exports.toFahrenheit = toFahrenheit;
 exports.formatClock = formatClock;
+/**
+ * Keyless weather + geolocation via open-meteo, with an optional ipapi.co IP
+ * fallback. Every call is time- and size-bounded, validates the (untrusted)
+ * response, and returns null on failure so the receptionist can degrade to a
+ * time-only mode without erroring.
+ */
+const http_js_1 = require("../../core/http.js");
+const text_js_1 = require("../../core/text.js");
 // 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 = {
@@ -47,65 +51,56 @@ const WMO = {
 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);
-    }
+/** A finite, in-range latitude/longitude pair. */
+function validCoords(lat, lon) {
+    const la = (0, http_js_1.finiteNumber)(lat);
+    const lo = (0, http_js_1.finiteNumber)(lon);
+    return la !== null && lo !== null && Math.abs(la) <= 90 && Math.abs(lo) <= 180;
 }
-/** 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')
+function coordsFrom(rec, labelKey) {
+    if (!validCoords(rec['latitude'], rec['longitude']))
         return null;
+    const label = rec[labelKey];
     return {
-        lat: first['latitude'],
-        lon: first['longitude'],
-        label: first['name'] ?? name,
+        lat: rec['latitude'],
+        lon: rec['longitude'],
+        label: typeof label === 'string' ? (0, text_js_1.sanitizeText)(label, 60) : undefined,
     };
 }
-/** Best-effort IP geolocation via ipapi.co (keyless). */
+/** 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.slice(0, 100))}&count=1`;
+    const results = (0, http_js_1.asRecord)(await (0, http_js_1.fetchJson)(url, { timeoutMs }))?.['results'];
+    const first = Array.isArray(results) ? (0, http_js_1.asRecord)(results[0]) : null;
+    return first ? coordsFrom(first, 'name') : null;
+}
+/**
+ * Best-effort IP geolocation via ipapi.co (keyless). This sends the machine's
+ * public IP to a third party, so the receptionist only calls it when no place
+ * was configured and the user hasn't opted out. Only the coordinates are used;
+ * nothing from the response is pushed to Nocville.
+ */
 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'],
-    };
+    const res = (0, http_js_1.asRecord)(await (0, http_js_1.fetchJson)('https://ipapi.co/json/', { timeoutMs }));
+    return res ? coordsFrom(res, 'city') : null;
 }
 /** 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')
+    const cur = (0, http_js_1.asRecord)((0, http_js_1.asRecord)(await (0, http_js_1.fetchJson)(url, { timeoutMs }))?.['current']);
+    const temp = (0, http_js_1.finiteNumber)(cur?.['temperature_2m']);
+    if (!cur || temp === null || Math.abs(temp) > 100)
         return null;
-    const code = Number(cur['weather_code'] ?? 0);
+    const code = (0, http_js_1.finiteNumber)(cur['weather_code']) ?? -1;
     const { text, icon } = describeWmo(code);
     return {
-        tempC: Math.round(cur['temperature_2m']),
+        tempC: Math.round(temp),
         code,
         text,
         icon,
-        windKph: Math.round(Number(cur['wind_speed_10m'] ?? 0)),
+        windKph: Math.round(Math.max(0, (0, http_js_1.finiteNumber)(cur['wind_speed_10m']) ?? 0)),
     };
 }
 /** Convert Celsius to Fahrenheit, rounded. */