@nocville/npc 0.2.1 → 0.2.3

package/dist/cjs/core/http.js

@@ -0,0 +1,121 @@
+"use strict";
+/**
+ * Small, bounded HTTP helpers for NPCs that read untrusted remote content
+ * (weather/geo APIs, GitHub, watched web pages). Every call has a timeout and
+ * every body read has a byte cap, so a slow or hostile server can neither hang
+ * a collection nor balloon memory.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_MAX_BODY_BYTES = exports.NPC_USER_AGENT = void 0;
+exports.isHttpUrl = isHttpUrl;
+exports.displayUrl = displayUrl;
+exports.readTextCapped = readTextCapped;
+exports.discardBody = discardBody;
+exports.fetchJson = fetchJson;
+exports.asRecord = asRecord;
+exports.finiteNumber = finiteNumber;
+/** The `User-Agent` sent by every NPC request. */
+exports.NPC_USER_AGENT = 'nocville-npc';
+/** Default cap for a response body read into memory. */
+exports.DEFAULT_MAX_BODY_BYTES = 1024 * 1024;
+/** True for an absolute http(s) URL (anything else — file:, data:, javascript: — is refused). */
+function isHttpUrl(value) {
+    try {
+        const url = new URL(value);
+        return url.protocol === 'http:' || url.protocol === 'https:';
+    }
+    catch {
+        return false;
+    }
+}
+/** A URL rendered for logs/screens: scheme, host and path only — never credentials or query. */
+function displayUrl(value) {
+    try {
+        const url = new URL(value);
+        return `${url.protocol}//${url.host}${url.pathname === '/' ? '' : url.pathname}`;
+    }
+    catch {
+        return '(invalid url)';
+    }
+}
+/**
+ * Read a response body as UTF-8, keeping at most `maxBytes`. Streams when the
+ * body is available (cancelling the rest); otherwise falls back to `text()`
+ * after rejecting an oversized declared Content-Length. Returns the (possibly
+ * truncated) text and whether it was truncated.
+ */
+async function readTextCapped(res, maxBytes = exports.DEFAULT_MAX_BODY_BYTES) {
+    const reader = res.body?.getReader();
+    if (!reader) {
+        const declared = Number(res.headers?.get('content-length') ?? NaN);
+        if (Number.isFinite(declared) && declared > maxBytes)
+            return { text: '', truncated: true };
+        const text = await res.text();
+        return text.length > maxBytes
+            ? { text: text.slice(0, maxBytes), truncated: true }
+            : { text, truncated: false };
+    }
+    const chunks = [];
+    let total = 0;
+    let truncated = false;
+    try {
+        for (;;) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            if (total + value.byteLength > maxBytes) {
+                chunks.push(value.subarray(0, maxBytes - total));
+                total = maxBytes;
+                truncated = true;
+                break;
+            }
+            chunks.push(value);
+            total += value.byteLength;
+        }
+    }
+    finally {
+        if (truncated)
+            await reader.cancel().catch(() => undefined);
+        reader.releaseLock();
+    }
+    return { text: new TextDecoder().decode(Buffer.concat(chunks)), truncated };
+}
+/** Discard a response body without reading it (frees the connection). */
+async function discardBody(res) {
+    await res.body?.cancel().catch(() => undefined);
+}
+/**
+ * GET a JSON document with a timeout and size cap. Returns null on any network
+ * error, non-2xx status, oversized body or malformed JSON — callers degrade
+ * gracefully rather than throw.
+ */
+async function fetchJson(url, opts) {
+    try {
+        const res = await fetch(url, {
+            signal: AbortSignal.timeout(opts.timeoutMs),
+            headers: { 'User-Agent': exports.NPC_USER_AGENT, Accept: 'application/json', ...opts.headers },
+        });
+        if (!res.ok) {
+            await discardBody(res);
+            return null;
+        }
+        const { text, truncated } = await readTextCapped(res, opts.maxBytes ?? 256 * 1024);
+        if (truncated)
+            return null;
+        return JSON.parse(text);
+    }
+    catch {
+        return null;
+    }
+}
+/** Narrow an unknown JSON value to a plain object (arrays and null excluded). */
+function asRecord(value) {
+    return value !== null && typeof value === 'object' && !Array.isArray(value)
+        ? value
+        : null;
+}
+/** A finite number from an unknown JSON value, else null. */
+function finiteNumber(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : null;
+}
+//# sourceMappingURL=http.js.map

package/dist/cjs/core/pixel-art.js

@@ -0,0 +1,110 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.encodePixelArt = encodePixelArt;
+exports.pixelArtFromPng = pixelArtFromPng;
+exports.pixelDevice = pixelDevice;
+const node_fs_1 = require("node:fs");
+const pngjs_1 = require("pngjs");
+/**
+ * Helpers for custom pixel-art companions (`screenType: 'pixel-device'`): your NPC's own
+ * device, sign or machine, drawn frameless beside it in the office.
+ *
+ * Art is 32 pixels per tile (a 2×3-tile device is 64×96, like the office furniture) and is
+ * sent as `pixel-image` screen data: a palette of up to 255 colours plus one byte per pixel.
+ * Fully transparent pixels (alpha < 128) become see-through, and several frames stacked top
+ * to bottom animate at `fps`. Push a new image whenever its state changes (e.g. an LED turns
+ * red); the server rate-limits pushes, so animate with frames rather than many pushes.
+ */
+/** Largest single screen-data value the API accepts (base64 pixels). */
+const MAX_VALUE = 220_000;
+const MAX_COLORS = 255;
+const MAX_FRAMES = 16;
+/** Encode RGBA frames as `pixel-image` screen data. Throws with a fix-it message. */
+function encodePixelArt(art) {
+    const { width, height, frames } = art;
+    if (!Number.isInteger(width) || !Number.isInteger(height) || width < 1 || height < 1)
+        throw new Error('Pixel art needs a positive whole-number width and height.');
+    if (width > 192 || height > 192)
+        throw new Error(`Pixel art is ${width}×${height}; keep it within 192×192 (6×6 tiles).`);
+    if (frames.length < 1 || frames.length > MAX_FRAMES)
+        throw new Error(`Pixel art needs 1–${MAX_FRAMES} frames (got ${frames.length}).`);
+    const size = width * height;
+    for (const frame of frames)
+        if (frame.length !== size * 4)
+            throw new Error(`Each frame must be ${width}×${height} RGBA (${size * 4} bytes).`);
+    // Index 0 is reserved for transparency when any pixel is see-through.
+    const transparent = frames.some((f) => {
+        for (let i = 3; i < f.length; i += 4)
+            if (f[i] < 128)
+                return true;
+        return false;
+    });
+    const colors = new Map();
+    const palette = transparent ? [0, 0, 0] : [];
+    const pixels = Buffer.alloc(size * frames.length);
+    frames.forEach((frame, f) => {
+        for (let i = 0; i < size; i++) {
+            const r = frame[i * 4], g = frame[i * 4 + 1], b = frame[i * 4 + 2];
+            if (transparent && frame[i * 4 + 3] < 128) {
+                pixels[f * size + i] = 0;
+                continue;
+            }
+            const key = (r << 16) | (g << 8) | b;
+            let index = colors.get(key);
+            if (index === undefined) {
+                index = palette.length / 3;
+                if (index > MAX_COLORS)
+                    throw new Error(`Pixel art uses more than ${MAX_COLORS} colours; reduce the palette (pixel art usually needs 8–32).`);
+                colors.set(key, index);
+                palette.push(r, g, b);
+            }
+            pixels[f * size + i] = index;
+        }
+    });
+    const tokens = [`idx8`, `${width}x${height}`, `p${palette.length / 3}`];
+    if (transparent)
+        tokens.push('t0');
+    if (frames.length > 1) {
+        const fps = Math.min(12, Math.max(1, Math.round(art.fps ?? 4)));
+        tokens.push(`f${frames.length}`, `fps${fps}`);
+    }
+    const encoded = pixels.toString('base64');
+    if (encoded.length > MAX_VALUE)
+        throw new Error('Pixel art is too large to send; use fewer frames or a smaller size.');
+    return {
+        layout: 'pixel-image',
+        values: [
+            { label: 'fmt', value: tokens.join(';') },
+            { label: 'palette', value: Buffer.from(palette).toString('base64') },
+            { label: 'pixels', value: encoded },
+        ],
+    };
+}
+/**
+ * Load a PNG (path or bytes) as pixel-device screen data. For animation, stack frames
+ * top to bottom in one PNG and pass `frameHeight`.
+ */
+function pixelArtFromPng(png, opts = {}) {
+    const image = pngjs_1.PNG.sync.read(typeof png === 'string' ? (0, node_fs_1.readFileSync)(png) : png);
+    const frameHeight = opts.frameHeight ?? image.height;
+    if (frameHeight < 1 || image.height % frameHeight !== 0)
+        throw new Error(`PNG height ${image.height} is not a whole number of ${frameHeight}px frames.`);
+    const frameBytes = image.width * frameHeight * 4;
+    const frames = [];
+    for (let offset = 0; offset < image.data.length; offset += frameBytes)
+        frames.push(image.data.subarray(offset, offset + frameBytes));
+    return encodePixelArt({ width: image.width, height: frameHeight, frames, fps: opts.fps });
+}
+/**
+ * Companion declaration for a pixel device: `size` in tiles (art is 32px per tile).
+ * Freestanding by default so it sits on the floor next to the NPC's home.
+ */
+function pixelDevice(opts) {
+    return {
+        screenType: 'pixel-device',
+        size: { w: opts.w, h: opts.h },
+        placement: opts.placement ?? 'freestanding',
+        ...(opts.label ? { label: opts.label } : {}),
+    };
+}
+//# sourceMappingURL=pixel-art.js.map

package/dist/cjs/core/polling-npc.js

@@ -1,17 +1,34 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PollingNPC = void 0;
+exports.PollingNPC = exports.MIN_POLL_INTERVAL_MS = void 0;
 const base_npc_js_1 = require("./base-npc.js");
+/**
+ * Lower bound for any poll interval, so a typo can't exhaust the API's
+ * per-service rate limit (60 pushes/min) or hammer the watched source.
+ */
+exports.MIN_POLL_INTERVAL_MS = 5000;
+/** How long `stop()` waits for an in-flight collection before pushing offline anyway. */
+const STOP_DRAIN_TIMEOUT_MS = 10_000;
 function clamp(n, min, max) {
     return Math.min(max, Math.max(min, n));
 }
 class PollingNPC extends base_npc_js_1.BaseNPC {
     timer = null;
-    collecting = false;
+    keepaliveTimer = null;
+    /** The running collection + push, if any (awaited by `onStop`). */
+    inflight = null;
+    /** A `collectNow()` arrived while a collection was in flight: run once more after it. */
+    rerunRequested = false;
+    /** The last successfully pushed cycle, replayed (without its screen) by the keepalive. */
+    lastPushed = null;
+    lastPushAt = 0;
     pollInterval;
     constructor(config) {
         super(config);
-        this.pollInterval = config.pollInterval ?? 15000;
+        const requested = config.pollInterval ?? 15000;
+        this.pollInterval = Number.isFinite(requested)
+            ? Math.max(exports.MIN_POLL_INTERVAL_MS, requested)
+            : 15000;
     }
     /** Scale staleness to the poll cadence: the server marks unknown at ~2x the interval. */
     get heartbeatSeconds() {
@@ -20,14 +37,22 @@ class PollingNPC extends base_npc_js_1.BaseNPC {
     async onStart() {
         // Collect immediately on start
         await this.runCollection();
+        // Stopped while the first collection ran: don't arm timers nobody will clear.
+        if (this.state !== 'running')
+            return;
         // Then on interval
         this.timer = setInterval(() => {
             void this.runCollection();
         }, this.pollInterval);
-        // For slow pollers, keep the NPC alive with a lightweight heartbeat between
-        // collections so it never falsely goes stale mid-interval.
-        if (this.pollInterval > 60_000) {
-            this.client.startHeartbeat(30_000);
+        // Only very slow pollers (> heartbeatSeconds, i.e. > 30 min given the clamp)
+        // could go stale between collections. Keep them alive by replaying the
+        // last cycle. The SDK's own heartbeat is not used: it omits `map`, `name`
+        // and `alertConfig`, so it would spawn a twin on the team's default map.
+        const heartbeatMs = this.heartbeatSeconds * 1000;
+        if (this.pollInterval > heartbeatMs) {
+            this.keepaliveTimer = setInterval(() => {
+                void this.keepalive(heartbeatMs);
+            }, heartbeatMs);
         }
     }
     async onStop() {
@@ -35,29 +60,89 @@ class PollingNPC extends base_npc_js_1.BaseNPC {
             clearInterval(this.timer);
             this.timer = null;
         }
-        this.client.stopHeartbeat();
+        if (this.keepaliveTimer) {
+            clearInterval(this.keepaliveTimer);
+            this.keepaliveTimer = null;
+        }
+        this.rerunRequested = false;
+        // Let an in-flight push land before the offline push, so it can't arrive
+        // afterwards and respawn the NPC. Bounded: a hung collector never blocks exit.
+        if (this.inflight) {
+            let timeout;
+            await Promise.race([
+                this.inflight,
+                new Promise((resolve) => {
+                    timeout = setTimeout(resolve, STOP_DRAIN_TIMEOUT_MS);
+                }),
+            ]);
+            clearTimeout(timeout);
+        }
     }
-    async runCollection() {
+    /**
+     * Collect and push now instead of waiting for the next tick — for NPCs that
+     * also react to events (e.g. a fresh error line). Coalesces: if a collection
+     * is already running, exactly one more runs after it.
+     */
+    collectNow() {
         if (this.state !== 'running')
             return;
+        if (this.inflight) {
+            this.rerunRequested = true;
+            return;
+        }
+        void this.runCollection();
+    }
+    runCollection() {
+        if (this.state !== 'running')
+            return Promise.resolve();
         // Overlap guard: if a slow collector is still running, skip this tick rather
         // than stacking collections (load-bearing for screenshot/render collectors).
-        if (this.collecting) {
+        if (this.inflight) {
             this.logger.debug('Previous collection still in flight, skipping this tick');
-            return;
+            return this.inflight;
         }
-        this.collecting = true;
+        const run = this.collectAndPush().finally(() => {
+            this.inflight = null;
+            if (this.rerunRequested && this.state === 'running') {
+                this.rerunRequested = false;
+                void this.runCollection();
+            }
+        });
+        this.inflight = run;
+        return run;
+    }
+    async collectAndPush() {
         try {
             const metrics = await this.collect();
+            // Stopped mid-collection: never push after (or race) the offline push.
+            if (this.state !== 'running')
+                return;
             await this.pushMetrics(metrics);
+            this.lastPushed = metrics;
+            this.lastPushAt = Date.now();
         }
         catch (err) {
+            if (this.state !== 'running')
+                return; // teardown aborted the collector
             this.logger.error('Collection failed', {
                 error: err instanceof Error ? err.message : String(err),
             });
         }
-        finally {
-            this.collecting = false;
+    }
+    /** Replay the last cycle (minus its screen, which the server keeps) if nothing was pushed recently. */
+    async keepalive(heartbeatMs) {
+        if (this.state !== 'running' || this.inflight || !this.lastPushed)
+            return;
+        if (Date.now() - this.lastPushAt < heartbeatMs / 2)
+            return;
+        try {
+            await this.pushMetrics({ ...this.lastPushed, screenData: undefined });
+            this.lastPushAt = Date.now();
+        }
+        catch (err) {
+            this.logger.debug('Keepalive push failed', {
+                error: err instanceof Error ? err.message : String(err),
+            });
         }
     }
 }

package/dist/cjs/core/session-filter.js

@@ -113,7 +113,9 @@ function projectMatches(pattern, projectDir) {
         const re = globRegExp(pattern, false);
         return dir.split('/').some((segment) => segment && re.test(segment));
     }
-    const expanded = normalizePath(pattern.startsWith('~') ? (0, node_os_1.homedir)() + pattern.slice(1) : pattern);
+    // A trailing `/*` or `/**` means "this folder and everything in it": subfolders already
+    // match through their ancestors, so drop it and the folder itself matches too.
+    const expanded = normalizePath((pattern.startsWith('~') ? (0, node_os_1.homedir)() + pattern.slice(1) : pattern).replace(/(\/\*{1,2})+$/, ''));
     const re = globRegExp(expanded, true);
     // The directory itself or any ancestor: a rule for a folder covers its subfolders.
     for (let p = dir; p; p = p.includes('/') ? p.slice(0, p.lastIndexOf('/')) : '') {

package/dist/cjs/core/text.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.truncate = truncate;
+exports.sanitizeText = sanitizeText;
 /**
  * Truncate a string to at most `max` characters, appending an ellipsis when cut.
  * Used to keep messages and screen lines within API limits.
@@ -12,4 +13,16 @@ function truncate(s, max = 200) {
         return s.slice(0, Math.max(0, max));
     return s.slice(0, max - 1) + '…';
 }
+// C0/C1 controls (incl. ESC, so no terminal escapes) plus the bidi overrides,
+// isolates and marks that can visually reorder text on a banner.
+// eslint-disable-next-line no-control-regex
+const UNSAFE_CHARS = /[\u0000-\u0008\u000B-\u001F\u007F-\u009F؜‎‏‪-‮⁦-⁩]/g;
+/**
+ * Make untrusted remote text (commit messages, page titles, log lines) safe to
+ * display: drop control and bidi-override characters, collapse whitespace
+ * (including newlines and tabs) to single spaces, trim, and truncate.
+ */
+function sanitizeText(s, max = 200) {
+    return truncate(s.replace(UNSAFE_CHARS, '').replace(/\s+/g, ' ').trim(), max);
+}
 //# sourceMappingURL=text.js.map

package/dist/cjs/core/thresholds.js

@@ -2,6 +2,8 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.evaluateThreshold = evaluateThreshold;
 exports.worstStatus = worstStatus;
+exports.moodForStatus = moodForStatus;
+exports.thresholdProblem = thresholdProblem;
 /**
  * Evaluate a numeric value against thresholds to determine status.
  */
@@ -45,4 +47,31 @@ function worstStatus(statuses) {
     }
     return worst;
 }
+/** The NPC mood that matches a status (drives the NPC's demeanour and emotes). */
+function moodForStatus(status) {
+    switch (status) {
+        case 'healthy':
+            return 'happy';
+        case 'warning':
+            return 'concerned';
+        case 'critical':
+            return 'stressed';
+        default:
+            return 'idle';
+    }
+}
+/**
+ * Validate a warning/critical pair from user flags: both finite, and critical
+ * at least as severe as warning for the threshold's direction. Returns an error
+ * message, or null when the pair is usable.
+ */
+function thresholdProblem(label, t) {
+    if (!Number.isFinite(t.warning) || !Number.isFinite(t.critical)) {
+        return `${label}: thresholds must be numbers`;
+    }
+    const inverted = (t.direction ?? 'above') === 'above' ? t.critical < t.warning : t.critical > t.warning;
+    return inverted
+        ? `${label}: critical (${t.critical}) must be at least as severe as warning (${t.warning})`
+        : null;
+}
 //# sourceMappingURL=thresholds.js.map

package/dist/cjs/index.js

@@ -1,7 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.geminiServiceId = exports.geminiTransition = exports.GEMINI_ADAPTER = exports.GEMINI_DEFAULTS = exports.WebPageWatcherNPC = exports.GitHubWatcherNPC = exports.ReceptionistNPC = exports.LogWatcherNPC = exports.ProcessWatcherNPC = exports.InternetConnectivityNPC = exports.ensureSessionFilterTemplate = exports.sessionPublishDecision = exports.sessionFilterPath = exports.loadSessionFilter = exports.userConfigPath = exports.saveUserConfig = exports.loadUserConfig = exports.redactSecrets = exports.shortPath = exports.shortCommand = exports.describeToolUse = exports.CodexWatcher = exports.parseRolloutLine = exports.uninstallCodexHooks = exports.setupCodexHooks = exports.codexTransition = exports.handleCodexHookEvent = exports.handleCodexCommand = exports.claudeTransition = exports.processHookEvent = exports.uninstallHooks = exports.setupHooks = exports.handleHookEvent = exports.handleClaudeCodeCommand = exports.ClaudeCodeNPC = exports.SystemMonitorNPC = exports.pushHistory = exports.statusColor = exports.truncate = exports.worstStatus = exports.evaluateThreshold = exports.numberFlag = exports.boolFlag = exports.stringFlag = exports.resolveConfig = exports.parseArgs = exports.Logger = exports.EventNPC = exports.PollingNPC = exports.BaseNPC = void 0;
-exports.normalizeCursorEvent = exports.isCursorInvocation = exports.CURSOR_HOOK_EVENTS = exports.installCursorHooksInto = exports.uninstallCursorHooks = exports.setupCursorHooks = exports.handleCursorHookEvent = exports.cursorServiceId = exports.CURSOR_ADAPTER = exports.CURSOR_DEFAULTS = exports.GEMINI_HOOK_EVENTS = exports.installGeminiHooksInto = exports.uninstallGeminiHooks = exports.setupGeminiHooks = exports.handleGeminiHookEvent = void 0;
+exports.ReceptionistNPC = exports.LogWatcherNPC = exports.ProcessWatcherNPC = exports.InternetConnectivityNPC = exports.ensureSessionFilterTemplate = exports.sessionPublishDecision = exports.sessionFilterPath = exports.loadSessionFilter = exports.pixelDevice = exports.pixelArtFromPng = exports.encodePixelArt = exports.userConfigPath = exports.saveUserConfig = exports.loadUserConfig = exports.redactSecrets = exports.shortPath = exports.shortCommand = exports.describeToolUse = exports.CodexWatcher = exports.parseRolloutLine = exports.uninstallCodexHooks = exports.setupCodexHooks = exports.codexTransition = exports.handleCodexHookEvent = exports.handleCodexCommand = exports.claudeTransition = exports.processHookEvent = exports.uninstallHooks = exports.setupHooks = exports.handleHookEvent = exports.handleClaudeCodeCommand = exports.ClaudeCodeNPC = exports.SystemMonitorNPC = exports.pushHistory = exports.statusColor = exports.NpcConfigError = exports.sanitizeText = exports.truncate = exports.moodForStatus = exports.worstStatus = exports.evaluateThreshold = exports.numberFlag = exports.boolFlag = exports.stringFlag = exports.resolveConfig = exports.parseArgs = exports.Logger = exports.EventNPC = exports.PollingNPC = exports.BaseNPC = void 0;
+exports.normalizeCursorEvent = exports.isCursorInvocation = exports.CURSOR_HOOK_EVENTS = exports.installCursorHooksInto = exports.uninstallCursorHooks = exports.setupCursorHooks = exports.handleCursorHookEvent = exports.cursorServiceId = exports.CURSOR_ADAPTER = exports.CURSOR_DEFAULTS = exports.GEMINI_HOOK_EVENTS = exports.installGeminiHooksInto = exports.uninstallGeminiHooks = exports.setupGeminiHooks = exports.handleGeminiHookEvent = exports.geminiServiceId = exports.geminiTransition = exports.GEMINI_ADAPTER = exports.GEMINI_DEFAULTS = exports.WebPageWatcherNPC = exports.GitHubWatcherNPC = void 0;
 // Core
 var base_npc_js_1 = require("./core/base-npc.js");
 Object.defineProperty(exports, "BaseNPC", { enumerable: true, get: function () { return base_npc_js_1.BaseNPC; } });
@@ -20,8 +20,12 @@ Object.defineProperty(exports, "numberFlag", { enumerable: true, get: function (
 var thresholds_js_1 = require("./core/thresholds.js");
 Object.defineProperty(exports, "evaluateThreshold", { enumerable: true, get: function () { return thresholds_js_1.evaluateThreshold; } });
 Object.defineProperty(exports, "worstStatus", { enumerable: true, get: function () { return thresholds_js_1.worstStatus; } });
+Object.defineProperty(exports, "moodForStatus", { enumerable: true, get: function () { return thresholds_js_1.moodForStatus; } });
 var text_js_1 = require("./core/text.js");
 Object.defineProperty(exports, "truncate", { enumerable: true, get: function () { return text_js_1.truncate; } });
+Object.defineProperty(exports, "sanitizeText", { enumerable: true, get: function () { return text_js_1.sanitizeText; } });
+var errors_js_1 = require("./core/errors.js");
+Object.defineProperty(exports, "NpcConfigError", { enumerable: true, get: function () { return errors_js_1.NpcConfigError; } });
 var screen_js_1 = require("./core/screen.js");
 Object.defineProperty(exports, "statusColor", { enumerable: true, get: function () { return screen_js_1.statusColor; } });
 Object.defineProperty(exports, "pushHistory", { enumerable: true, get: function () { return screen_js_1.pushHistory; } });
@@ -53,6 +57,10 @@ var user_config_js_1 = require("./core/user-config.js");
 Object.defineProperty(exports, "loadUserConfig", { enumerable: true, get: function () { return user_config_js_1.loadUserConfig; } });
 Object.defineProperty(exports, "saveUserConfig", { enumerable: true, get: function () { return user_config_js_1.saveUserConfig; } });
 Object.defineProperty(exports, "userConfigPath", { enumerable: true, get: function () { return user_config_js_1.userConfigPath; } });
+var pixel_art_js_1 = require("./core/pixel-art.js");
+Object.defineProperty(exports, "encodePixelArt", { enumerable: true, get: function () { return pixel_art_js_1.encodePixelArt; } });
+Object.defineProperty(exports, "pixelArtFromPng", { enumerable: true, get: function () { return pixel_art_js_1.pixelArtFromPng; } });
+Object.defineProperty(exports, "pixelDevice", { enumerable: true, get: function () { return pixel_art_js_1.pixelDevice; } });
 var session_filter_js_1 = require("./core/session-filter.js");
 Object.defineProperty(exports, "loadSessionFilter", { enumerable: true, get: function () { return session_filter_js_1.loadSessionFilter; } });
 Object.defineProperty(exports, "sessionFilterPath", { enumerable: true, get: function () { return session_filter_js_1.sessionFilterPath; } });

package/dist/cjs/npcs/agent-common/session.js

@@ -244,6 +244,7 @@ function buildAgentPayload(adapter, state, config) {
         name,
         message: current ? (0, text_js_1.truncate)(current, 120) : undefined,
         archetype: 'ai-agent',
+        kind: adapter.command,
         metrics: { sessionStartedAt: state.startedAt ?? state.lastUpdate },
         appearance: { family: adapter.family },
         agentStats: state.agentStats,

package/dist/cjs/npcs/github-watcher/defaults.js

@@ -2,10 +2,16 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.DEFAULTS = void 0;
 exports.DEFAULTS = {
-    pollInterval: 60000, // 60s
+    pollInterval: 60000, // 60s with a token
+    /** Without a token GitHub allows 60 requests/hour (304s included): poll every 90s. */
+    unauthenticatedPollInterval: 90000,
     fetchTimeoutMs: 5000,
     perPage: 10,
+    /** Commit rows on the board (plus a header row). */
+    boardRows: 8,
     /** Polls to keep the 'new-commit' sub-status active after a fresh commit. */
     newCommitPolls: 2,
+    /** Consecutive network/5xx failures tolerated (board kept, healthy) before warning. */
+    failuresBeforeWarning: 3,
 };
 //# sourceMappingURL=defaults.js.map