Merge pull request 'LLM timeout default 60 s → 180 s (v0.21.4)' (#47 ) from fix/llm-timeout into main

LLM_TIMEOUT_MS default 60 s -> 3 min (v0.21.4)
Production incident: '#rss get lublin' at 9:41 AM failed with 'The operation was aborted due to timeout' — the LlmService call hit its 60 s cap while the local OpenAI-compatible server (qwen3.8-27b, uncontrollable reasoning tokens) was slow/busy. The same endpoint answers a trivial prompt in ~1 s when idle, so this is latency variance on the server side, not a dead endpoint. Bump the LLM_TIMEOUT_MS fallback from 60000 to 180000 (3 min headroom for slow reasoning periods); still env-overridable, only the default changed.
2026-09-26 11:55:54 +02:00 · 2026-09-26 09:52:18 +00:00 · 2026-09-26 11:37:41 +02:00 · 2026-09-26 09:34:30 +00:00 · 2026-09-26 10:53:28 +02:00 · 2026-09-26 08:50:27 +00:00
18 changed files with 1477 additions and 32 deletions
@@ -12,7 +12,7 @@
 ## Verification
 1. **Local checks** — `npm run build` (nest build) and `npm test` (vitest; no e2e suite yet). Both must pass before a PR is opened.
-2. **Docker** — `docker compose build`, then after `docker compose up -d`: `curl -s -H "Host: bot.dev.kkhost.pl" http://localhost/api/status` returns JSON (`{ connected, myNodeNum, host, port }`). `"connected":false` is normal while the bridge/device is down — the service retries every 5 s.
+2. **Docker** — `docker compose build`, then after `docker compose up -d`: `curl -s -H "Host: bot.dev.kkhost.pl" http://localhost/api/status` returns JSON (`{ connected, myNodeNum, host, port }`). `"connected":false` is normal while the bridge/device is down — the service retries every 5 s. An idle watchdog also force-reconnects an ESTABLISHED-but-silent connection (zombie bridge: outbound works, inbound dead) when no DECODED FRAME arrives from the bridge for `MESH_IDLE_TIMEOUT_MS` ms (default 60000 = 1 min; checked every 30 s — raw non-frame bytes do NOT count), an undecoded frame buffer over `MESH_MAX_FRAME_BUFFER` bytes (default 256000) forces a reconnect as a stream-desync backstop, and the socket has TCP keepalive enabled (30 s). A lazy periodic autoreconnect additionally unconditionally re-establishes every `MESH_RECONNECT_INTERVAL_MS` ms (default 300000 = 5 min) for a fresh sync.
 ## API
@@ -27,5 +27,5 @@
 - MESHTASTIC.md — rules for Meshtastic communication (owner authority, language, response protocol); read before acting on mesh messages.
 - Hourly cron weather report job (`src/weather`): fetches Open-Meteo current conditions and broadcasts a one-line report to the mesh on the pinned send channel; env `WEATHER_CRON`/`WEATHER_LAT`/`WEATHER_LON`/`WEATHER_CITY`.
- Channel-2 auto-responder (`src/commands`): event-driven — `CommandService.onRx()` is called by `MeshService` for every decoded rx text (right after the notify gate) and dispatches exact, case-sensitive `#command` matches on `COMMAND_CHANNEL` (env, default 2) through a single-registration-point registry (handlers registered in the constructor via `register(name, fn)`; handler gets `{ text, from?, id? }`, returns reply string or void = no reply). First command: `#ping` → replies `#pong!`. Replies go through `MeshService.respond(id, reply)`: auto-routed (rx → DM back to the original sender unless the original was a broadcast; tx → its destination), riding the original record's channel with `replyId = id` so the recipient app renders it as a threaded quote — `COMMAND_CHANNEL` is only the trigger/listen gate. Only when the trigger has no packet id does it fall back to legacy sendText routing on `COMMAND_CHANNEL`. A failing handler/respond only logs a warn. DI: provided by `CommandModule`'s factory (injects `MeshService`, attaches itself via `attachCommands()`) — no constructor-level cycle; `forwardRef` was tried and left one side null in NestJS 12's injector.
+- Channel-2 auto-responder (`src/commands`): event-driven — `CommandService.onRx()` is called by `MeshService` for every decoded rx text (right after the notify gate) and dispatches exact, case-sensitive `#command` matches on `COMMAND_CHANNEL` (env, default 2) through a single-registration-point registry (handlers registered in the constructor via `register(name, fn)`; handler gets `{ text, from?, id? }`, returns a reply string — or an array of lines, sent as one message per line through the same routing — or void = no reply). First command: `#ping` → replies `#pong!`. Replies go through `MeshService.respond(id, reply)`: auto-routed (rx → DM back to the original sender unless the original was a broadcast; tx → its destination), riding the original record's channel with `replyId = id` so the recipient app renders it as a threaded quote — `COMMAND_CHANNEL` is only the trigger/listen gate. Only when the trigger has no packet id does it fall back to legacy sendText routing on `COMMAND_CHANNEL`. A failing handler/respond only logs a warn. DI: provided by `CommandModule`'s factory (injects `MeshService`, attaches itself via `attachCommands()`) — no constructor-level cycle; `forwardRef` was tried and left one side null in NestJS 12's injector. Prefix dispatch (`registerPrefix(name, fn)`) lets one handler own a whole family: the `#rss` subcommands live in `src/rss` (`RssService.handle`, registered as prefix `'rss'` from the CommandModule factory — exact matches still win over prefixes). Subcommands: `#rss help`; `#rss add <url> <name>` (validates URL, fetches with 15 s timeout, requires ≥1 titled item, rejects duplicate names case-insensitively; LLM generates 2-4 lowercase tags from up to 8 latest titles — on LLM failure the source is added with empty tags and the reply says so); `#rss remove <name>`; `#rss tags` (all distinct tags); `#rss sources`; `#rss get <name|#tag>` (LLM headline summary as 3-5 SEPARATE mesh messages: prompt asks for exactly 3-5 lines, one item per line, `<short header>: <one or two short sentences>` with ≤20-char header, no intro/outro/numbering; reply parsed into items — drop empty/separator-less lines, cap at 5, fewer than 3 → send what we got (no retry), zero → no message; each item sent via its own respond() threaded to the trigger packet id, per-line backstop `fitOneLine()` hard-cuts >185-char lines at a word boundary near 180 so every item fits one packet; maxTokens 2500 is headroom because the LLM server's reasoning tokens count against it — see rss.service.ts comment; `#tag` collects items across ALL sources carrying that tag — one dead feed does not sink the summary). Storage: `rss_sources(name TEXT PRIMARY KEY, url, tags, created_at)` table in the EXISTING MESH_DB_PATH file via a second node:sqlite connection (names matched case-insensitively); feed parsing via `fast-xml-parser` (RSS 2.0 + Atom; malformed/no-items → "not a valid feed"); LLM via injected `LlmService.chat()` with explicit maxTokens (50 tags / 2500 summary headroom).
- LLM client (`src/llm`): `LlmService` wraps the local OpenAI-compatible server (default `http://192.168.1.70:1111/v1`, no auth) with native fetch — plain feature module, no Mesh/Schedule dependency. Methods: `listModels()` → `data[].id`; `chat(messages, { maxTokens?, temperature? })` → `choices[0].message.content` (non-2xx throws with status + body snippet); `summarize(text)` = chat() with system prompt "Summarize the following text concisely." Env: `LLM_API_BASE`, `LLM_MODEL` (default `qwen3.8-27b`), `LLM_TIMEOUT_MS` (default 60000, via `AbortSignal.timeout`).
+- LLM client (`src/llm`): `LlmService` wraps the local OpenAI-compatible server (default `http://192.168.1.70:1111/v1`, no auth) with native fetch — plain feature module, no Mesh/Schedule dependency. Methods: `listModels()` → `data[].id`; `chat(messages, { maxTokens?, temperature? })` → `choices[0].message.content` (non-2xx throws with status + body snippet); `summarize(text)` = chat() with system prompt "Summarize the following text concisely." Env: `LLM_API_BASE`, `LLM_MODEL` (default `qwen3.8-27b`), `LLM_TIMEOUT_MS` (default 180000, via `AbortSignal.timeout`).
@@ -1,5 +1,53 @@
 # Changelog
 ## v0.21.4 — 2026-09-26 09:51
 - `LLM_TIMEOUT_MS` default raised from 60000 (60 s) to **180000** (3 min): production incident — `#rss get lublin` at 9:41 AM failed with "The operation was aborted due to timeout" because the local OpenAI-compatible server (qwen3.8-27b, uncontrollable reasoning tokens) was slow/busy on that call; the same endpoint answers a trivial prompt in ~1 s when idle, so this is latency variance, not a dead endpoint. Still env-overridable (`LLM_TIMEOUT_MS`), only the fallback changed.
 ## v0.21.3 — 2026-09-26 09:31
 - Idle timeout default lowered from 10 min to **1 min** (`MESH_IDLE_TIMEOUT_MS` fallback `600000` → `60000`) — the v0.21.2 frame-based watchdog works in production (it fired today and the reconnect delivered queued packets), but the bridge/radio side at 192.168.1.4 keeps killing inbound RX within ~20 min of a fresh sync, so a shorter detection window is wanted.
 - New **lazy periodic autoreconnect**: `MESH_RECONNECT_INTERVAL_MS` (new env, default **300000** = 5 min, read at construction) — an interval that unconditionally logs ("periodic reconnect — MESH_RECONNECT_INTERVAL_MS elapsed") and destroys the socket so the existing close→scheduleReconnect loop re-establishes with a fresh sync on schedule. When not connected at tick time, destroy is a no-op and the retry loop owns recovery (no special-casing). Started in `onModuleInit`, cleared in `onModuleDestroy`.
 - Tests: 171 → 172 — periodic reconnect observed end-to-end with an overridden short interval (fake bridge disconnect + re-establish); existing watchdog tests pass unchanged, comments updated to the new 60 s default.
 ## v0.21.2 — 2026-09-26 08:47
 - Idle watchdog now tracks DECODED FRAMES, not raw bytes (fixes a second production zombie that slipped past v0.21.1): text+telemetry RX was dead for >1 h while TX worked and the watchdog never fired — /proc/net/snmp showed InSegs delta = 2 segments per 30 s, i.e. the bridge peer keeps dribbling small NON-frame bytes (~every 15 s) that kept resetting `lastPacketAt` on every socket chunk even though zero valid Meshtastic frames decoded. The `'data'` handler no longer updates `lastPacketAt` per chunk; it is updated only when `extractFrames` yields ≥1 valid packet (the reset in the `'connect'` handler is unchanged), so a stream that decodes nothing trips the watchdog after `MESH_IDLE_TIMEOUT_MS` even while raw bytes keep arriving.
 - Buffer-overflow backstop: if the undecoded frame buffer exceeds `MESH_MAX_FRAME_BUFFER` (new env, default **256000** = 250 KB) the service logs ERROR ("frame buffer overflow — stream desync, forcing reconnect") and destroys the socket → existing close→scheduleReconnect self-heals a desynced stream. The undecoded buffer is also reset on every (re)connect so leftover garbage from a dead session can't re-trigger the backstop or corrupt the first frames of a healthy new stream.
 - Tests: 169 → 171 — raw non-frame bytes do NOT keep the watchdog alive (garbage-only stream forces disconnect + reconnect, exactly today's incident shape), and an undecoded chunk over `MESH_MAX_FRAME_BUFFER` triggers destroy + a fresh session that decodes normally. The existing valid-frames-reset-the-clock test now exercises frame-based tracking unchanged.
 ## v0.21.1 — 2026-09-26 06:47
 - Bridge zombie-connection fix (production incident: outbound sends kept working ~10 h while inbound packets stopped entirely and `/api/status` stayed `connected:true`). New **idle watchdog**: the service tracks `lastPacketAt`, updated on EVERY chunk received from the bridge in the lowest-level socket `'data'` path (any frame kind, decodable or not) and reset when a connection successfully starts. A 30 s interval checks: if connected AND no inbound traffic for `MESH_IDLE_TIMEOUT_MS` (new env, default **600000** = 10 min), it logs WARN ("no bridge traffic for X ms — forcing reconnect") and destroys the socket — the EXISTING connect/retry loop (`MESH_RECONNECT_MS`) then re-establishes with a fresh sync. No changes to connect-error retry/backoff behavior; this only adds detection for established-but-silent connections.
 - TCP keepalive on the bridge socket: `socket.setKeepAlive(true, 30_000)` — cheap insurance against dead peers at the TCP level, complementing the application-level watchdog.
 - Tests: 165 → 169 — silence past an overridden timeout forces disconnect + reconnect (fake bridge), inbound traffic keeps resetting the idle clock so no false trigger, default timeout does not fire in a test window, and `setKeepAlive(true, 30_000)` is asserted on the socket.
 ## v0.21.0 — 2026-09-25 19:59
 - `#rss get <name|#tag>` now replies with **3–5 SEPARATE mesh messages** instead of one small summary (owner request: the single-message summary was too small). Each item is its own packet, so no fragmentation — and each rides the trigger's channel threaded as a quote of the command packet.
 - New summarizer prompt asks for exactly 3-5 lines, one item per line, format `<short header>: <one or two short sentences>` with a ≤20-char header (e.g. `Culture: Museum opens new wing`), no intro/outro/numbering. maxTokens stays 2500 (reasoning-token headroom — see v0.20.1).
 - The LLM reply is parsed into items: split on newlines, trim, drop empty lines and lines without a `:` header separator, cap at 5. Fewer than 3 valid lines → send what we got (no failure, no retry — the model is non-deterministic); zero valid lines → no message sent.
 - Per-item backstop replaces the old whole-reply cut: any single line >185 chars is hard-cut at a word boundary near 180 (`fitOneLine`), so every item fits one packet even if the model ignores the prompt. `fitOnePacket()` (whole-reply ≤190) is gone — it no longer applies to joined text.
 - CommandService now sends array replies line by line: each element goes through the same routing as a single reply (`respond(id, line)` threaded to the trigger packet id; legacy sendText fallback per line when there is no packet id). A failing send stops the remaining lines (warn log), like any failed command.
 - LLM failure path unchanged: single `summary failed` reply via respond(). `#rss get #tag` gets the same multi-message treatment automatically (shared summary path — covered by tests). All other subcommands unchanged.
 - Tests: 158 → 165 — prompt shape + maxTokens asserted on the new call, 5-item cap, invalid-line filtering, fewer-than-3 fallback, per-line over-length cut through `handle()`, direct `parseSummaryItems`/`fitOneLine` specs, and CommandService array-reply routing (threaded respond ×N to one packet id; legacy sendText fallback).
 ## v0.20.1 — 2026-09-25 19:20
 - `#rss get` summaries now fit ONE mesh packet (≤190 chars). Mesh fragments longer replies into fire-and-forget packets that recipients frequently never receive, and the old prompt ("a few short one-line highlights") produced ~326-334 char replies.
 - The summary prompt now asks for "at most 3 short bullet lines, each under 45 characters … bullets only - no intro, no other text" (verified against the live LLM: exactly 3 compliant bullets, ~110 chars). A `fitOnePacket()` backstop additionally cuts any over-length reply at complete-bullet boundaries so delivery is one packet even if the model ignores the prompt.
 - The summary `chat()` call now uses an explicit `maxTokens = 2500` (was 200). Empirically verified on this server: qwen3.8-27b emits `reasoning_content` and those tokens COUNT against max_tokens (cap 150 → completion_tokens 150, of which 105 were reasoning, finish_reason 'length'; a cap of 500 was fully consumed by reasoning with zero visible content). Thinking length for this task is unbounded and uncontrollable server-side (`/no_think`, `chat_template_kwargs.enable_thinking` and `thinking_budget` are all ignored) — observed 32..1776 tokens across runs. 2500 covers every observed run plus ~80 content tokens, and keeps the worst case (~42 s at ~60 tok/s) under the 60 s LLM timeout. The old cap of 200 guaranteed empty replies whenever reasoning exceeded it.
 - Tests: 154 → 158 — prompt shape + maxTokens asserted on the summary call, over-length reply cut through `handle()`, and direct `fitOnePacket` specs (pass-through at/under 190, bullet-boundary cut, hard-cut fallback for non-bulleted paragraphs).
 ## v0.20.0 — 2026-09-25 18:40
 - New `#rss` command family on the command channel (ch2): `#rss help`, `#rss add <url> <name>` (validates URL + fetches with a 15 s timeout, requires ≥1 item with a non-empty title, rejects duplicate names case-insensitively; tags are generated by the LLM from up to 8 latest titles — on LLM failure the source is still added with empty tags and the reply says so), `#rss remove <name>`, `#rss tags` (all distinct tags), `#rss sources`, `#rss get <name>` and `#rss get #<tag>` (LLM headline summary, maxTokens 200; tag form collects items across ALL sources carrying the tag — one dead feed does not sink the summary). Bare `#rss` / unknown subcommand → help. All replies ride the existing respond() path like `#ping`.
 - Storage: new `rss_sources(name TEXT PRIMARY KEY, url, tags, created_at)` table in the EXISTING MESH_DB_PATH file (default ./data/mesh-bot.db) via a second node:sqlite connection opened by `RssModule`'s factory — no new DB file. Names are matched case-insensitively everywhere (`COLLATE NOCASE`).
 - Feed parsing: new dependency `fast-xml-parser` (the only one added for this feature) — RSS 2.0 (`<item><title>/<link>`) and Atom (`<entry><title>`, link as `href` attribute); CDATA titles supported; malformed input or no usable items → "not a valid feed".
 - LLM: `RssService` injects `LlmService` (plain DI, one-way — `RssModule` imports `LlmModule`) and uses `chat()` directly with explicit maxTokens (50 for tags, 200 for summaries) to keep mesh replies short. Tag output is sanitized (lowercase, no #, whitespace → '-', deduped).
 - Dispatch: `CommandService` gains prefix registration (`registerPrefix(name, fn)`) alongside exact matches — one handler owns the whole `#rss` family while `#ping` stays an untouched exact match; exact names win over prefixes, and a name merely starting with the prefix (e.g. `#rssfoo`) does not dispatch. Wired in `CommandModule`'s factory (`inject: [MeshService, RssService]`) — still no constructor-level cycle, no forwardRef.
 - Tests: 128 → 153 specs — store CRUD against a real temp SQLite file (incl. second-connection persistence), feed parser fixtures (RSS 2.0 / Atom / malformed / empty titles), handler behavior with mocked LLM + fetch (help, add success/LLM-fail/invalid-url/duplicate/non-2xx/unparseable, remove found/missing, tags/sources empty+populated, get by name/by tag across sources/dead-feed resilience/unknown name+tag), and `#rss` prefix dispatch through respond().
 ## v0.19.0 — 2026-09-25 18:03
 - New LLM client module (`src/llm`): `LlmService` speaks the OpenAI-compatible chat-completions API of the local server at `LLM_API_BASE` (default `http://192.168.1.70:1111/v1`, no auth) using native fetch only — no new dependencies. Plain feature module (`LlmModule`), wired into `app.module.ts`; no Mesh/Schedule dependency.
@@ -1,12 +1,12 @@
 {
  "name": "mesh-bot",
-  "version": "0.11.3",
+  "version": "0.19.0",
  "lockfileVersion": 3,
  "requires": true,
  "packages": {
    "": {
      "name": "mesh-bot",
-      "version": "0.11.3",
+      "version": "0.19.0",
      "license": "UNLICENSED",
      "dependencies": {
        "@bufbuild/protobuf": "^2.15.0",
@@ -18,6 +18,7 @@
        "@nestjs/schedule": "^12.0.2",
        "@nestjs/swagger": "^12.0.2",
        "@scalar/nestjs-api-reference": "^1.2.21",
        "fast-xml-parser": "^5.11.1",
        "reflect-metadata": "^0.2.2",
        "rxjs": "^7.8.1"
      },
@@ -1148,6 +1149,18 @@
        "url": "https://paulmillr.com/funding/"
      }
    },
    "node_modules/@nodable/entities": {
      "version": "3.0.0",
      "resolved": "https://registry.npmjs.org/@nodable/entities/-/entities-3.0.0.tgz",
      "integrity": "sha512-8L9xFeTYKhm49xfIypoe2W5wV1m/3Z58kT+7kR9A8OyFxcPduI4VmxaUMQyKYrRjUoLLSXv6EKKID5Tvj9cUVw==",
      "funding": [
        {
          "type": "github",
          "url": "https://github.com/sponsors/nodable"
        }
      ],
      "license": "MIT"
    },
    "node_modules/@oxc-project/types": {
      "version": "0.151.0",
      "resolved": "https://registry.npmjs.org/@oxc-project/types/-/types-0.151.0.tgz",
@@ -2336,6 +2349,18 @@
        "node": ">=14"
      }
    },
    "node_modules/anynum": {
      "version": "1.0.1",
      "resolved": "https://registry.npmjs.org/anynum/-/anynum-1.0.1.tgz",
      "integrity": "sha512-N6//FLET/tXYNM/F6ABca1oH6fWB+KlTt909Le28WMDBk8oaT4vY17DCrwg2MvmuqUKt3Ni4N5dGJ/EoBgcO6A==",
      "funding": [
        {
          "type": "github",
          "url": "https://github.com/sponsors/NaturalIntelligence"
        }
      ],
      "license": "MIT"
    },
    "node_modules/append-field": {
      "version": "1.0.0",
      "resolved": "https://registry.npmjs.org/append-field/-/append-field-1.0.0.tgz",
@@ -3279,6 +3304,45 @@
        "fast-string-width": "^3.0.2"
      }
    },
    "node_modules/fast-xml-builder": {
      "version": "1.3.1",
      "resolved": "https://registry.npmjs.org/fast-xml-builder/-/fast-xml-builder-1.3.1.tgz",
      "integrity": "sha512-pIM/1n3ntFXKYrUZwW7QCK0gAW7XY+wzj1YMIV3tLDvPj/V+zTGJK5e3/4WJfwj0qWw2ElNXiTixda/R+3YSug==",
      "funding": [
        {
          "type": "github",
          "url": "https://github.com/sponsors/NaturalIntelligence"
        }
      ],
      "license": "MIT",
      "dependencies": {
        "path-expression-matcher": "^1.6.2",
        "xml-naming": "^0.3.0"
      }
    },
    "node_modules/fast-xml-parser": {
      "version": "5.11.1",
      "resolved": "https://registry.npmjs.org/fast-xml-parser/-/fast-xml-parser-5.11.1.tgz",
      "integrity": "sha512-TBw6K/fxoQGGjCmZDw9w/ZwP3uDcnTM4YH/g+PFRWr8sbe5idXtxNN6vITh4+1ruCZaho6uBFurElsA7F0zzgw==",
      "funding": [
        {
          "type": "github",
          "url": "https://github.com/sponsors/NaturalIntelligence"
        }
      ],
      "license": "MIT",
      "dependencies": {
        "@nodable/entities": "^3.0.0",
        "fast-xml-builder": "^1.2.0",
        "is-unsafe": "^2.0.0",
        "path-expression-matcher": "^1.6.2",
        "strnum": "^2.4.2",
        "xml-naming": "^0.3.0"
      },
      "bin": {
        "fxparser": "src/cli/cli.js"
      }
    },
    "node_modules/fdir": {
      "version": "6.5.0",
      "resolved": "https://registry.npmjs.org/fdir/-/fdir-6.5.0.tgz",
@@ -3830,6 +3894,18 @@
        "url": "https://github.com/sponsors/sindresorhus"
      }
    },
    "node_modules/is-unsafe": {
      "version": "2.0.2",
      "resolved": "https://registry.npmjs.org/is-unsafe/-/is-unsafe-2.0.2.tgz",
      "integrity": "sha512-HgbIHPBH0KHHCcjLfGsCvhtPTVxjaAZlXjwdz7/GQC40SjSe4sfQsar8J5VFo8JOSbarkpV0OLG95bbaNd9aAQ==",
      "funding": [
        {
          "type": "github",
          "url": "https://github.com/sponsors/NaturalIntelligence"
        }
      ],
      "license": "MIT"
    },
    "node_modules/isexe": {
      "version": "2.0.0",
      "resolved": "https://registry.npmjs.org/isexe/-/isexe-2.0.0.tgz",
@@ -4848,6 +4924,21 @@
        "node": ">= 0.8"
      }
    },
    "node_modules/path-expression-matcher": {
      "version": "1.6.2",
      "resolved": "https://registry.npmjs.org/path-expression-matcher/-/path-expression-matcher-1.6.2.tgz",
      "integrity": "sha512-enSlaiat05iasnzmgNxRj8reFdj3puY2QpNgP1aPIaVfT6nn9ICuPoFlKHk8EN22HcwewshO+mN2DGbkCEOtqQ==",
      "funding": [
        {
          "type": "github",
          "url": "https://github.com/sponsors/NaturalIntelligence"
        }
      ],
      "license": "MIT",
      "engines": {
        "node": ">=14.0.0"
      }
    },
    "node_modules/path-key": {
      "version": "3.1.1",
      "resolved": "https://registry.npmjs.org/path-key/-/path-key-3.1.1.tgz",
@@ -5503,6 +5594,21 @@
        "node": ">=4"
      }
    },
    "node_modules/strnum": {
      "version": "2.4.2",
      "resolved": "https://registry.npmjs.org/strnum/-/strnum-2.4.2.tgz",
      "integrity": "sha512-rDG3Ah4TV0k1hWvLSzkZtMmLN9+eS+h3knq4MP6A42Y3Yh5qGNnOUs1jJkoSr8FG5dsL28c7KgkIBzSEykqtuw==",
      "funding": [
        {
          "type": "github",
          "url": "https://github.com/sponsors/NaturalIntelligence"
        }
      ],
      "license": "MIT",
      "dependencies": {
        "anynum": "^1.0.1"
      }
    },
    "node_modules/strtok3": {
      "version": "10.3.5",
      "resolved": "https://registry.npmjs.org/strtok3/-/strtok3-10.3.5.tgz",
@@ -6147,6 +6253,21 @@
      "integrity": "sha512-l4Sp/DRseor9wL6EvV2+TuQn63dMkPjZ/sp9XkghTEbV9KlPS1xUsZ3u7/IQO4wxtcFB4bgpQPRcR3QCvezPcQ==",
      "license": "ISC"
    },
    "node_modules/xml-naming": {
      "version": "0.3.0",
      "resolved": "https://registry.npmjs.org/xml-naming/-/xml-naming-0.3.0.tgz",
      "integrity": "sha512-ghig2TBE/H11aOVgmahA3MhimvkBr6JIYknH/Dhdk10nXwdbIqBJsbfMxpvFPG8bAw77gN29aQWvKpmVoPlvPQ==",
      "funding": [
        {
          "type": "github",
          "url": "https://github.com/sponsors/NaturalIntelligence"
        }
      ],
      "license": "MIT",
      "engines": {
        "node": ">=16.0.0"
      }
    },
    "node_modules/yoctocolors": {
      "version": "2.2.0",
      "resolved": "https://registry.npmjs.org/yoctocolors/-/yoctocolors-2.2.0.tgz",
@@ -1,6 +1,6 @@
 {
  "name": "mesh-bot",
-  "version": "0.19.0",
+  "version": "0.21.4",
  "description": "",
  "author": "",
  "private": true,
@@ -30,6 +30,7 @@
    "@nestjs/schedule": "^12.0.2",
    "@nestjs/swagger": "^12.0.2",
    "@scalar/nestjs-api-reference": "^1.2.21",
    "fast-xml-parser": "^5.11.1",
    "reflect-metadata": "^0.2.2",
    "rxjs": "^7.8.1"
  },
@@ -3,6 +3,7 @@ import { BatteryAlertModule } from './battery/battery.module.js';
 import { CommandModule } from './commands/command.module.js';
 import { LlmModule } from './llm/llm.module.js';
 import { MeshModule } from './mesh/mesh.module.js';
 import { RssModule } from './rss/rss.module.js';
 import { WeatherModule } from './weather/weather.module.js';
@Module({
@@ -12,6 +13,7 @@ import { WeatherModule } from './weather/weather.module.js';
    BatteryAlertModule,
    CommandModule,
    LlmModule,
    RssModule,
  ],
 })
 export class AppModule {}
@@ -1,20 +1,22 @@
 import { Module } from '@nestjs/common';
 import { MeshModule } from '../mesh/mesh.module.js';
 import { MeshService } from '../mesh/mesh.service.js';
 import { RssModule } from '../rss/rss.module.js';
 import { RssService } from '../rss/rss.service.js';
 import { CommandService } from './command.service.js';
@Module({
-  imports: [MeshModule], // one-way only — the reverse edge is wired in the factory below, not via DI
+  imports: [MeshModule, RssModule], // one-way only — the MeshService reverse edge is wired in the factory below, not via DI
  providers: [
    {
      provide: CommandService,
-      useFactory: (mesh: MeshService) => {
+      useFactory: (mesh: MeshService, rss: RssService) => {
-        const commands = new CommandService(mesh);
+        const commands = new CommandService(mesh, rss);
        // break the cycle: MeshService can't inject us (its own factory would deadlock on this edge), so attach ourselves once we exist — mesh is guaranteed created here because it's our injected dependency
        mesh.attachCommands(commands);
        return commands;
      },
-      inject: [MeshService],
+      inject: [MeshService, RssService],
    },
  ],
  exports: [CommandService],
@@ -1,5 +1,10 @@
-import { beforeEach, describe, expect, it, vi } from 'vitest';
+import { mkdtempSync, rmSync } from 'node:fs';
-import { BROADCAST_ADDR } from '../mesh/codec.js';
+import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import type { LlmService } from '../llm/llm.service.js';
 import { RssService } from '../rss/rss.service.js';
 import {
  startBridge,
  textPacketFrame,
@@ -7,6 +12,7 @@ import {
  outboundPackets,
  KAMIL_NUM,
 } from '../mesh/fake-bridge.js';
 import { BROADCAST_ADDR } from '../mesh/codec.js';
 import type { MeshService } from '../mesh/mesh.service.js';
 import { MeshService as RealMeshService } from '../mesh/mesh.service.js';
 import { CommandService } from './command.service.js';
@@ -108,6 +114,30 @@ describe('CommandService.onRx', () => {
    expect(mesh.respond).toHaveBeenCalledWith(5, 'up from 99');
  });
  it('sends each line of an array reply as its own threaded respond() to the same packet id', async () => {
    const [svc, mesh] = makeService();
    svc.register('multi', () => ['one: first item', 'two: second item']);
    await svc.onRx(2, '#multi', 42, 9);
    expect(mesh.respond).toHaveBeenCalledTimes(2);
    expect(mesh.respond.mock.calls[0]).toEqual([9, 'one: first item']);
    expect(mesh.respond.mock.calls[1]).toEqual([9, 'two: second item']);
    expect(mesh.sendText).not.toHaveBeenCalled();
  });
  it('sends each line of an array reply via the legacy sendText fallback when there is no packet id', async () => {
    const [svc, mesh] = makeService();
    svc.register('multi', () => ['one: first item', 'two: second item']);
    await svc.onRx(2, '#multi', 42); // no id → legacy path on COMMAND_CHANNEL, DM back to the sender
    expect(mesh.sendText).toHaveBeenCalledTimes(2);
    expect(mesh.sendText.mock.calls[0]).toEqual([
      42,
      'one: first item',
      undefined,
      2,
    ]);
    expect(mesh.respond).not.toHaveBeenCalled();
  });
  it('swallows a failing handler (a bad command must not crash the app)', async () => {
    const [svc, mesh] = makeService();
    svc.register('boom', () => {
@@ -134,6 +164,71 @@ describe('CommandService.onRx', () => {
  });
 });
 describe('#rss prefix dispatch', () => {
  let dir: string | undefined;
  const makeRss = (): RssService => {
    dir = mkdtempSync(join(tmpdir(), 'mesh-bot-cmd-rss-'));
    return new RssService(
      { chat: vi.fn() } as unknown as LlmService,
      new DatabaseSync(join(dir, 'test.db')),
    );
  };
  afterEach(() => {
    if (dir) rmSync(dir, { recursive: true, force: true });
    dir = undefined;
  });
  it('routes #rss subcommands through respond() like any command reply', async () => {
    const mesh = {
      sendText: vi.fn(),
      respond: vi.fn().mockResolvedValue({ id: 1 }),
    } as unknown as MeshService;
    const svc = new CommandService(mesh, makeRss());
    await svc.onRx(2, '#rss sources', 42, 9);
    expect(mesh.respond).toHaveBeenCalledWith(9, 'no sources yet');
    expect(mesh.sendText).not.toHaveBeenCalled();
  });
  it('routes bare #rss to the help text via respond()', async () => {
    const mesh = {
      sendText: vi.fn(),
      respond: vi.fn().mockResolvedValue({ id: 1 }),
    } as unknown as MeshService;
    const svc = new CommandService(mesh, makeRss());
    await svc.onRx(2, '#rss', 42, 9);
    expect(mesh.respond).toHaveBeenCalledTimes(1);
    expect(String(mesh.respond.mock.calls[0][1])).toContain(
      '#rss add <url> <name>',
    );
  });
  it('leaves exact commands untouched and does not partial-match prefix names', async () => {
    const mesh = {
      sendText: vi.fn(),
      respond: vi.fn().mockResolvedValue({ id: 1 }),
    } as unknown as MeshService;
    const svc = new CommandService(mesh, makeRss());
    await svc.onRx(2, '#ping', 42, 3);
    expect(mesh.respond).toHaveBeenCalledWith(3, '#pong!');
    await svc.onRx(2, '#rssfoo', 42, 4); // starts with 'rss' but is not the family — no partial prefix match
    expect(mesh.respond).toHaveBeenCalledTimes(1);
  });
  it('does nothing for #rss when no RssService was wired (legacy construction)', async () => {
    const [svc, mesh] = makeService(); // rss omitted
    await svc.onRx(2, '#rss sources', 42, 9);
    expect(mesh.respond).not.toHaveBeenCalled();
    expect(mesh.sendText).not.toHaveBeenCalled();
  });
 });
 describe('MeshService wiring (event-driven trigger)', () => {
  it('answers a #ping DM on ch2 with a directed #pong! back to the sender, same channel, threaded quote', async () => {
    const bridge = await startBridge();
@@ -1,7 +1,8 @@
 import { Injectable, Logger } from '@nestjs/common';
 import { BROADCAST_ADDR } from '../mesh/codec.js';
-// type-only: the instance comes from DI (command.module.ts factory) or direct construction in tests — no runtime import cycle with src/mesh
+// type-only: the instances come from DI (command.module.ts factory) or direct construction in tests — no runtime import cycles with src/mesh / src/rss
 import type { MeshService } from '../mesh/mesh.service.js';
 import type { RssService } from '../rss/rss.service.js';
 /** Context handed to a command handler: the trimmed text plus sender/packet id when present. */
 export interface CommandContext {
@@ -13,10 +14,10 @@ export interface CommandContext {
  id?: number;
 }
-/** A command handler: returns the reply text to send back, or void/undefined for no reply. */
+/** A command handler: returns the reply text(s) to send back — an array sends one message per line — or void/undefined for no reply. */
 export type CommandHandler = (
  ctx: CommandContext,
-) => string | undefined | Promise<string | undefined>;
+) => string | string[] | undefined | Promise<string | string[] | undefined>;
@Injectable()
 export class CommandService {
@@ -28,10 +29,16 @@ export class CommandService {
  );
  // single registration point: the constructor registers every built-in command — add the next one there (or via register())
  private readonly commands = new Map<string, CommandHandler>();
  // prefix handlers own a whole family (`#rss`, `#rss add ...`) instead of one exact name
  private readonly prefixes = new Map<string, CommandHandler>();
  /** mesh is optional so tests can construct without a bridge; production DI always passes one. */
-  constructor(private readonly mesh?: MeshService) {
+  constructor(
    private readonly mesh?: MeshService,
    rss?: RssService,
  ) {
    this.register('ping', () => '#pong!');
    if (rss) this.registerPrefix('rss', (ctx) => rss.handle(ctx));
  }
  /** Register a command handler (names are case-sensitive; the leading `#` is stripped before lookup). */
@@ -39,9 +46,14 @@ export class CommandService {
    this.commands.set(name, fn);
  }
  /** Register a prefix handler: owns bare `#<name>` and everything starting with `#<name> `. Exact matches win over prefixes. */
  registerPrefix(name: string, fn: CommandHandler): void {
    this.prefixes.set(name, fn);
  }
  /**
   * Event-driven entry point called by MeshService for every decoded rx text.
-   * No-op unless on COMMAND_CHANNEL with an exact `#command` match (case-sensitive).
+   * No-op unless on COMMAND_CHANNEL with a case-sensitive `#command` match — exact name or registered prefix family (`#rss ...`).
   * Replies go through MeshService.respond(id, reply): auto-routed to the original message's
   * destination and channel as a threaded quote (replyId = id). Only when the trigger has no packet
   * id does it fall back to legacy sendText routing on COMMAND_CHANNEL. Never throws — a failed
@@ -56,22 +68,35 @@ export class CommandService {
    if (channel !== this.commandChannel) return;
    const trimmed = text.trim();
    if (!trimmed.startsWith('#')) return; // only `#command` texts trigger handlers
-    const handler = this.commands.get(trimmed.slice(1));
+    const name = trimmed.slice(1);
    let handler = this.commands.get(name);
    if (!handler) {
      for (const [prefix, fn] of this.prefixes) {
        // a prefix owns bare `#<prefix>` and everything starting with `#<prefix> ` — e.g. 'rss' → #rss / #rss add ...
        if (name === prefix || name.startsWith(prefix + ' ')) {
          handler = fn;
          break;
        }
      }
    }
    if (!handler) return; // exact, case-sensitive match — no partials
    try {
      const reply = await handler({ text: trimmed, from, id });
      if (reply === undefined || reply === null) return; // void = no reply
-      if (id !== undefined && this.mesh) {
+      // an array reply sends one message per line, all threaded to the same trigger packet id
-        // respond() auto-routes the reply: rides the original record's channel with replyId = id (threaded quote)
+      for (const line of Array.isArray(reply) ? reply : [reply]) {
-        await this.mesh.respond(id, reply);
+        if (id !== undefined && this.mesh) {
-      } else {
+          // respond() auto-routes each line: rides the original record's channel with replyId = id (threaded quote)
-        // defensive fallback when the trigger has no packet id: legacy routing on COMMAND_CHANNEL
+          await this.mesh.respond(id, line);
-        await this.mesh?.sendText(
+        } else {
-          from ?? BROADCAST_ADDR,
+          // defensive fallback when the trigger has no packet id: legacy routing on COMMAND_CHANNEL
-          reply,
+          await this.mesh?.sendText(
-          undefined,
+            from ?? BROADCAST_ADDR,
-          this.commandChannel,
+            line,
-        );
+            undefined,
            this.commandChannel,
          );
        }
      }
    } catch (err) {
      this.logger.warn(
@@ -12,9 +12,9 @@ export class LlmService {
  private readonly apiBase =
    process.env.LLM_API_BASE ?? 'http://192.168.1.70:1111/v1';
  private readonly model = process.env.LLM_MODEL ?? 'qwen3.8-27b';
-  // local 27B model can be slow — generous default
+  // local 27B model can be slow (uncontrollable reasoning tokens) — generous default: 3 min headroom for slow reasoning periods
  private readonly timeoutMs = parseInt(
-    process.env.LLM_TIMEOUT_MS ?? '60000',
+    process.env.LLM_TIMEOUT_MS ?? '180000',
    10,
  );
@@ -1,6 +1,7 @@
 import { create, fromBinary, toBinary } from '@bufbuild/protobuf';
 import * as P from '@meshtastic/protobufs';
 import { BadRequestException, NotFoundException } from '@nestjs/common';
 import * as net from 'node:net';
 import { DatabaseSync } from 'node:sqlite';
 import { beforeEach, describe, expect, it, vi } from 'vitest';
 import { BROADCAST_ADDR, extractFrames, frame } from './codec.js';
@@ -249,6 +250,195 @@ describe('MeshService connect', () => {
  });
 });
 const sleep = (ms: number) => new Promise((r) => setTimeout(r, ms));
 describe('MeshService idle watchdog', () => {
  it('forces a reconnect when an established connection goes silent past MESH_IDLE_TIMEOUT_MS', async () => {
    const bridge = await startBridge();
    process.env.MESH_HOST = '127.0.0.1';
    process.env.MESH_PORT = String(bridge.port);
    process.env.MESH_RECONNECT_MS = '50'; // fast retry so the re-establishment is observable
    process.env.MESH_IDLE_TIMEOUT_MS = '100'; // override — the default (60000) would never fire in a test
    const svc = new MeshService();
    try {
      svc.onModuleInit();
      await waitFor(
        () => bridge.sockets.length === 1 && svc.status().connected,
      );
      // zombie case: connected but no inbound traffic at all — wait past the timeout, then drive a watchdog tick
      await sleep(250);
      svc.checkIdle();
      // socket torn down → existing connect/retry loop re-establishes with a fresh session
      await waitFor(() => bridge.sockets.length >= 2 && svc.status().connected);
    } finally {
      delete process.env.MESH_RECONNECT_MS;
      delete process.env.MESH_IDLE_TIMEOUT_MS;
      svc.onModuleDestroy();
      bridge.close();
    }
  });
  it('raw non-frame bytes do NOT keep the watchdog alive — a garbage-only stream forces a reconnect', async () => {
    const bridge = await startBridge();
    process.env.MESH_HOST = '127.0.0.1';
    process.env.MESH_PORT = String(bridge.port);
    process.env.MESH_RECONNECT_MS = '50'; // fast retry so the re-establishment is observable
    process.env.MESH_IDLE_TIMEOUT_MS = '100'; // override — the default (60000) would never fire in a test
    const svc = new MeshService();
    try {
      svc.onModuleInit();
      await waitFor(
        () => bridge.sockets.length === 1 && svc.status().connected,
      );
      // today's incident: the peer keeps dribbling small non-frame bytes (keepalive noise / desynced stream) — raw chunks must not reset the idle clock
      const garbage = Buffer.from('zz-no-frames-here'); // pure ASCII — never forms a 0x94 0xc3 frame header
      for (let i = 0; i < 6; i++) {
        await sleep(50); // ~300 ms wall time, well past the timeout
        bridge.sockets[0].write(garbage);
      }
      svc.checkIdle();
      await waitFor(() => bridge.sockets.length >= 2 && svc.status().connected);
    } finally {
      delete process.env.MESH_RECONNECT_MS;
      delete process.env.MESH_IDLE_TIMEOUT_MS;
      svc.onModuleDestroy();
      bridge.close();
    }
  });
  it('forces a reconnect when the undecoded frame buffer exceeds MESH_MAX_FRAME_BUFFER', async () => {
    const bridge = await startBridge();
    process.env.MESH_HOST = '127.0.0.1';
    process.env.MESH_PORT = String(bridge.port);
    process.env.MESH_RECONNECT_MS = '50'; // fast retry so the re-establishment is observable
    process.env.MESH_MAX_FRAME_BUFFER = '100'; // tiny cap — Node delivers socket data in ~64 KB events, far below the 256_000 default
    const svc = new MeshService();
    try {
      svc.onModuleInit();
      await waitFor(
        () => bridge.sockets.length === 1 && svc.status().connected,
      );
      // non-frame bytes (0x42 is not part of any frame header) — a desynced stream that never forms frames; the first ~64 KB data event alone exceeds the cap
      bridge.sockets[0].write(Buffer.alloc(300_000, 0x42));
      // overflow forced a reconnect — fresh session
      await waitFor(() => bridge.sockets.length >= 2 && svc.status().connected);
      // the new socket starts with a clean buffer and decodes valid frames normally (the myInfo frame is well under the cap)
      const fr = create(P.Mesh.FromRadioSchema, {
        payloadVariant: { case: 'myInfo', value: { myNodeNum: 777 } },
      });
      bridge.sockets[1].write(frame(toBinary(P.Mesh.FromRadioSchema, fr)));
      await waitFor(() => svc.status().myNodeNum === 777);
    } finally {
      delete process.env.MESH_RECONNECT_MS;
      delete process.env.MESH_MAX_FRAME_BUFFER;
      svc.onModuleDestroy();
      bridge.close();
    }
  });
  it('inbound traffic keeps resetting the idle clock — no false trigger while packets arrive', async () => {
    const bridge = await startBridge();
    process.env.MESH_HOST = '127.0.0.1';
    process.env.MESH_PORT = String(bridge.port);
    process.env.MESH_IDLE_TIMEOUT_MS = '100';
    const svc = new MeshService();
    try {
      svc.onModuleInit();
      await waitFor(
        () => bridge.sockets.length === 1 && svc.status().connected,
      );
      // steady drip of inbound frames for well over the timeout in wall time — each chunk resets lastPacketAt
      for (let i = 0; i < 5; i++) {
        await sleep(60);
        bridge.sockets[0].write(nodeInfoFrame(42, kamilNodeInfo()));
      }
      svc.checkIdle(); // wall time is past the timeout, but traffic kept resetting it
      await sleep(100); // enough for a destroy to surface as 'close' (connected would flip false)
      expect(svc.status().connected).toBe(true);
      expect(bridge.sockets.length).toBe(1);
    } finally {
      delete process.env.MESH_IDLE_TIMEOUT_MS;
      svc.onModuleDestroy();
      bridge.close();
    }
  });
  it('does not trigger under the default timeout (MESH_IDLE_TIMEOUT_MS unset)', async () => {
    const bridge = await startBridge();
    process.env.MESH_HOST = '127.0.0.1';
    process.env.MESH_PORT = String(bridge.port);
    delete process.env.MESH_IDLE_TIMEOUT_MS; // default 60000 — a test can't wait that long, so silence must NOT fire
    const svc = new MeshService();
    try {
      svc.onModuleInit();
      await waitFor(
        () => bridge.sockets.length === 1 && svc.status().connected,
      );
      await sleep(250); // silent, but far under the default budget
      svc.checkIdle();
      expect(svc.status().connected).toBe(true);
      expect(bridge.sockets.length).toBe(1);
    } finally {
      delete process.env.MESH_IDLE_TIMEOUT_MS;
      svc.onModuleDestroy();
      bridge.close();
    }
  });
  it('enables TCP keepalive on the bridge socket', async () => {
    const setKeepAlive = vi.spyOn(net.Socket.prototype, 'setKeepAlive');
    const bridge = await startBridge();
    process.env.MESH_HOST = '127.0.0.1';
    process.env.MESH_PORT = String(bridge.port);
    const svc = new MeshService();
    try {
      svc.onModuleInit();
      await waitFor(() => svc.status().connected);
      expect(setKeepAlive).toHaveBeenCalledWith(true, 30_000);
    } finally {
      setKeepAlive.mockRestore();
      svc.onModuleDestroy();
      bridge.close();
    }
  });
 });
 describe('MeshService periodic autoreconnect', () => {
  it('unconditionally reconnects when MESH_RECONNECT_INTERVAL_MS elapses', async () => {
    const bridge = await startBridge();
    process.env.MESH_HOST = '127.0.0.1';
    process.env.MESH_PORT = String(bridge.port);
    process.env.MESH_RECONNECT_MS = '50'; // fast retry so the re-establishment is observable
    process.env.MESH_RECONNECT_INTERVAL_MS = '100'; // override — the default (300000) would never elapse in a test
    const svc = new MeshService();
    try {
      svc.onModuleInit();
      await waitFor(
        () => bridge.sockets.length === 1 && svc.status().connected,
      );
      // interval fires → destroy → existing close/retry loop re-establishes with a fresh session
      await waitFor(() => bridge.sockets.length >= 2 && svc.status().connected);
    } finally {
      delete process.env.MESH_RECONNECT_MS;
      delete process.env.MESH_RECONNECT_INTERVAL_MS;
      svc.onModuleDestroy();
      bridge.close();
    }
  });
 });
 describe('MeshService send', () => {
  it('sends on the test channel (index 3) by default, never primary', async () => {
    const bridge = await startBridge();
@@ -81,6 +81,8 @@ export interface TelemetryRecord {
 const HISTORY_LIMIT = 100;
 /** Rows kept in SQLite across restarts; older rows are pruned on every poller tick. */
 const DB_RETENTION = 1000;
 // how often the idle watchdog checks for a silent-but-connected bridge (ms)
 const IDLE_CHECK_MS = 30_000;
 // one row per MessageRecord, keyed by packet id (tx ids and injected ids are random uint32, rx uses the wire id)
 export const MESSAGES_DDL = `CREATE TABLE IF NOT EXISTS messages(
@@ -208,6 +210,21 @@ export class MeshService implements OnModuleInit, OnModuleDestroy {
  );
  // how often the poller re-upserts the history buffer into SQLite (ms)
  private readonly pollMs = parseInt(process.env.MESH_POLL_MS ?? '1000', 10);
  // idle watchdog: force a reconnect when an ESTABLISHED connection stops decoding frames — the zombie-bridge case where outbound sends keep working but inbound frame flow is dead (raw non-frame bytes do NOT reset the clock). Read at construction like the other env config.
  private readonly idleTimeoutMs = parseInt(
    process.env.MESH_IDLE_TIMEOUT_MS ?? '60000',
    10,
  );
  // lazy periodic autoreconnect: unconditionally destroy + re-establish every N ms so a fresh sync happens on schedule — the bridge/radio side tends to kill inbound RX within ~20 min of a fresh sync. Read at construction like the other env config.
  private readonly reconnectIntervalMs = parseInt(
    process.env.MESH_RECONNECT_INTERVAL_MS ?? '300000',
    10,
  );
  // cap on undecoded frame buffer: a desynced stream that never forms frames would grow it without bound — force a reconnect instead. Env-overridable so tests can trigger it (Node caps socket 'data' events at ~64 KB).
  private readonly maxFrameBuffer = parseInt(
    process.env.MESH_MAX_FRAME_BUFFER ?? '256000',
    10,
  );
  /** SQLite database backing the message history; null = persistence disabled (tests construct without one). */
  private db: DatabaseSync | null = null;
@@ -255,6 +272,10 @@ export class MeshService implements OnModuleInit, OnModuleDestroy {
  // telemetry history (newest kept, capped at HISTORY_LIMIT)
  private telemetryHistory: TelemetryRecord[] = [];
  private reconnectTimer: NodeJS.Timeout | null = null;
  /** epoch ms when the last valid frame was decoded from the bridge; reset on connect — idle watchdog baseline */
  private lastPacketAt = Date.now();
  private idleTimer: NodeJS.Timeout | null = null;
  private periodicReconnectTimer: NodeJS.Timeout | null = null;
  private shuttingDown = false;
  onModuleInit(): void {
@@ -264,6 +285,15 @@ export class MeshService implements OnModuleInit, OnModuleDestroy {
      // ponytail: full re-upsert of the ≤100-row buffer every tick — trivial load, zero bookkeeping
      this.pollTimer = setInterval(() => this.flushHistory(), this.pollMs);
    }
    // idle watchdog: catches established-but-silent connections (zombie bridge) that the connect/retry loop never sees
    this.idleTimer = setInterval(() => this.checkIdle(), IDLE_CHECK_MS);
    // lazy periodic autoreconnect: unconditional fresh sync on a fixed schedule; when not connected, destroy is a no-op and the retry loop owns recovery
    this.periodicReconnectTimer = setInterval(() => {
      this.logger.log(
        'periodic reconnect — MESH_RECONNECT_INTERVAL_MS elapsed',
      );
      this.socket?.destroy();
    }, this.reconnectIntervalMs);
    this.connect();
  }
@@ -271,6 +301,8 @@ export class MeshService implements OnModuleInit, OnModuleDestroy {
    this.shuttingDown = true;
    if (this.reconnectTimer) clearTimeout(this.reconnectTimer);
    if (this.pollTimer) clearInterval(this.pollTimer);
    if (this.idleTimer) clearInterval(this.idleTimer);
    if (this.periodicReconnectTimer) clearInterval(this.periodicReconnectTimer);
    this.socket?.destroy();
    this.db?.close();
  }
@@ -641,11 +673,17 @@ export class MeshService implements OnModuleInit, OnModuleDestroy {
  private connect(): void {
    if (this.shuttingDown) return;
    const socket = net.createConnection({ host: this.host, port: this.port });
    // TCP-level keepalive: cheap insurance against a dead peer that the idle watchdog (application level) complements
    socket.setKeepAlive(true, 30_000);
    this.socket = socket;
    socket.on('connect', () => {
      this.connected = true;
      // fresh connection — reset the idle clock so it can't self-trigger before any traffic arrives
      this.lastPacketAt = Date.now();
      // fresh sync on every (re)connect — drop stale channels/nodes/device info/telemetry from the old session;
-      // message history is NOT reset: it's an append-only log backed by SQLite and survives reconnects
+      // message history is NOT reset: it's an append-only log backed by SQLite and survives reconnects.
      // The undecoded frame buffer goes too: leftover desync garbage must not re-trigger the overflow backstop on a healthy new stream.
      this.buffer = new Uint8Array(0);
      this.channelMap = new Map();
      this.nodeMap = new Map();
      this.metadata = null;
@@ -666,9 +704,19 @@ export class MeshService implements OnModuleInit, OnModuleDestroy {
      const merged = new Uint8Array(this.buffer.length + chunk.length);
      merged.set(this.buffer, 0);
      merged.set(chunk, this.buffer.length);
      // buffer-overflow backstop: a desynced stream that never forms frames would grow the buffer without bound — cap it and self-heal via reconnect
      if (merged.length > this.maxFrameBuffer) {
        this.logger.error(
          'frame buffer overflow — stream desync, forcing reconnect',
        );
        socket.destroy();
        return;
      }
      this.buffer = merged;
      const { packets, rest } = extractFrames(this.buffer);
      this.buffer = rest;
      // the watchdog tracks DECODED FRAMES, not raw bytes: non-frame noise (keepalives, desynced streams) must not keep a dead connection alive
      if (packets.length) this.lastPacketAt = Date.now();
      for (const p of packets) {
        decodeFromRadio(p)
          .then((fr) => this.handleFromRadio(fr))
@@ -694,6 +742,25 @@ export class MeshService implements OnModuleInit, OnModuleDestroy {
    this.reconnectTimer = setTimeout(() => this.connect(), this.reconnectMs);
  }
  /**
   * Idle watchdog tick: force a reconnect when an ESTABLISHED connection has decoded no frames from
   * the bridge for MESH_IDLE_TIMEOUT_MS — the zombie case where outbound sends keep working but inbound
   * frame flow is dead (raw non-frame bytes arriving on the socket do not count). Destroying the socket
   * routes through 'close' → onDown → scheduleReconnect, so the existing connect/retry loop re-establishes
   * with a fresh sync; no new retry machinery here. Public so tests can drive a tick without waiting for
   * the real interval (like flushHistory()).
   */
  checkIdle(): void {
    if (!this.connected) return; // disconnected state is owned by the connect/retry loop
    const idle = Date.now() - this.lastPacketAt;
    if (idle > this.idleTimeoutMs) {
      this.logger.warn(
        `no decoded bridge frames for ${idle} ms — forcing reconnect`,
      );
      this.socket?.destroy();
    }
  }
  private async handleFromRadio(
    fr: import('@meshtastic/protobufs').Mesh.FromRadio,
  ): Promise<void> {
@@ -0,0 +1,64 @@
 import { describe, expect, it } from 'vitest';
 import { parseFeed } from './rss.feed.js';
 const RSS2 = `<?xml version="1.0" encoding="UTF-8"?>
 <rss version="2.0">
  <channel>
    <title>Some Feed</title>
    <item>
      <title>First headline</title>
      <link>https://example.com/first</link>
    </item>
    <item>
      <title><![CDATA[Second: with CDATA]]></title>
      <description>ignored</description>
    </item>
    <item>
      <title></title>
      <link>https://example.com/empty-title</link>
    </item>
  </channel>
 </rss>`;
 const ATOM = `<?xml version="1.0" encoding="utf-8"?>
 <feed xmlns="http://www.w3.org/2005/Atom">
  <title>An Atom feed</title>
  <entry>
    <title>Only entry</title>
    <link rel="alternate" href="https://example.com/atom"/>
  </entry>
 </feed>`;
 describe('parseFeed', () => {
  it('parses RSS 2.0 items in document order, keeping links where present and skipping empty titles', () => {
    expect(parseFeed(RSS2)).toEqual([
      { title: 'First headline', link: 'https://example.com/first' },
      { title: 'Second: with CDATA' },
    ]);
  });
  it('parses Atom entries (single entry object, link as href attribute)', () => {
    expect(parseFeed(ATOM)).toEqual([
      { title: 'Only entry', link: 'https://example.com/atom' },
    ]);
  });
  it('returns [] for malformed XML', () => {
    expect(parseFeed('this is not xml at all')).toEqual([]);
    expect(parseFeed('<rss><channel><item><title>broken')).toEqual([]);
  });
  it('returns [] when there are no items or none with a usable title', () => {
    expect(
      parseFeed('<rss version="2.0"><channel><title>x</title></channel></rss>'),
    ).toEqual([]);
    expect(
      parseFeed('<feed xmlns="http://www.w3.org/2005/Atom"></feed>'),
    ).toEqual([]);
    expect(
      parseFeed(
        '<rss version="2.0"><channel><item><title>   </title></item></channel></rss>',
      ),
    ).toEqual([]);
  });
 });
@@ -0,0 +1,60 @@
 import { XMLParser } from 'fast-xml-parser';
 /** One feed item: title always present (non-empty), link where the feed provides one. */
 export interface FeedItem {
  title: string;
  link?: string;
 }
 const parser = new XMLParser({ ignoreAttributes: false });
 function asText(value: unknown): string | undefined {
  if (typeof value === 'string') return value.trim() || undefined;
  // element with attributes/CDATA parses to an object holding its text under #text
  const t = (value as Record<string, unknown>)?.['#text'];
  if (typeof t === 'string' && t.trim()) return t.trim();
  return undefined;
 }
 function asLink(value: unknown): string | undefined {
  const fromText = asText(value);
  if (fromText) return fromText; // RSS 2.0 <link>url</link>
  // Atom <link rel="alternate" href="..."/> — the URL is an attribute
  const href = (value as Record<string, unknown>)?.['@_href'];
  if (typeof href === 'string' && href.trim()) return href.trim();
  return undefined;
 }
 function collect(value: unknown): Record<string, unknown>[] {
  // a single item/entry parses to an object, several to an array
  if (!value) return [];
  const arr = Array.isArray(value) ? value : [value];
  return arr.filter(
    (v): v is Record<string, unknown> => !!v && typeof v === 'object',
  );
 }
 /**
 * Parse RSS 2.0 (`<item><title>/<link>`) or Atom (`<entry><title>`) XML into items with
 * non-empty titles, in document order (feeds are newest-first). Returns [] for malformed
 * input or feeds without usable items — that empty result IS the "not a valid feed" signal.
 */
 export function parseFeed(xml: string): FeedItem[] {
  let doc: unknown;
  try {
    doc = parser.parse(xml);
  } catch {
    return []; // fast-xml-parser is lenient, but a hard failure means no items either
  }
  const root = doc as Record<string, any>;
  // coalesce the RAW values first — collect() always returns an array, so `collect(a) ?? collect(b)` could never fall through to b
  const rawItems = collect(root?.rss?.channel?.item ?? root?.feed?.entry);
  const items: FeedItem[] = [];
  for (const item of rawItems) {
    const title = asText(item?.title);
    if (!title) continue; // skip entries without a usable title
    const link = asLink(item.link);
    items.push(link ? { title, link } : { title });
  }
  return items;
 }
@@ -0,0 +1,28 @@
 import { Module } from '@nestjs/common';
 import { mkdirSync } from 'node:fs';
 import { dirname } from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
 import { LlmModule } from '../llm/llm.module.js';
 import { LlmService } from '../llm/llm.service.js';
 import { RssService } from './rss.service.js';
 // The rss_sources table lives in the SAME file as the mesh message history (MESH_DB_PATH) — a second
 // connection is fine, SQLite serializes writes. The service initializes its own table on construction.
 function openRssDb(): DatabaseSync {
  const path = process.env.MESH_DB_PATH ?? './data/mesh-bot.db';
  mkdirSync(dirname(path), { recursive: true });
  return new DatabaseSync(path);
 }
@Module({
  imports: [LlmModule], // one-way — LlmService has no dependencies of its own
  providers: [
    {
      provide: RssService,
      useFactory: (llm: LlmService) => new RssService(llm, openRssDb()),
      inject: [LlmService],
    },
  ],
  exports: [RssService],
 })
 export class RssModule {}
@@ -0,0 +1,317 @@
 import { mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
 import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
 import type { LlmService } from '../llm/llm.service.js';
 import { RssStore } from './rss.store.js';
 import { fitOneLine, parseSummaryItems, RssService } from './rss.service.js';
 const FEED_A = `<rss version="2.0"><channel>
  <item><title>Alpha headline</title></item>
  <item><title>Beta headline</title></item>
 </channel></rss>`;
 const FEED_B = `<rss version="2.0"><channel>
  <item><title>Gamma headline</title></item>
 </channel></rss>`;
 function feedResponse(xml: string): Response {
  return { ok: true, status: 200, text: async () => xml } as Response;
 }
 describe('RssService.handle', () => {
  let dir: string;
  let dbFile: string;
  let llm: { chat: ReturnType<typeof vi.fn> };
  let svc: RssService;
  let fetchMock: ReturnType<typeof vi.fn>;
  beforeEach(() => {
    dir = mkdtempSync(join(tmpdir(), 'mesh-bot-rss-svc-'));
    dbFile = join(dir, 'test.db');
    llm = { chat: vi.fn() };
    svc = new RssService(
      llm as unknown as LlmService,
      new DatabaseSync(dbFile),
    );
    fetchMock = vi.fn();
    vi.stubGlobal('fetch', fetchMock);
  });
  afterEach(() => {
    vi.unstubAllGlobals();
    rmSync(dir, { recursive: true, force: true });
  });
  const ctx = (text: string) => ({ text });
  // second connection — the same shape production uses for a separate table in one file
  const stored = () => new RssStore(new DatabaseSync(dbFile));
  it('replies with usage on bare #rss and on unknown subcommands', async () => {
    const help = await svc.handle(ctx('#rss'));
    expect(help).toContain('#rss add <url> <name>');
    expect(help).toContain('#rss get <name|#tag>');
    expect(await svc.handle(ctx('#rss frobnicate'))).toBe(help);
  });
  it('add: validates the feed, stores source with LLM tags, replies added (tags: ...)', async () => {
    fetchMock.mockResolvedValueOnce(feedResponse(FEED_A));
    llm.chat.mockResolvedValueOnce('#AI, News');
    const reply = await svc.handle(
      ctx('#rss add https://a.example/rss my feed'),
    );
    expect(reply).toBe('added my feed (tags: ai, news)');
    expect(stored().get('my feed')).toMatchObject({
      url: 'https://a.example/rss',
      tags: ['ai', 'news'],
    });
    const [messages, opts] = llm.chat.mock.calls[0];
    expect(opts).toEqual({ maxTokens: 50 });
    expect(messages[0].content).toContain('Alpha headline');
  });
  it('add: LLM failure still stores the source with empty tags and says so', async () => {
    fetchMock.mockResolvedValueOnce(feedResponse(FEED_A));
    llm.chat.mockRejectedValueOnce(new Error('llm down'));
    const reply = await svc.handle(
      ctx('#rss add https://a.example/rss myfeed'),
    );
    expect(reply).toBe('added myfeed (tag generation failed - no tags)');
    expect(stored().get('myfeed')?.tags).toEqual([]);
  });
  it('add: rejects invalid urls without fetching or storing', async () => {
    expect(await svc.handle(ctx('#rss add not a url x'))).toBe('invalid url');
    expect(await svc.handle(ctx('#rss add ftp://a.example/rss x'))).toBe(
      'invalid url',
    );
    expect(fetchMock).not.toHaveBeenCalled();
    expect(stored().list()).toEqual([]);
  });
  it('add: rejects duplicate names case-insensitively without fetching', async () => {
    stored().add({ name: 'MyFeed', url: 'https://old.example/rss', tags: [] });
    const reply = await svc.handle(
      ctx('#rss add https://a.example/rss myfeed'),
    );
    expect(reply).toBe('myfeed already exists - remove it first');
    expect(fetchMock).not.toHaveBeenCalled();
    expect(stored().get('myfeed')?.url).toBe('https://old.example/rss'); // untouched
  });
  it('add: reports non-2xx and unparseable feeds, stores nothing', async () => {
    fetchMock.mockResolvedValueOnce({ ok: false, status: 404 } as Response);
    expect(await svc.handle(ctx('#rss add https://a.example/rss x'))).toBe(
      'feed fetch failed (HTTP 404)',
    );
    fetchMock.mockResolvedValueOnce(feedResponse('this is not xml'));
    expect(await svc.handle(ctx('#rss add https://b.example/rss y'))).toBe(
      'not a valid feed (no items)',
    );
    expect(stored().list()).toEqual([]);
  });
  it('remove: deletes case-insensitively, reports missing names', async () => {
    stored().add({ name: 'Gone', url: 'https://g.example/rss', tags: [] });
    expect(await svc.handle(ctx('#rss remove gone'))).toBe('removed gone');
    expect(stored().list()).toEqual([]);
    expect(await svc.handle(ctx('#rss remove nope'))).toBe(
      'no source named nope',
    );
  });
  it('tags: no tags yet when empty, distinct sorted list otherwise', async () => {
    expect(await svc.handle(ctx('#rss tags'))).toBe('no tags yet');
    stored().add({
      name: 'A',
      url: 'https://a.example/rss',
      tags: ['zeta', 'alpha'],
    });
    stored().add({
      name: 'B',
      url: 'https://b.example/rss',
      tags: ['beta', 'alpha'],
    });
    expect(await svc.handle(ctx('#rss tags'))).toBe('alpha, beta, zeta');
  });
  it('sources: no sources yet when empty, names otherwise', async () => {
    expect(await svc.handle(ctx('#rss sources'))).toBe('no sources yet');
    stored().add({ name: 'Bee', url: 'https://b.example/rss', tags: [] });
    stored().add({ name: 'Aye', url: 'https://a.example/rss', tags: [] });
    expect(await svc.handle(ctx('#rss sources'))).toBe('Aye, Bee');
  });
  it('get <name>: summarizes via chat with a bounded maxTokens and replies with headered lines', async () => {
    stored().add({ name: 'myfeed', url: 'https://a.example/rss', tags: [] });
    fetchMock.mockResolvedValueOnce(feedResponse(FEED_A));
    llm.chat.mockResolvedValueOnce(
      'Chips: EU funds foundries.\nPark: Riverfront expansion approved.',
    );
    const reply = await svc.handle(ctx('#rss get myfeed'));
    expect(reply).toEqual([
      'Chips: EU funds foundries.',
      'Park: Riverfront expansion approved.',
    ]);
    const [messages, opts] = llm.chat.mock.calls[0];
    // headroom for the server's reasoning tokens (they count against max_tokens) — see rss.service.ts
    expect(opts).toEqual({ maxTokens: 2500 });
    const prompt = messages[0].content;
    expect(prompt).toContain('exactly 3-5 lines');
    expect(prompt).toContain('<short header>: <one or two short sentences>');
    expect(prompt).toContain('at most 20 characters');
    expect(prompt).toContain('No intro, no outro, no numbering');
    expect(prompt).toContain('Alpha headline');
    expect(prompt).toContain('Beta headline');
  });
  it('get <name>: caps items at 5', async () => {
    stored().add({ name: 'myfeed', url: 'https://a.example/rss', tags: [] });
    fetchMock.mockResolvedValueOnce(feedResponse(FEED_A));
    const seven = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
      .map((c) => `${c}: item ${c}`)
      .join('\n');
    llm.chat.mockResolvedValueOnce(seven);
    const reply = await svc.handle(ctx('#rss get myfeed'));
    expect(reply).toEqual([
      'a: item a',
      'b: item b',
      'c: item c',
      'd: item d',
      'e: item e',
    ]);
  });
  it('get <name>: drops empty and separator-less lines, sends what remains when fewer than 3 are valid', async () => {
    stored().add({ name: 'myfeed', url: 'https://a.example/rss', tags: [] });
    fetchMock.mockResolvedValueOnce(feedResponse(FEED_A));
    llm.chat.mockResolvedValueOnce(
      'Chips: EU funds foundries.\n\nJust a sentence without a header\n   \nPark: expansion approved.',
    );
    const reply = await svc.handle(ctx('#rss get myfeed'));
    expect(reply).toEqual([
      'Chips: EU funds foundries.',
      'Park: expansion approved.',
    ]);
  });
  it('get <name>: hard-cuts an over-length line at a word boundary so each item fits one packet', async () => {
    stored().add({ name: 'myfeed', url: 'https://a.example/rss', tags: [] });
    fetchMock.mockResolvedValueOnce(feedResponse(FEED_A));
    const longLine = `Chips: ${'word '.repeat(40)}`; // 207 chars — over the per-line cap
    llm.chat.mockResolvedValueOnce(`${longLine}\nPark: short line.`);
    const reply = await svc.handle(ctx('#rss get myfeed'));
    expect(Array.isArray(reply)).toBe(true);
    const [cut, ok] = reply as string[];
    expect(cut.length).toBeLessThanOrEqual(180);
    expect(longLine.startsWith(cut)).toBe(true); // prefix — cut at a word boundary, not mid-word
    expect(cut.endsWith(' ')).toBe(false);
    expect(ok).toBe('Park: short line.'); // other lines untouched
  });
  it('get #tag: collects items across all sources with the tag; one dead feed does not sink it', async () => {
    stored().add({ name: 'A', url: 'https://a.example/rss', tags: ['tech'] });
    stored().add({ name: 'B', url: 'https://b.example/rss', tags: ['tech'] });
    stored().add({ name: 'C', url: 'https://c.example/rss', tags: ['other'] }); // not matched by #tech
    fetchMock
      .mockResolvedValueOnce(feedResponse(FEED_A)) // A answers (Alpha, Beta)
      .mockRejectedValueOnce(new Error('down')); // B is dead
    llm.chat.mockResolvedValueOnce('Chips: only alpha survived.');
    const reply = await svc.handle(ctx('#rss get #tech'));
    // B's fetch rejected, yet the summary still went out from A's titles alone
    expect(reply).toEqual(['Chips: only alpha survived.']);
    expect(llm.chat).toHaveBeenCalledTimes(1);
    const content = llm.chat.mock.calls[0][0][0].content;
    expect(content).toContain('Alpha headline');
  });
  it('get #tag: merges titles from every source carrying the tag', async () => {
    stored().add({ name: 'A', url: 'https://a.example/rss', tags: ['tech'] });
    stored().add({ name: 'B', url: 'https://b.example/rss', tags: ['tech'] });
    fetchMock
      .mockResolvedValueOnce(feedResponse(FEED_A)) // A → Alpha, Beta
      .mockResolvedValueOnce(feedResponse(FEED_B)); // B → Gamma
    llm.chat.mockResolvedValueOnce(
      'Alpha: first headline.\nGamma: second headline.',
    );
    const reply = await svc.handle(ctx('#rss get #tech'));
    expect(reply).toEqual([
      'Alpha: first headline.',
      'Gamma: second headline.',
    ]);
    const content = llm.chat.mock.calls[0][0][0].content;
    expect(content).toContain('Alpha headline');
    expect(content).toContain('Gamma headline'); // proves B's feed was collected too
  });
  it('get: unknown name and tag get distinct error replies', async () => {
    expect(await svc.handle(ctx('#rss get nope'))).toBe('no source named nope');
    stored().add({ name: 'A', url: 'https://a.example/rss', tags: ['tech'] });
    expect(await svc.handle(ctx('#rss get #nothing'))).toBe(
      'no sources with tag nothing',
    );
  });
 });
 describe('parseSummaryItems (per-line items for multi-message summaries)', () => {
  it('keeps lines with a header separator, drops empty and separator-less ones', () => {
    expect(
      parseSummaryItems(
        'Chips: EU funds foundries.\n\nNo header here\n   \nPark: expansion approved.',
      ),
    ).toEqual(['Chips: EU funds foundries.', 'Park: expansion approved.']);
  });
  it('caps at 5 items', () => {
    const seven = ['a', 'b', 'c', 'd', 'e', 'f', 'g']
      .map((c) => `${c}: item`)
      .join('\n');
    expect(parseSummaryItems(seven)).toHaveLength(5);
    expect(parseSummaryItems(seven)[4]).toBe('e: item');
  });
  it('returns [] when nothing is valid', () => {
    expect(parseSummaryItems('no headers at all\n')).toEqual([]);
  });
 });
 describe('fitOneLine (one mesh packet per line)', () => {
  it('passes through lines that already fit, including exactly 185 chars', () => {
    const short = 'Chips: EU funds foundries.';
    expect(fitOneLine(short)).toBe(short);
    const exact = 'x'.repeat(185);
    expect(fitOneLine(exact)).toBe(exact);
  });
  it('cuts over-long lines at a word boundary near 180', () => {
    const long = `Chips: ${'word '.repeat(40)}`; // 207 chars
    const cut = fitOneLine(long);
    expect(cut.length).toBeLessThanOrEqual(180);
    expect(long.startsWith(cut)).toBe(true); // prefix — not mid-word
    expect(cut.endsWith(' ')).toBe(false);
  });
  it('hard-cuts at 180 when there is no word boundary in reach', () => {
    const long = 'w'.repeat(250);
    expect(fitOneLine(long)).toBe('w'.repeat(180));
  });
 });
@@ -0,0 +1,237 @@
 import { Injectable, Logger } from '@nestjs/common';
 import { DatabaseSync } from 'node:sqlite';
 // type-only both ways — no runtime import cycle between src/rss and src/commands
 import type { CommandContext } from '../commands/command.service.js';
 import { LlmService } from '../llm/llm.service.js';
 import { parseFeed } from './rss.feed.js';
 import { RssStore } from './rss.store.js';
 // ponytail: hardcoded tunables, promote to env if the owner wants them adjustable
 const FETCH_TIMEOUT_MS = 15000; // feed fetches — same budget as the opencode notifier's POSTs
 const MAX_TITLES = 8; // "up to 8 latest item titles" per the design
 const TAG_MAX_TOKENS = 50;
 // The LLM server (qwen3.8-27b) emits reasoning_content and those tokens COUNT against max_tokens
 // (verified: cap 150 → completion_tokens 150 of which 105 were reasoning, finish_reason 'length').
 // Thinking length for this task is unbounded and uncontrollable server-side (/no_think,
 // chat_template_kwargs.enable_thinking and thinking_budget are all ignored) — observed 32..1776
 // tokens across runs. So the cap must be headroom for reasoning + ~80 content tokens:
 // 2500 covers every observed run (worst case ≈42 s at ~60 tok/s, under LLM_TIMEOUT_MS=60 s).
 const SUMMARY_MAX_TOKENS = 2500;
 // Mesh fragments replies longer than ~190 chars into fire-and-forget packets that recipients
 // often never get — each summary line must fit ONE packet on its own. The prompt asks for short
 // headered lines; this is the hard backstop if the model ignores it (cut at a word boundary).
 const MAX_LINE_CHARS = 185; // per-line one-packet threshold
 const LINE_CUT_AT = 180; // where over-long lines get cut, snapped back to a word boundary
 const MAX_ITEMS = 5; // cap on summary items sent as separate messages
 /**
 * The `#rss` command family: stored RSS sources (SQLite, shared MESH_DB_PATH file) with
 * LLM-generated tags and on-demand headline summaries. Replies are short strings — or an array
 * of lines for multi-message summaries, which CommandService sends one respond() per line.
 */
@Injectable()
 export class RssService {
  private readonly logger = new Logger(RssService.name);
  private readonly store: RssStore;
  constructor(
    private readonly llm: LlmService,
    db: DatabaseSync,
  ) {
    this.store = new RssStore(db);
  }
  /** Entry point for the `#rss` prefix — always replies (errors included); `get` may reply with several lines. */
  async handle(ctx: CommandContext): Promise<string | string[]> {
    const words = ctx.text.trim().split(/\s+/);
    switch (words[1]) {
      case undefined: // bare `#rss`
      case 'help':
        return this.help();
      case 'add':
        return this.add(words.slice(2));
      case 'remove':
        return this.remove(words.slice(2).join(' '));
      case 'tags':
        return this.tags();
      case 'sources':
        return this.sources();
      case 'get':
        return this.get((words[2] ?? '').trim());
      default:
        return this.help(); // unknown subcommand → help
    }
  }
  private help(): string {
    return [
      '#rss add <url> <name> - add source with AI tags',
      '#rss remove <name> - delete a source',
      '#rss get <name|#tag> - summarize latest items',
      '#rss tags - all distinct tags',
      '#rss sources - all source names',
    ].join('\n');
  }
  /** `#rss add <url> <name>` — name may contain spaces (everything after the url). */
  private async add(args: string[]): Promise<string> {
    const url = args[0];
    const name = args.slice(1).join(' ').trim();
    if (!url || !name) return 'usage: #rss add <url> <name>';
    let parsedUrl: URL;
    try {
      parsedUrl = new URL(url);
    } catch {
      return 'invalid url';
    }
    if (parsedUrl.protocol !== 'http:' && parsedUrl.protocol !== 'https:')
      return 'invalid url';
    if (this.store.exists(name))
      return `${name} already exists - remove it first`;
    let titles: string[];
    try {
      titles = await this.fetchLatestTitles(url);
    } catch (err) {
      const msg = (err as Error).message;
      // fetchLatestTitles throws `HTTP <status>` on non-2xx, other errors carry their own message
      return msg.startsWith('HTTP')
        ? `feed fetch failed (${msg})`
        : 'not a valid feed';
    }
    if (!titles.length) return 'not a valid feed (no items)';
    // AI tags — best effort: a source is still added when the LLM fails
    let tags: string[] = [];
    try {
      const raw = await this.llm.chat(
        [
          {
            role: 'user',
            content: `Give 2-4 short lowercase tags for these RSS feed item titles. Reply with comma-separated tags only - no # symbols, no explanation:\n${titles.join('\n')}`,
          },
        ],
        { maxTokens: TAG_MAX_TOKENS },
      );
      tags = sanitizeTags(raw);
    } catch (err) {
      this.logger.warn(
        `[rss] tag generation failed for '${name}': ${(err as Error).message}`,
      );
    }
    this.store.add({ name, url, tags });
    return tags.length
      ? `added ${name} (tags: ${tags.join(', ')})`
      : 'added ' + name + ' (tag generation failed - no tags)';
  }
  private remove(name: string): string {
    if (!name) return 'usage: #rss remove <name>';
    return this.store.remove(name)
      ? `removed ${name}`
      : `no source named ${name}`;
  }
  private tags(): string {
    const all = this.store.allTags();
    return all.length ? all.join(', ') : 'no tags yet';
  }
  private sources(): string {
    const names = this.store.list().map((s) => s.name);
    return names.length ? names.join(', ') : 'no sources yet';
  }
  /** `#rss get <name>` or `#rss get #<tag>` — replies with 3-5 separate one-packet lines. */
  private async get(target: string): Promise<string | string[]> {
    if (!target) return 'usage: #rss get <name|#tag>';
    let urls: string[];
    if (target.startsWith('#')) {
      const tag = target.slice(1).toLowerCase();
      if (!tag) return 'usage: #rss get <name|#tag>';
      const matching = this.store.list().filter((s) => s.tags.includes(tag));
      if (!matching.length) return `no sources with tag ${tag}`;
      urls = matching.map((s) => s.url);
    } else {
      const source = this.store.get(target);
      if (!source) return `no source named ${target}`;
      urls = [source.url];
    }
    // one dead feed must not sink the whole summary — collect what answers
    const results = await Promise.allSettled(
      urls.map((u) => this.fetchLatestTitles(u)),
    );
    const titles: string[] = [];
    for (const r of results) {
      if (r.status === 'fulfilled') titles.push(...r.value);
      else
        this.logger.warn(
          `[rss] feed fetch failed: ${(r.reason as Error).message}`,
        );
    }
    if (!titles.length) return 'no items found';
    try {
      const reply = await this.llm.chat(
        [
          {
            role: 'user',
            content: `Summarize these RSS headlines into exactly 3-5 lines, one item per line, each in the format "<short header>: <one or two short sentences>" where the header is at most 20 characters (e.g. "Culture: Museum opens new wing"). No intro, no outro, no numbering - items only:\n${titles.join('\n')}`,
          },
        ],
        { maxTokens: SUMMARY_MAX_TOKENS },
      );
      // each item goes out as its own mesh message — CommandService sends the array line by line;
      // fewer than 3 valid lines is fine (the model is non-deterministic), we send what we got
      return parseSummaryItems(reply).map(fitOneLine);
    } catch (err) {
      this.logger.warn(`[rss] summary failed: ${(err as Error).message}`);
      return 'summary failed';
    }
  }
  /** Fetch a feed and return up to MAX_TITLES latest item titles; throws on non-2xx. */
  private async fetchLatestTitles(url: string): Promise<string[]> {
    const res = await fetch(url, {
      signal: AbortSignal.timeout(FETCH_TIMEOUT_MS),
    });
    if (!res.ok) throw new Error(`HTTP ${res.status}`);
    return parseFeed(await res.text())
      .slice(0, MAX_TITLES)
      .map((i) => i.title);
  }
 }
 /** Parse an LLM summary into per-line items: drop empty lines and lines without a `:` header separator, cap at MAX_ITEMS. */
 export function parseSummaryItems(reply: string): string[] {
  return reply
    .split('\n')
    .map((l) => l.trim())
    .filter((l) => l && l.includes(':'))
    .slice(0, MAX_ITEMS);
 }
 /** Hard-cut a single summary line at a word boundary near LINE_CUT_AT when it exceeds MAX_LINE_CHARS. */
 export function fitOneLine(line: string): string {
  if (line.length <= MAX_LINE_CHARS) return line;
  const slice = line.slice(0, LINE_CUT_AT);
  const at = slice.lastIndexOf(' ');
  return (at > 0 ? slice.slice(0, at) : slice).trimEnd();
 }
 /** Normalize LLM tag output: lowercase, no #, whitespace → '-', deduped. */
 export function sanitizeTags(raw: string): string[] {
  const seen = new Set<string>();
  for (const part of raw.split(',')) {
    const tag = part
      .trim()
      .toLowerCase()
      .replace(/^#+/, '')
      .replace(/\s+/g, '-');
    if (tag) seen.add(tag);
  }
  return [...seen];
 }
@@ -0,0 +1,80 @@
 import { mkdtempSync, rmSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { join } from 'node:path';
 import { DatabaseSync } from 'node:sqlite';
 import { afterEach, beforeEach, describe, expect, it } from 'vitest';
 import { RssStore } from './rss.store.js';
 describe('RssStore (real SQLite file)', () => {
  let dir: string;
  let store: RssStore;
  beforeEach(() => {
    dir = mkdtempSync(join(tmpdir(), 'mesh-bot-rss-'));
    const db = new DatabaseSync(join(dir, 'test.db'));
    store = new RssStore(db);
  });
  afterEach(() => {
    rmSync(dir, { recursive: true, force: true });
  });
  it('adds and lists sources with tags round-tripped through the comma string', () => {
    store.add({
      name: 'Hacker News',
      url: 'https://news.ycombinator.com/rss',
      tags: ['tech', 'news'],
    });
    store.add({ name: 'LWN', url: 'https://lwn.net/headlines.rss', tags: [] });
    expect(store.list()).toEqual([
      {
        name: 'Hacker News',
        url: 'https://news.ycombinator.com/rss',
        tags: ['tech', 'news'],
        createdAt: expect.any(Number),
      },
      {
        name: 'LWN',
        url: 'https://lwn.net/headlines.rss',
        tags: [],
        createdAt: expect.any(Number),
      },
    ]);
  });
  it('looks up and checks existence case-insensitively', () => {
    store.add({ name: 'My Feed', url: 'https://example.com/rss', tags: ['a'] });
    expect(store.get('my feed')?.url).toBe('https://example.com/rss');
    expect(store.get('MY FEED')).toBeDefined();
    expect(store.exists('mY fEeD')).toBe(true);
    expect(store.exists('other')).toBe(false);
  });
  it('removes case-insensitively and reports whether a row went', () => {
    store.add({ name: 'Gone', url: 'https://example.com/gone', tags: [] });
    expect(store.remove('gone')).toBe(true);
    expect(store.list()).toEqual([]);
    expect(store.remove('gone')).toBe(false);
  });
  it('collects all distinct tags across sources, sorted', () => {
    store.add({
      name: 'A',
      url: 'https://a.example/rss',
      tags: ['zeta', 'alpha'],
    });
    store.add({
      name: 'B',
      url: 'https://b.example/rss',
      tags: ['beta', 'alpha'],
    });
    expect(store.allTags()).toEqual(['alpha', 'beta', 'zeta']);
  });
  it('persists across a second connection to the same file (the production shape)', () => {
    store.add({ name: 'Durable', url: 'https://d.example/rss', tags: ['x'] });
    const db2 = new DatabaseSync(join(dir, 'test.db'));
    expect(new RssStore(db2).get('durable')?.tags).toEqual(['x']);
  });
 });
@@ -0,0 +1,108 @@
 import { DatabaseSync } from 'node:sqlite';
 /** A stored RSS source; tags are a comma-separated string in the DB, split here. */
 export interface RssSource {
  name: string;
  url: string;
  tags: string[];
  createdAt: number;
 }
 /** Idempotent — safe to call on every open (the table lives in the shared MESH_DB_PATH file). */
 export function initRssTable(db: DatabaseSync): void {
  db.exec(`CREATE TABLE IF NOT EXISTS rss_sources (
    name TEXT PRIMARY KEY,
    url TEXT NOT NULL,
    tags TEXT NOT NULL DEFAULT '',
    created_at INTEGER
  )`);
 }
 /** CRUD for the rss_sources table. Names are matched case-insensitively everywhere. */
 export class RssStore {
  constructor(private readonly db: DatabaseSync) {
    initRssTable(db);
  }
  list(): RssSource[] {
    const rows = this.db
      .prepare(
        'SELECT name, url, tags, created_at FROM rss_sources ORDER BY name',
      )
      .all() as {
      name: string;
      url: string;
      tags: string;
      created_at: number;
    }[];
    return rows.map((r) => ({
      name: r.name,
      url: r.url,
      tags: splitTags(r.tags),
      createdAt: r.created_at,
    }));
  }
  /** Case-insensitive lookup by name. */
  get(name: string): RssSource | undefined {
    const row = this.db
      .prepare(
        'SELECT name, url, tags, created_at FROM rss_sources WHERE name = ? COLLATE NOCASE',
      )
      .get(name) as
      | { name: string; url: string; tags: string; created_at: number }
      | undefined;
    return (
      row && {
        name: row.name,
        url: row.url,
        tags: splitTags(row.tags),
        createdAt: row.created_at,
      }
    );
  }
  /** Case-insensitive duplicate check. */
  exists(name: string): boolean {
    const row = this.db
      .prepare('SELECT 1 FROM rss_sources WHERE name = ? COLLATE NOCASE')
      .get(name);
    return row !== undefined;
  }
  add(source: { name: string; url: string; tags: string[] }): void {
    this.db
      .prepare(
        'INSERT INTO rss_sources (name, url, tags, created_at) VALUES (?, ?, ?, ?)',
      )
      .run(source.name, source.url, joinTags(source.tags), Date.now());
  }
  /** Case-insensitive delete; true when a row was removed. */
  remove(name: string): boolean {
    const result = this.db
      .prepare('DELETE FROM rss_sources WHERE name = ? COLLATE NOCASE')
      .run(name);
    return Number(result.changes) > 0;
  }
  /** All distinct tags across sources, sorted. */
  allTags(): string[] {
    const set = new Set<string>();
    for (const source of this.list()) {
      for (const tag of source.tags) set.add(tag);
    }
    return [...set].sort();
  }
 }
 export function splitTags(raw: string): string[] {
  return raw
    .split(',')
    .map((t) => t.trim())
    .filter(Boolean);
 }
 export function joinTags(tags: string[]): string {
  return tags.join(',');
 }
Author	SHA1	Message	Date
kamilkrzywda	3f6c02d71e	Merge pull request 'LLM timeout default 60 s → 180 s (v0.21.4)' (#47 ) from fix/llm-timeout into main CI / build + unit (push) Failing after 38s Details	2026-09-26 11:55:54 +02:00
kamilkrzywda	98b9ec5185	LLM_TIMEOUT_MS default 60 s -> 3 min (v0.21.4) CI / build + unit (pull_request) Failing after 21s Details Production incident: '#rss get lublin' at 9:41 AM failed with 'The operation was aborted due to timeout' — the LlmService call hit its 60 s cap while the local OpenAI-compatible server (qwen3.8-27b, uncontrollable reasoning tokens) was slow/busy. The same endpoint answers a trivial prompt in ~1 s when idle, so this is latency variance on the server side, not a dead endpoint. Bump the LLM_TIMEOUT_MS fallback from 60000 to 180000 (3 min headroom for slow reasoning periods); still env-overridable, only the default changed.	2026-09-26 09:52:18 +00:00
kamilkrzywda	0722c82359	Merge pull request 'Reconnect tuning: 1 min idle timeout + 5 min periodic autoreconnect (v0.21.3)' (#46 ) from fix/reconnect-tuning into main CI / build + unit (push) Failing after 42s Details	2026-09-26 11:37:41 +02:00
kamilkrzywda	1ae8d7a926	Idle timeout default 60 s; lazy periodic autoreconnect every 5 min (v0.21.3) CI / build + unit (pull_request) Failing after 22s Details The v0.21.2 frame-based watchdog works in production (it fired today: 'no decoded bridge frames for 628474 ms — forcing reconnect', and the reconnect delivered queued packets), but the bridge/radio side at 192.168.1.4 keeps killing inbound RX within ~20 min of a fresh sync, repeatedly. Two tuning changes requested by the owner: - MESH_IDLE_TIMEOUT_MS default lowered from 600000 (10 min) to 60000 (1 min). - New lazy periodic autoreconnect: MESH_RECONNECT_INTERVAL_MS (new env, default 300000 = 5 min, read at construction like the others). An interval started in onModuleInit unconditionally logs and destroys the socket so the existing close -> scheduleReconnect loop re-establishes with a fresh sync on schedule; cleared in onModuleDestroy. When not connected at tick time, destroy is a no-op and the retry loop owns recovery — no special-casing. Tests: 171 -> 172 — periodic reconnect observed end-to-end with an overridden short interval (fake bridge disconnect + re-establish); existing watchdog tests pass unchanged, comments updated to the new 60 s default.	2026-09-26 09:34:30 +00:00
kamilkrzywda	77459adc13	Merge pull request 'Watchdog: track decoded frames, not raw bytes (v0.21.2)' (#45 ) from fix/watchdog-frame-tracking into main CI / build + unit (push) Failing after 21s Details	2026-09-26 10:53:28 +02:00
kamilkrzywda	33a88f3d83	Watchdog tracks decoded frames, not raw bytes; buffer-overflow backstop (v0.21.2) CI / build + unit (pull_request) Failing after 39s Details Second production zombie slipped past v0.21.1's watchdog: text+telemetry RX dead for >1 h while TX worked and the watchdog never fired. Root cause proven at runtime via /proc/net/snmp — InSegs delta = 2 segments per 30 s (OutSegs 0): the bridge peer keeps dribbling small NON-frame bytes (~every 15 s, keepalive noise or a desynced stream) and v0.21.1 updated lastPacketAt on EVERY socket chunk, so 'no traffic for MESH_IDLE_TIMEOUT_MS' was never true even though zero valid Meshtastic frames decoded. - The 'data' handler no longer updates lastPacketAt per chunk; it is updated only when extractFrames yields >=1 valid packet (the reset in the 'connect' handler is unchanged), so a stream that decodes nothing trips the watchdog after MESH_IDLE_TIMEOUT_MS even while raw bytes keep arriving. - Buffer-overflow backstop: if the undecoded frame buffer exceeds MESH_MAX_FRAME_BUFFER (new env, default 256000) — e.g. one data event of a desynced stream that never forms frames — log ERROR and destroy the socket; the existing close -> scheduleReconnect loop self-heals it. The undecoded buffer is also reset on every (re)connect so leftover garbage from a dead session can't re-trigger the backstop or corrupt the first frames of a healthy new stream. Tests: 169 -> 171 — raw non-frame bytes do NOT keep the watchdog alive (garbage-only stream forces disconnect + reconnect, today's incident shape), and an undecoded chunk over MESH_MAX_FRAME_BUFFER triggers destroy + a fresh session that decodes normally (cap env-overridden to 100 since Node delivers socket data in ~64 KB events, far below the 256_000 default).	2026-09-26 08:50:27 +00:00
kamilkrzywda	306756c63b	Merge pull request 'Bridge idle watchdog + forced reconnect (v0.21.1)' (#44 ) from fix/bridge-idle-reconnect into main CI / build + unit (push) Successful in 45s Details	2026-09-26 08:53:06 +02:00
kamilkrzywda	af1c77fd54	Force reconnect when the bridge connection goes silent (v0.21.1) CI / build + unit (pull_request) Successful in 1m8s Details Production incident: the bridge TCP connection went zombie — outbound sends kept working for ~10 h while inbound packets stopped entirely, and /api/status stayed connected:true because nothing detects inbound silence on an established connection. - Track lastPacketAt: updated on every chunk received from the bridge in the lowest-level socket 'data' path (any frame kind, decodable or not) and reset when a connection successfully starts, so a fresh connection can't self-trigger. - Idle watchdog: a 30 s interval checks connected AND now - lastPacketAt > MESH_IDLE_TIMEOUT_MS (new env, default 600000 = 10 min) — logs WARN with the idle duration and destroys the socket so the EXISTING connect/retry loop re-establishes it with a fresh sync. No changes to connect-error retry or backoff; this only adds detection for established-but-silent connections. - TCP keepalive: socket.setKeepAlive(true, 30_000) on the bridge socket — cheap insurance against dead peers at the TCP level. Tests (fake-bridge based): silence past an overridden timeout forces a disconnect + reconnect; inbound traffic keeps resetting the idle clock so no false trigger; the default timeout does not fire in a test window; and setKeepAlive(true, 30_000) is asserted on the socket. checkIdle() is public so tests drive a tick without waiting for the real interval (like flushHistory()).	2026-09-26 06:50:01 +00:00
kamilkrzywda	73ce49c741	Merge pull request '#rss get: 3-5 separate messages with short headers (v0.21.0)' (#43 ) from feat/rss-multi-message into main CI / build + unit (push) Successful in 41s Details	2026-09-25 22:12:05 +02:00
kamilkrzywda	cdd52a3ddb	Send #rss get summaries as 3-5 separate mesh messages (v0.21.0) CI / build + unit (pull_request) Successful in 1m20s Details The single-message summary was too small (owner request). The summarizer prompt now asks for exactly 3-5 lines, one item per line, in the format '<short header>: <one or two short sentences>' with a <=20-char header, no intro/outro/numbering. maxTokens stays 2500 (reasoning-token headroom). The reply is parsed into items: drop empty lines and lines without a ':' header separator, cap at 5; fewer than 3 valid lines sends what we got (no failure/retry), zero valid lines sends nothing. Each item goes out as its own mesh message via respond(id, line) - all threaded to the trigger packet id on its channel. Per-item backstop fitOneLine() hard-cuts any line >185 chars at a word boundary near 180 so every item fits one packet; the old whole-reply fitOnePacket() cut is gone. CommandService sends array replies line by line through the same routing as single replies (respond per line, or legacy sendText fallback per line when there is no packet id). LLM failure path unchanged: single 'summary failed' reply.	2026-09-25 20:09:16 +00:00
kamilkrzywda	172e7bed9c	Merge pull request 'Cap #rss get summaries to one mesh packet (v0.20.1)' (#42 ) from fix/rss-summary-length into main CI / build + unit (push) Successful in 1m10s Details	2026-09-25 21:25:02 +02:00
kamilkrzywda	e2d712a26c	Cap #rss get summaries to one mesh packet (v0.20.1) CI / build + unit (pull_request) Successful in 42s Details Replies >~190 chars fragment into fire-and-forget packets recipients often never receive; old prompt produced ~326-334 char replies. Prompt now asks for at most 3 short bullet lines, each under 45 chars, bullets only (verified live: exactly 3 compliant bullets, ~110 chars). fitOnePacket() backstop cuts any over-length reply at complete-bullet boundaries so delivery is one packet even if the model ignores the prompt. maxTokens 200 -> 2500 on the summary chat(): empirically verified that this server's reasoning tokens count against max_tokens (cap 150 -> completion 150 of which 105 were reasoning; cap 500 fully consumed by reasoning, zero visible content) and thinking is uncontrollable server-side (/no_think, chat_template_kwargs.enable_thinking, thinking_budget all ignored), observed 32..1776 tokens for this task. 2500 covers every observed run + ~80 content tokens, worst case ~42 s under the 60 s LLM timeout.	2026-09-25 19:22:13 +00:00
kamilkrzywda	a8ce04d3f8	Merge pull request 'Add #rss command family with LLM tags and summaries (v0.20.0)' (#41 ) from feat/rss-command into main CI / build + unit (push) Successful in 40s Details Add #rss command family with LLM tags and summaries (v0.20.0) (#41)	2026-09-25 20:46:56 +02:00
kamilkrzywda	eda1cbd125	Add #rss command family with LLM tags and summaries (v0.20.0) CI / build + unit (pull_request) Successful in 1m15s Details #rss subcommands on the command channel: help / add <url> <name> / remove <name> / tags / sources / get <name\|#tag>. Sources are stored in a new rss_sources table in the existing MESH_DB_PATH file (second node:sqlite connection, case-insensitive names); feeds parsed with fast-xml-parser (RSS 2.0 + Atom); AI tags and headline summaries via injected LlmService.chat() with bounded maxTokens (50/200). CommandService gains prefix registration so one handler owns the whole #rss family while #ping stays an exact match; wired in CommandModule's factory — still no constructor-level cycle, no forwardRef. One dead feed does not sink a tag summary.	2026-09-25 18:44:06 +00:00