From 0da25dd15b0aabf74da0676d182308ba1e5588be Mon Sep 17 00:00:00 2001 From: TeTeHacko Date: Tue, 3 Nov 2026 00:20:03 +0100 Subject: [PATCH] meshcore-repeater-observer 0.1.0 Reads a MeshCore repeater's console over BLE or USB and publishes what it hears: the `pktlog` raw-frame feed in the meshcoretomqtt format (community analyzer with a JWT signed by the node's key, audience = broker hostname, or an own broker without auth) and optionally stats, `nodes`, `rxlog` to a local MQTT broker. Needs the observer build of meshcore-tth. Tested on a XIAO with the observer build over USB and over BLE: feed in the meshcoretomqtt format, packet hashes matching those of other observers. Unit tests for the parsers, the packet transform, the Ed25519 signature (checked against `cryptography`), the JWT and paho-mqtt 1.x/2.x; README (Czech), AGENTS.md, CI, Renovate. Co-Authored-By: Claude Opus 5.5 --- .gitea/workflows/ci.yml | 44 ++ .gitignore | 10 + .yamllint | 5 + AGENTS.md | 25 + CLAUDE.md | 1 + LICENSE | 21 + README.md | 165 ++++ meshcore_repeater_observer.py | 1393 +++++++++++++++++++++++++++++++++ pyproject.toml | 37 + tests/test_observer.py | 167 ++++ 10 files changed, 1868 insertions(+) create mode 100644 .gitea/workflows/ci.yml create mode 100644 .gitignore create mode 100644 .yamllint create mode 100644 AGENTS.md create mode 100644 CLAUDE.md create mode 100644 LICENSE create mode 100644 README.md create mode 100644 meshcore_repeater_observer.py create mode 100644 pyproject.toml create mode 100644 tests/test_observer.py diff --git a/.gitea/workflows/ci.yml b/.gitea/workflows/ci.yml new file mode 100644 index 0000000..d31d317 --- /dev/null +++ b/.gitea/workflows/ci.yml @@ -0,0 +1,44 @@ +# Lint + tests on every push and PR; the image is built by image.yml. +name: ci + +"on": + push: + pull_request: + workflow_dispatch: + +env: + RUFF_VERSION: "0.15.7" + MYPY_VERSION: "1.19.1" + YAMLLINT_VERSION: "1.38.0" + +jobs: + test: + runs-on: ubuntu-latest + steps: + - uses: actions/checkout@v7 + + - name: gitleaks + uses: https://git.rfa.cz/tth-pub/ci-actions/gitleaks@v11 + with: + mode: block + + - uses: actions/setup-python@v7 + with: + python-version: "3.15" + + - name: Install + run: | + set -euo pipefail + python -m pip install --quiet ".[dev]" \ + "ruff==$RUFF_VERSION" "mypy==$MYPY_VERSION" "yamllint==$YAMLLINT_VERSION" + + - name: Lint + run: | + set -euo pipefail + ruff check . + ruff format --check . + mypy meshcore_repeater_observer.py + yamllint .gitea .yamllint + + - name: Tests + run: python -m pytest -q diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..e200e00 --- /dev/null +++ b/.gitignore @@ -0,0 +1,10 @@ +__pycache__/ +*.egg-info/ +.venv/ +.pytest_cache/ +.mypy_cache/ +.ruff_cache/ +build/ +dist/ +cursors.json +*.env diff --git a/.yamllint b/.yamllint new file mode 100644 index 0000000..4d38c5c --- /dev/null +++ b/.yamllint @@ -0,0 +1,5 @@ +extends: default +rules: + line-length: {max: 120} + document-start: disable + truthy: {check-keys: false} diff --git a/AGENTS.md b/AGENTS.md new file mode 100644 index 0000000..a828605 --- /dev/null +++ b/AGENTS.md @@ -0,0 +1,25 @@ +# Instructions for an AI agent setting this up + +meshcore-repeater-observer reads a MeshCore repeater's console and publishes +what the repeater hears. README.md is the reference; these are the rules. + +1. **Read only, with two exceptions the user must approve:** the observer + itself sets the node's clock (`time `) and, for the community feed, + reads its private key (`get prv.key`) into memory. Never send other CLI + commands to the repeater (`set …`, `reboot`, `erase`, `advert`) — it is + part of a community network. +2. The repeater needs the observer build of meshcore-tth. Ask which board and + firmware it runs; do not flash anything yourself. +3. Prefer USB (`/dev/serial/by-id/…`, never `/dev/ttyACM0`). BLE: the console + is off after flashing; the user turns it on (`ble on`) after setting their + own PIN. Pairing is interactive (`bluetoothctl pair`) — the user does it. + Never `bluetoothctl remove` a paired repeater. +4. Community feed only for a node on the Czech preset (869.432 / 62.5 / SF7 / + CR5), with `MC_OBS_IATA` set; leave `MC_OBS_AUDIENCE` at its default. +5. Passwords and PINs go to the env file (mode 600), never into commands you + print, commits or logs. The private key never leaves the process. +6. Done = the log shows `observer: připojen k …` and packets are counted; + on the community analyzer the node appears under observers within minutes. + +Developing: `python3 -m pytest`, `ruff check`, `ruff format --check`, +`mypy meshcore_repeater_observer.py`. `--help` must work without bleak/paho. diff --git a/CLAUDE.md b/CLAUDE.md new file mode 100644 index 0000000..43c994c --- /dev/null +++ b/CLAUDE.md @@ -0,0 +1 @@ +@AGENTS.md diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000..8b3ca74 --- /dev/null +++ b/LICENSE @@ -0,0 +1,21 @@ +MIT License + +Copyright (c) 2026 TeTeHacko + +Permission is hereby granted, free of charge, to any person obtaining a copy +of this software and associated documentation files (the "Software"), to deal +in the Software without restriction, including without limitation the rights +to use, copy, modify, merge, publish, distribute, sublicense, and/or sell +copies of the Software, and to permit persons to whom the Software is +furnished to do so, subject to the following conditions: + +The above copyright notice and this permission notice shall be included in all +copies or substantial portions of the Software. + +THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR +IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, +FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE +AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER +LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, +OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE +SOFTWARE. diff --git a/README.md b/README.md new file mode 100644 index 0000000..082ae3b --- /dev/null +++ b/README.md @@ -0,0 +1,165 @@ +# meshcore-repeater-observer + +Udělá z MeshCore **repeateru observer**: přes jeho konzoli (Bluetooth nebo USB) +průběžně čte, co repeater slyší, a posílá to do MQTT — do komunitního +analyzeru ([analyzer.meshcore.cz](https://analyzer.meshcore.cz)), do vlastního +CoreScope, nebo obojí. Žádné druhé rádio vedle repeateru není potřeba. + +``` +repeater ── BLE / USB ── meshcore-repeater-observer ──┬── MQTT ── komunitní analyzer + (observer build) └── MQTT ── vlastní broker / CoreScope +``` + +*English: turns a MeshCore repeater into an observer by reading its console +(`pktlog`, `rxlog`, `nodes`) over BLE or USB and publishing to MQTT in the +meshcoretomqtt format. Docs below are Czech; `--help` is English.* + +## Kdy to dává smysl + +- Repeater už stojí (stožár, střecha) a vedle něj nejde nebo nechcete dát + další rádio. Počítač s Bluetooth v dosahu, nebo USB kabel, stačí. +- Jinak je jednodušší samostatný observer na [openHopu](https://github.com/openhop-dev/openhop_repeater), + který MQTT do analyzerů umí sám a repeater nechá na pokoji. + +## Co je potřeba + +1. **Repeater s observer buildem** firmwaru [meshcore-tth](https://git.rfa.cz/tth-pub/meshcore-tth): + soubory `*_repeater-observer-*` v [Releases](https://git.rfa.cz/tth-pub/meshcore-tth/releases) + (XIAO, SenseCAP Solar, RAK4631, T1000-E, Heltec T114; `.uf2` přetažením na + disk bootloaderu, `.zip` pro DFU přes BLE nebo USB). Běžný MeshCore + firmware příkazy `pktlog`/`rxlog` nemá; observer pak feed tiše vynechá. + Observer build má Bluetooth konzoli **po flashi vypnutou** a zástupný PIN + `123456`: nejdřív si nastavte vlastní PIN a admin heslo, pak `ble on`. +2. **Linux** s Pythonem 3.10+ (Raspberry Pi stačí), u BLE s BlueZ. +3. Pro komunitní analyzer: repeater na **českém nastavení** (869,432 MHz / + 62,5 kHz / SF7 / CR5) — komunita chce jen uzly na CZ presetu. + +## Instalace + +```bash +pipx install git+https://git.rfa.cz/tth-pub/meshcore-repeater-observer +meshcore-repeater-observer --help +``` + +### USB (doporučeno) + +Repeater na USB kabelu; port najdete v `ls -l /dev/serial/by-id/` (trvalé +jméno, `/dev/ttyACM0` se po přepojení mění). + +```bash +MC_SERIAL_PORT=/dev/serial/by-id/usb-…-if00 \ +MC_OBS_ENABLE=1 MC_OBS_IATA=PRG \ +meshcore-repeater-observer +``` + +USB se s rádiem repeateru nepere a čte se nepřetržitě. + +### Bluetooth + +1. Na repeateru (USB konzole, nebo z aplikace přes admin CLI) nastavte vlastní + PIN a heslo a zapněte konzoli — po flashi je **vypnutá**: + `ble on` (uloží se). Pozor: dokud má nějaký počítač otevřený jeho USB port, + **Bluetooth konzole se neukáže** (neběží BLE advertising, nejde se + připojit). Na repeater jako takový to vliv nemá — přijímá, přeposílá + a posílá LoRa adverty dál normálně. Jen BLE a USB konzole se střídají. +2. Jednou spárujte: + + ``` + bluetoothctl + agent KeyboardOnly + default-agent + scan on # počkejte na MAC repeateru + pair AA:BB:CC:DD:EE:FF + trust AA:BB:CC:DD:EE:FF + quit + ``` + +3. Spusťte s `MC_BLE_ADDR=AA:BB:CC:DD:EE:FF` místo `MC_SERIAL_PORT`. + +Observer se po každém vyčtení odpojí a `MC_BLE_OFF_INTERVAL` sekund (výchozí +120) počká: starší firmware s připojeným BLE klientem zahazoval přímé +(DIRECT) pakety, které měl přeposlat. V meshcore-tth je to opravené, interval +jde zkrátit; pokud log hlásí `pktlog DROP`, ring se během pauzy přepsal. + +### Jako služba (systemd) + +```ini +# /etc/systemd/system/meshcore-repeater-observer.service +[Unit] +Description=MeshCore repeater observer +Wants=network-online.target bluetooth.target +After=network-online.target bluetooth.target + +[Service] +EnvironmentFile=/etc/meshcore-repeater-observer.env +ExecStart=/opt/meshcore-repeater-observer/bin/meshcore-repeater-observer +StateDirectory=meshcore-repeater-observer +Restart=on-failure +RestartSec=30 + +[Install] +WantedBy=multi-user.target +``` + +V `/etc/meshcore-repeater-observer.env` řádky `MC_…=…` z tabulky níž. +`StateDirectory` drží pozici v ringu repeateru, takže restart nic neztratí. + +## Nastavení (proměnné prostředí) + +| proměnná | výchozí | | +|---|---|---| +| `MC_SERIAL_PORT` | — | USB konzole repeateru (`/dev/serial/by-id/…`) | +| `MC_BLE_ADDR` / `MC_BLE_NAME` | — | BLE: MAC, nebo jméno, které repeater advertuje | +| `MC_NODE` | `repeater` | jméno v lokálních MQTT tématech | +| `MC_OBS_ENABLE` | vypnuto | `1` = observer feed z `pktlog` | +| `MC_OBS_IATA` | — | **povinné s feedem**: kód letiště regionu (`PRG`, `BRQ`, `OSR`, …) | +| `MC_OBS_MQTT_HOST` | `mqtt1.meshcore.cz` | broker feedu | +| `MC_OBS_MQTT_PORT` / `MC_OBS_TRANSPORT` / `MC_OBS_TLS` | `443` / `websockets` / `1` | | +| `MC_OBS_AUTH` | `token` | `token` = JWT podepsaný klíčem uzlu; `none` = vlastní broker bez hesla | +| `MC_OBS_AUDIENCE` | = `MC_OBS_MQTT_HOST` | audience v JWT; komunitní brokery chtějí svůj hostname | +| `MC_OBS_OWNER` / `MC_OBS_EMAIL` / `MC_OBS_MODEL` | — / — / `MeshCore repeater` | volitelné údaje do tokenu a statusu | +| `MC_MQTT_HOST` | — | lokální MQTT (volitelné): stats, `nodes`, `rxlog`, kopie paketů | +| `MC_MQTT_PORT` / `MC_MQTT_TLS` / `MC_MQTT_USER` / `MC_MQTT_PASS` | `1883` / — | | +| `MC_MQTT_TOPIC` | `repeater-observer/` | kořen lokálních témat | +| `MC_INTERVAL` | `300` | s mezi plným čtením (stats, senzory, sousedé) | +| `MC_NODES_INTERVAL` / `MC_RXLOG_INTERVAL` | `60` / `5` | registr `nodes` / vyčítání `rxlog`+`pktlog` | +| `MC_BLE_OFF_INTERVAL` | `120` | BLE: pauza bez spojení mezi vyčteními | +| `MC_CURSOR_FILE` | `$STATE_DIRECTORY/cursors.json` | pozice v ringu repeateru | + +Komunitní brokery: `mqtt1.meshcore.cz`, `mqtt2.meshcore.website`, +`mqtt.meshcore-analyzer.eu` (všechny WSS :443, JWT). Audience musí být +hostname brokeru — s jinou broker odpoví `not authorised`. + +Vlastní CoreScope: `MC_OBS_MQTT_HOST= MC_OBS_MQTT_PORT=1883 +MC_OBS_TRANSPORT=tcp MC_OBS_TLS=0 MC_OBS_AUTH=none`. + +## Klíč uzlu + +Pro komunitní feed se observer přihlašuje tokenem podepsaným **klíčem +repeateru**, takže si při spojení přečte z konzole `get prv.key`. Klíč drží jen +v paměti procesu, nikam ho nezapisuje ani neloguje, a před použitím ověří, že +k němu patří veřejný klíč uzlu. S `MC_OBS_AUTH=none` se klíč nečte vůbec. + +## Co se publikuje + +- Feed (`MC_OBS_ENABLE=1`): `meshcore///packets` a `…/status` + ve formátu [meshcoretomqtt](https://github.com/Cisien/meshcoretomqtt). +- Lokálně (`MC_MQTT_HOST`), pod `MC_MQTT_TOPIC`: `neighbours`, `stats`, + `sensors`, `nodes` (retained), `rxlog`, `packets`, `ble`/`serial` stav. + +Observer navíc srovnává hodiny repeateru bez GPS (`time `), když jsou +pozadu: starý čas v advertech by ostatní uzly zahazovaly jako replay. + +## Když to nejde + +| příznak | příčina | +|---|---| +| `config: …` a konec | chybí transport (`MC_SERIAL_PORT`/`MC_BLE_ADDR`), IATA, nebo není kam publikovat | +| `BLE … nenalezen ve scanu` | repeater má BLE vypnuté (`ble on`), má otevřený USB port (BLE se pak neukazuje), nebo BlueZ visí na starém spojení: `bluetoothctl disconnect ` — **nikdy `remove`**, to zruší spárování | +| `FW nezná pktlog` | repeater nemá observer build | +| `broker odmítl spojení rc=5` | špatná audience, nebo uzel není na CZ presetu | +| `pktlog DROP` | ring repeateru se přepsal dřív, než se vyčetl: kratší `MC_BLE_OFF_INTERVAL`, nebo USB | + +## Licence + +MIT. diff --git a/meshcore_repeater_observer.py b/meshcore_repeater_observer.py new file mode 100644 index 0000000..1dd5d50 --- /dev/null +++ b/meshcore_repeater_observer.py @@ -0,0 +1,1393 @@ +#!/usr/bin/env python3 +"""MeshCore repeater observer: reads a repeater's console over BLE or USB and +publishes what it hears to MQTT. + +For a repeater running the observer build of the meshcore-tth fork (console +commands `pktlog`, `rxlog`, `nodes`): no second radio next to it is needed. + + * `pktlog` raw frames -> observer feed in the meshcoretomqtt format: the + community analyzer (JWT signed with the node's own key) or your + own CoreScope broker (no auth) + * `rxlog`, `nodes`, `neighbors`, stats, `sensor read` -> local MQTT (optional) + +Configuration: environment variables only (MC_*), see README.md. + + MC_BLE_ADDR=AA:BB:CC:DD:EE:FF or MC_SERIAL_PORT=/dev/serial/by-id/... + MC_OBS_ENABLE=1 MC_OBS_IATA=PRG observer feed to mqtt1.meshcore.cz + MC_MQTT_HOST=localhost optional local MQTT copy + stats + +BLE: pair once with the node's PIN (bluetoothctl pair/trust). USB is simpler +and keeps the node's BLE off. +""" + +import sys + +if {"-h", "--help"} & set(sys.argv[1:]): + print(__doc__.strip()) + sys.exit(0) + +import asyncio +import base64 +import hashlib +import json +import logging +import os +import re +import time +from datetime import datetime, timezone + +import paho.mqtt.client as mqtt +from bleak import BleakClient, BleakScanner + +# Nordic UART Service (NUS) — stejné UUID jako Adafruit BLEUart v našem FW +NUS_SVC = "6e400001-b5a3-f393-e0a9-e50e24dcca9e" +NUS_RX = "6e400002-b5a3-f393-e0a9-e50e24dcca9e" # klient → zařízení (write) +NUS_TX = "6e400003-b5a3-f393-e0a9-e50e24dcca9e" # zařízení → klient (notify) + +BLE_ADDR = os.environ.get("MC_BLE_ADDR", "") +BLE_NAME = os.environ.get("MC_BLE_NAME", "") +NODE = os.environ.get("MC_NODE", "repeater") +# Když je nastaven, jede se přes USB konzoli místo BLE. VŽDY /dev/serial/by-id/... +# podle sériového čísla — ttyACM* se po každém replugu přečísluje a mířil bys na +# jinou desku. +SERIAL_PORT = os.environ.get("MC_SERIAL_PORT", "") +INTERVAL = int(os.environ.get("MC_INTERVAL", "300")) # plný scrape (neighbors+stats+sensors) +NODES_INTERVAL = int(os.environ.get("MC_NODES_INTERVAL", "60")) # registr `nodes` (mění se pomalu) +RXLOG_INTERVAL = int(os.environ.get("MC_RXLOG_INTERVAL", "5")) # firehose `rxlog`+`pktlog` (drain přes cursor) +# Duty cycle: connect → drain → DISCONNECT → pauza. Starší FW s připojeným BLE +# klientem tiše zahazoval DIRECT pakety, které měl přeposlat (SoftDevice/LoRa +# koexistence, opraveno ve forku 21. 7. 2026 širším conn intervalem a TX retry). +# Pauza ale znamená, že se pktlog ring může mezitím přepsat (DROP v logu): +# na opraveném FW jde MC_BLE_OFF_INTERVAL zkrátit, nejlepší je USB. +OFF_INTERVAL = int(os.environ.get("MC_BLE_OFF_INTERVAL", "120")) # sekundy BEZ spojení mezi draity +# Lokální MQTT je volitelné: prázdný MC_MQTT_HOST = jen observer feed. +MQTT_HOST = os.environ.get("MC_MQTT_HOST", "") +MQTT_PORT = int(os.environ.get("MC_MQTT_PORT", "1883")) +# Mimo `meshcore/#`: tam poslouchá ingest CoreScope a tyhle dokumenty nejsou jeho formát. +MQTT_TOPIC = os.environ.get("MC_MQTT_TOPIC", f"repeater-observer/{NODE}") +MQTT_USER = os.environ.get("MC_MQTT_USER", "") +MQTT_PASS = os.environ.get("MC_MQTT_PASS", "") +MQTT_TLS = os.environ.get("MC_MQTT_TLS", "").lower() in ("1", "true", "yes") +CMD = os.environ.get("MC_CMD", "neighbors") +REPLY_WAIT = float(os.environ.get("MC_REPLY_WAIT", "12")) # tvrdý strop čtení odpovědi +FIRST_BYTE_WAIT = float(os.environ.get("MC_FIRST_BYTE_WAIT", "6")) # čekání na začátek odpovědi (BLE) + +# --- Observer feed ---------------------------------------------------------- +# Surové rámce z `pktlog` → broker ve formátu meshcoretomqtt +# (github.com/Cisien/meshcoretomqtt). Komunitní cluster: mqtt1.meshcore.cz, +# mqtt2.meshcore.website, mqtt.meshcore-analyzer.eu (WSS :443). Auth: JWT +# podepsaný Ed25519 klíčem uzlu, username `v1_`, AUDIENCE = HOSTNAME +# BROKERU (s audience analyzer.meshcore.cz broker odmítne: not authorised). +# Topicy `meshcore///{packets,status}`. Vlastní CoreScope: +# MC_OBS_MQTT_HOST= MC_OBS_MQTT_PORT=1883 MC_OBS_TRANSPORT=tcp +# MC_OBS_TLS=0 MC_OBS_AUTH=none (klíč uzlu se pak vůbec nečte). +OBS_ENABLE = os.environ.get("MC_OBS_ENABLE", "").lower() in ("1", "true", "yes") +OBS_HOST = os.environ.get("MC_OBS_MQTT_HOST", "mqtt1.meshcore.cz") +OBS_PORT = int(os.environ.get("MC_OBS_MQTT_PORT", "443")) +OBS_TRANSPORT = os.environ.get("MC_OBS_TRANSPORT", "websockets") # websockets | tcp +OBS_TLS = os.environ.get("MC_OBS_TLS", "1").lower() in ("1", "true", "yes") +OBS_AUTH = os.environ.get("MC_OBS_AUTH", "token") # token (JWT) | none (vlastní broker) +OBS_AUDIENCE = os.environ.get("MC_OBS_AUDIENCE", "") or OBS_HOST +OBS_IATA = os.environ.get("MC_OBS_IATA", "") # povinné: letiště regionu, PRG/BRQ/OSR/… +OBS_OWNER = os.environ.get("MC_OBS_OWNER", "") # volitelné JWT claims +OBS_EMAIL = os.environ.get("MC_OBS_EMAIL", "") +OBS_MODEL = os.environ.get("MC_OBS_MODEL", "MeshCore repeater") +OBS_TOKEN_TTL = int(os.environ.get("MC_OBS_TOKEN_TTL", "3600")) +__version__ = "0.1.0" +OBS_CLIENT_VER = f"meshcore-repeater-observer {__version__}" + +logging.basicConfig(level=logging.INFO, format="%(asctime)s %(levelname)s %(message)s") +log = logging.getLogger("repeater-observer") + + +# --- Ed25519 podpis (čistý Python, orlp key layout) --------------------------- +# MeshCore FW používá orlp/ed25519: `get prv.key` vrací 64 B = (clamped scalar a +# ‖ sha512 prefix), NE 32B RFC-8032 seed — cryptography/pynacl s ním neumí. +# Podepisuje se 1× za hodinu (JWT refresh), takže pomalá čistá implementace +# bohatě stačí a venv nepotřebuje žádnou novou závislost. Matematika = RFC 8032 +# (stejné rovnice jako orlp sign.c); ověřeno testem proti balíku cryptography. +_ED_Q = 2**255 - 19 +_ED_L = 2**252 + 27742317777372353535851937790883648493 +_ED_D = -121665 * pow(121666, _ED_Q - 2, _ED_Q) % _ED_Q +_ED_I = pow(2, (_ED_Q - 1) // 4, _ED_Q) + + +def _ed_recover_x(y): + xx = (y * y - 1) * pow(_ED_D * y * y + 1, _ED_Q - 2, _ED_Q) % _ED_Q + x = pow(xx, (_ED_Q + 3) // 8, _ED_Q) + if (x * x - xx) % _ED_Q: + x = x * _ED_I % _ED_Q + if x % 2: + x = _ED_Q - x + return x + + +_ED_BY = 4 * pow(5, _ED_Q - 2, _ED_Q) % _ED_Q +_ED_BX = _ed_recover_x(_ED_BY) +_ED_B = (_ED_BX, _ED_BY, 1, _ED_BX * _ED_BY % _ED_Q) # extended coordinates + + +def _ed_add(p, q): + x1, y1, z1, t1 = p + x2, y2, z2, t2 = q + a = (y1 - x1) * (y2 - x2) % _ED_Q + b = (y1 + x1) * (y2 + x2) % _ED_Q + c = 2 * t1 * t2 * _ED_D % _ED_Q + d = 2 * z1 * z2 % _ED_Q + e, f, g, h = b - a, d - c, d + c, b + a + return (e * f % _ED_Q, g * h % _ED_Q, f * g % _ED_Q, e * h % _ED_Q) + + +def _ed_mul(p, e): + q = (0, 1, 1, 0) # neutrální prvek + while e: + if e & 1: + q = _ed_add(q, p) + p = _ed_add(p, p) + e >>= 1 + return q + + +def _ed_compress(p): + x, y, z, _ = p + zi = pow(z, _ED_Q - 2, _ED_Q) + x, y = x * zi % _ED_Q, y * zi % _ED_Q + return int.to_bytes(y | ((x & 1) << 255), 32, "little") + + +def ed25519_sign_orlp(msg: bytes, pub32: bytes, prv64: bytes) -> bytes: + a = int.from_bytes(prv64[:32], "little") # clamped scalar (z keygenu) + prefix = prv64[32:] + r = int.from_bytes(hashlib.sha512(prefix + msg).digest(), "little") % _ED_L + rb = _ed_compress(_ed_mul(_ED_B, r)) + k = int.from_bytes(hashlib.sha512(rb + pub32 + msg).digest(), "little") % _ED_L + s = (r + k * a) % _ED_L + return rb + int.to_bytes(s, 32, "little") + + +def _b64url(data: bytes) -> str: + return base64.urlsafe_b64encode(data).rstrip(b"=").decode() + + +def make_auth_token(pub_hex: str, prv_hex: str) -> str: + """JWT kompatibilní s meshcoretomqtt/auth_token.py: header {alg: Ed25519}, + payload {publicKey, iat, exp, aud, [owner, email,] client}, podpis = + UPPERCASE HEX (ne base64url!) přes ASCII 'header.payload'.""" + now = int(time.time()) + payload = {"publicKey": pub_hex.upper(), "iat": now, "exp": now + OBS_TOKEN_TTL} + if OBS_AUDIENCE: + payload["aud"] = OBS_AUDIENCE + if OBS_TLS: # owner/email jen přes ověřené TLS (stejné pravidlo jako reference) + if OBS_OWNER: + payload["owner"] = OBS_OWNER + if OBS_EMAIL: + payload["email"] = OBS_EMAIL.lower() + payload["client"] = OBS_CLIENT_VER + head = _b64url(json.dumps({"alg": "Ed25519", "typ": "JWT"}, separators=(",", ":")).encode()) + body = _b64url(json.dumps(payload, separators=(",", ":")).encode()) + signing_input = f"{head}.{body}" + sig = ed25519_sign_orlp(signing_input.encode(), bytes.fromhex(pub_hex), bytes.fromhex(prv_hex)) + return f"{signing_input}.{sig.hex().upper()}" + + +# --- MeshCore wire frame → meshcoretomqtt packet ------------------------------ + +PAYLOAD_TYPE_TRACE = 9 + + +def parse_raw_frame(raw: bytes): + """Wire frame: header | [4B transport codes] | path_len | path | payload. + Vrací (route, ptype, path_len_byte, payload), None na nesmyslnou délku.""" + if len(raw) < 2: + return None + header = raw[0] + route = header & 0x03 # 0=trans-flood 1=flood 2=direct 3=trans-direct + ptype = (header >> 2) & 0x0F + i = 5 if route in (0, 3) else 1 # transport codes = 4 B navíc + if i >= len(raw): + return None + plb = raw[i] + i += 1 # bit-packed: (hash_size-1)<<6 | count + i += ((plb >> 6) + 1) * (plb & 63) # přeskoč path bajty + if i > len(raw): + return None + return route, ptype, plb, raw[i:] + + +def meshcore_packet_hash(ptype: int, path_len_byte: int, payload: bytes) -> str: + """MeshCore SHA packet hash = SHA256(type ‖ [path_len u TRACE] ‖ payload)[:8] + (Packet::calculatePacketHash) — korelační klíč mezi observery na analyzeru.""" + h = hashlib.sha256() + h.update(bytes([ptype])) + if ptype == PAYLOAD_TYPE_TRACE: + h.update(bytes([path_len_byte])) + h.update(payload) + return h.digest()[:8].hex().upper() + + +def obs_packet_json(rec): + """pktlog záznam → meshcoretomqtt 'packets' JSON (viz bridge/message_parser.py + v Cisien/meshcoretomqtt — analyzer na tenhle tvar spoléhá). None = neparsovatelné.""" + try: + raw = bytes.fromhex(rec["raw"]) + except ValueError: + return None + parsed = parse_raw_frame(raw) + if not parsed: + return None + route, ptype, plb, payload = parsed + when = rec["when"] + # Záchytná síť pro záznamy zalogované DŘÍV, než observer hodiny srovnal (viz + # sync_clock): v ringu uzlu leží dál `when` z roku 2024 a přepsat je nejde. + # Rok 2025 jako podlaha, protože `VolatileRTCClock` startuje v květnu 2024. + if when < 1735689600: + when = int(time.time()) + dt = datetime.fromtimestamp(when, tz=timezone.utc) + msg = { + "origin": OBS.name, + "origin_id": OBS.pub, + "timestamp": dt.isoformat(), + "type": "PACKET", + "direction": "rx", + "time": dt.strftime("%H:%M:%S"), + "date": f"{dt.day}/{dt.month}/{dt.year}", + "len": str(len(raw)), + "packet_type": str(ptype), + "route": "D" if route in (2, 3) else "F", + "payload_len": str(len(payload)), + "raw": rec["raw"].upper(), + "SNR": str(int(rec["snr"] / 4)), # FW loguje celé dB (trunc k nule jako C cast) + "RSSI": str(rec["rssi"]), + "score": None, # pktlog score nenese; reference ho má taky jen někdy + "duration": None, + "hash": meshcore_packet_hash(ptype, plb, payload), + } + # reference přidává "path" (= dest ← src hash bajty) jen u direct routed typů + if route in (2, 3) and ptype in (0, 1, 2, 8) and len(payload) >= 2: + msg["path"] = f"{payload[1]:02X} -> {payload[0]:02X}" + return msg + + +class Observer: + """Druhý MQTT sink: komunitní broker (websockets+TLS, JWT auth). Identita + uzlu (jméno, pubkey, PRIVÁTNÍ KLÍČ) se čte z BLE konzole při init session; + klíč žije výhradně v RAM tohoto procesu. Token se obnovuje při každém + (re)connectu — broker spojení při expiraci tokenu utne a paho auto-reconnect + si přes on_disconnect řekne o čerstvý.""" + + def __init__(self): + self.name = self.pub = self._prv = None + self.fw_ver = self.radio = "unknown" + self.client = None + self.connected = False + self.published = 0 + + def topic(self, kind): + return f"meshcore/{OBS_IATA}/{self.pub}/{kind}" + + def _status_json(self, status, stats=None): + msg = { + "status": status, + "timestamp": datetime.now(timezone.utc).isoformat(), + "origin": self.name, + "origin_id": self.pub, + "radio": self.radio, + "model": OBS_MODEL, + "firmware_version": self.fw_ver, + "client_version": OBS_CLIENT_VER, + } + if stats: + msg["stats"] = stats + return json.dumps(msg) + + def _set_fresh_creds(self): + if OBS_AUTH != "token": + return # vlastní broker (např. CoreScope) jede bez autentizace + self.client.username_pw_set(f"v1_{self.pub}", make_auth_token(self.pub, self._prv)) + + def start(self, name, pub, prv, fw_ver, radio): + """První BLE session: založ MQTT klienta. Další sessions jen osvěží jméno/verze.""" + self.name, self.pub, self._prv = name, pub.upper(), prv + self.fw_ver, self.radio = fw_ver, radio + if self.client is not None: + return + c = mqtt_client(client_id=f"meshcore_{self.pub[:15]}", clean_session=True, transport=OBS_TRANSPORT) + if OBS_TRANSPORT == "websockets": + c.ws_set_options(path="/") + if OBS_TLS: + c.tls_set() + self.client = c + self._set_fresh_creds() + c.will_set(self.topic("status"), self._status_json("offline"), qos=0, retain=True) + + def on_connect(cl, _ud, _fl, rc): + self.connected = rc == 0 + if rc == 0: + log.info("observer: připojen k %s:%d (%s)", OBS_HOST, OBS_PORT, self.topic("packets")) + cl.publish(self.topic("status"), self._status_json("online"), qos=0, retain=False) + else: + log.error("observer: broker odmítl spojení rc=%d (expirovaný/vadný token?)", rc) + + def on_disconnect(cl, _ud, rc): + self.connected = False + if rc != 0: + log.warning("observer: spojení ztraceno rc=%d — čerstvý token + reconnect", rc) + self._set_fresh_creds() # token mohl expirovat; před dalším CONNECTem obnov + + c.on_connect = on_connect + c.on_disconnect = on_disconnect + c.reconnect_delay_set(min_delay=5, max_delay=120) + c.connect_async(OBS_HOST, OBS_PORT, keepalive=60) + c.loop_start() + + def publish_packet(self, msg: dict) -> bool: + if not self.connected: + return False + self.client.publish(self.topic("packets"), json.dumps(msg), qos=0, retain=False) + self.published += 1 + return True + + def publish_status(self, stats=None): + if self.connected: + self.client.publish(self.topic("status"), self._status_json("online", stats), qos=0, retain=False) + + +OBS = Observer() + + +def mqtt_client(**kw): + """paho 1.x i 2.x: od 2.0 je `callback_api_version` povinný. VERSION1 drží + signatury callbacků (on_connect s rc, on_disconnect bez reason properties), + se kterými tenhle kód počítá.""" + api = getattr(mqtt, "CallbackAPIVersion", None) + if api is not None: + return mqtt.Client(api.VERSION1, **kw) + return mqtt.Client(**kw) + + +class NullMQTT: + """Bez MC_MQTT_HOST: lokální kopie a stats se zahazují, feed jede dál.""" + + def publish(self, *_a, **_k): + return None + + +def make_mqtt(): + if not MQTT_HOST: + return NullMQTT() + c = mqtt_client(client_id=f"repeater-observer-{NODE}", clean_session=True) + if MQTT_USER: + c.username_pw_set(MQTT_USER, MQTT_PASS) + if MQTT_TLS: + c.tls_set() # systémová CA; ověří i hostname + c.will_set(f"{MQTT_TOPIC}/status", "offline", qos=1, retain=True) + c.connect(MQTT_HOST, MQTT_PORT, keepalive=60) + c.loop_start() + c.publish(f"{MQTT_TOPIC}/status", "online", qos=1, retain=True) + return c + + +def parse_neighbours(text): + """`hex:secs_ago:snr` řádky (nebo `-none-`) → seznam dictů.""" + out = [] + for raw in text.replace("\r", "\n").split("\n"): + line = raw.strip() + if not line or line == "-none-": + continue + if line.startswith("->"): + line = line[2:].strip() + parts = line.split(":") + if len(parts) != 3: + continue + pk, secs, snr = parts + if len(pk) < 4: + continue + try: + # konzolový `neighbors` vrací SNR jako int8_t × 4 (viz FW MyMesh.h) → děl 4 na dB + out.append({"pubkey_prefix": pk.lower(), "secs_ago": int(secs), "snr": round(float(snr) / 4.0, 2)}) + except ValueError: + continue + return out + + +def _strip(line): + """Zahoď konzolový prefix '-> ' a whitespace.""" + line = line.strip() + if line.startswith("->"): + line = line[2:].strip() + return line + + +def parse_console_value(text): + """CommonCLI `get ...` odpovídá '> hodnota'; `ver` odpovídá rovnou textem. + Vrať hodnotu za '>' pokud je, jinak první neprázdný řádek.""" + first = None + for raw in text.replace("\r", "\n").split("\n"): + line = _strip(raw) + if not line: + continue + if line.startswith(">"): + return line[1:].strip() + if first is None: + first = line + return first + + +def parse_nodes(text): + """`nodes` odpověď → (rows, next_offset, total). + + Řádek uzlu: N,prefix,type,lat×1e6,lon×1e6,snr×4,rssi,age,pkt_hash,path,name + (pkt_hash = join key na rxlog kopie = všechny cesty advertu; path = reprezentativní, + direct 0-hop preferován; jméno = vše za 10. čárkou, může obsahovat čárky). + Trailer: E,next_offset,total. + """ + rows = [] + nxt = total = None + for raw in text.replace("\r", "\n").split("\n"): + line = _strip(raw) + if not line: + continue + if line[0] == "N": + parts = line.split(",", 10) # 11 polí; parts[10] = name (zbytek, může mít čárky) + if len(parts) < 11: + continue + _, prefix, typ, lat, lon, snr, rssi, age, pkt_hash, path, name = parts + try: + ilat, ilon = int(lat), int(lon) + rows.append( + { + "prefix": prefix.lower(), + "type": int(typ), + "lat": ilat / 1e6 if ilat != 0 else None, + "lon": ilon / 1e6 if ilon != 0 else None, + "snr": round(int(snr) / 4.0, 2), + "rssi": int(rssi), + "age": int(age), + "pkt_hash": pkt_hash.lower(), # join key → rxlog kopie (všechny cesty advertu) + "path": path.lower(), # reprezentativní hop-hashe (direct 0-hop preferován) + "name": name, + } + ) + except ValueError: + continue + elif line[0] == "E": + p = line.split(",") + if len(p) >= 3: + try: + nxt, total = int(p[1]), int(p[2]) + except ValueError: + pass + return rows, nxt, total + + +def parse_rxlog(text): + """`rxlog` odpověď → (records, last_seq, oldest_seq, newest_seq). + + Řádek: R,seq,when,pkthash,hdr(hex),snr×4,rssi,path(hex). + Trailer: E,last_seq,oldest_seq,newest_seq. + """ + recs = [] + last = oldest = newest = None + for raw in text.replace("\r", "\n").split("\n"): + line = _strip(raw) + if not line: + continue + if line[0] == "R": + p = line.split(",") + if len(p) < 8: + continue + try: + recs.append( + { + "seq": int(p[1]), + "when": int(p[2]), + "pkthash": p[3].lower(), + "hdr": int(p[4], 16), # syrový header byte + "snr": round(int(p[5]) / 4.0, 2), + "rssi": int(p[6]), + "path": p[7].lower(), + } + ) + except ValueError: + continue + elif line[0] == "E": + p = line.split(",") + if len(p) >= 4: + try: + last, oldest, newest = int(p[1]), int(p[2]), int(p[3]) + except ValueError: + pass + return recs, last, oldest, newest + + +def parse_pktlog(text): + """`pktlog` odpověď → (records, last_seq, oldest_seq, newest_seq). + + Řádek: P,seq,when,snr×4,rssi,raw(hex celého rámce). + Trailer: E,last_seq,oldest_seq,newest_seq (stejná sémantika jako rxlog). + """ + recs = [] + last = oldest = newest = None + for raw in text.replace("\r", "\n").split("\n"): + line = _strip(raw) + if not line: + continue + if line[0] == "P": + p = line.split(",") + if len(p) < 6: + continue + try: + recs.append( + { + "seq": int(p[1]), + "when": int(p[2]), + "snr": int(p[3]), # ×4, transformace dělí až v obs_packet_json + "rssi": int(p[4]), + "raw": p[5], + } + ) + except ValueError: + continue + elif line[0] == "E": + p = line.split(",") + if len(p) >= 4: + try: + last, oldest, newest = int(p[1]), int(p[2]), int(p[3]) + except ValueError: + pass + return recs, last, oldest, newest + + +async def clear_stale_ble_connection(): + """BlueZ umí po výpadku uváznout s D-Bus stavem `Connected: yes`, i když spojení + je mrtvé — nový scan pak zařízení NIKDY nenajde (signatura přesně + "nenalezen ve scanu (mimo dosah?)", i na desce, co je fyzicky na místě a + zdravá). Incident 18. 8. 2026: observer takhle crash-loopoval 3h20m, než si + toho někdo všiml; ruční oprava byla `bluetoothctl disconnect `. + Bez BLE_ADDR (BLE_NAME režim) nemáme co disconnectnout — no-op. Bezpečné + volat i když spojení NENÍ zaseklé (disconnect na už odpojeném zařízení je + no-op na straně BlueZ), takže se volá na KAŽDÝ neúspěch cyklu, ne jen na + tenhle konkrétní.""" + if not BLE_ADDR: + return + try: + proc = await asyncio.create_subprocess_exec( + "bluetoothctl", + "disconnect", + BLE_ADDR, + stdout=asyncio.subprocess.DEVNULL, + stderr=asyncio.subprocess.DEVNULL, + ) + await asyncio.wait_for(proc.wait(), timeout=10) + except Exception as e: + log.warning("bluetoothctl disconnect (self-heal) selhal, pokracuju: %r", e) + + +async def find_device(): + """BlueZ potřebuje discovery PŘED connectem → vždy scan, vrať BLEDevice (ne adresu).""" + if BLE_ADDR: + d = await BleakScanner.find_device_by_address(BLE_ADDR, timeout=25) + else: + d = await BleakScanner.find_device_by_name(BLE_NAME, timeout=25) + if d is None: + raise RuntimeError(f"BLE {BLE_ADDR or BLE_NAME} nenalezen ve scanu (mimo dosah?)") + return d + + +def parse_json_reply(text): + """Vytáhni JSON objekt z konzolové odpovědi (např. ' -> {...}'). {} když nic.""" + m = re.search(r"\{.*\}", text, re.S) + if not m: + return {} + try: + return json.loads(m.group(0)) + except Exception: + return {} + + +def parse_sensors(text): + """`sensor read` → dict {name: value}. FW dekóduje živou CayenneLPP telemetrii na text + `temperature=23.4 humidity=46.1 voltage=4.02 …`. Tokenizuje na whitespace, bere key=value, + přeskočí '-> ' prefix i DEBUG (klíč s ':'). Num→float/int, nečíselné (gps) nech textem.""" + out = {} + for tok in text.replace("\r", " ").replace("\n", " ").split(): + if "=" not in tok: + continue + k, v = tok.split("=", 1) + k = k.strip() + v = v.strip() + if not k or ":" in k: + continue + try: + out[k] = int(v) + except ValueError: + try: + out[k] = round(float(v), 2) + except ValueError: + out[k] = v + return out + + +def parse_bot(text): + """`bot` (kanálový bot v analyzer buildu) → countery do dictu. Na rozdíl od + STATS_CMDS nevrací JSON, ale prózu: + + bot: chan 75, trigger '', cmds 'link,path,snr,heard,noise', ignore '(nikdo)', + cooldown 10000 ms/odesilatel + 2500 ms floor, replies 0, throttled 0, + ignored 0, last 0 + + Bereme JEN countery — konfigurace je build-time, takže by se na MQTT jen + opakovala. `cooldown … 10000 ms/odesilatel + 2500 ms floor` regexy nechytí, + protože číslo je tam PŘED klíčovým slovem. + + Proč to tady vůbec je (7. 8. 2026): u „bot neodpověděl" se bez těchhle counterů + nedá odlišit „nesešel se trigger/cooldown" od „odpověď odešla a ztratila se po + cestě". Vlastní TX si uzel neloguje a v analyzeru je odpověď vidět jen tehdy, + když ji někdo zrepeatuje zpátky do slyšitelnosti observera — což u vzdáleného + tazatele nemusí nastat. Jediná jiná cesta ke counterům je sundat observer ze + sériové linky, čili díra ve feedu.""" + if "DISABLED" in text: + return {"bot_enabled": 0} + out = {} + for k in ("replies", "throttled", "ignored", "last"): + m = re.search(rf"\b{k}\s+(\d+)", text) + if m: + out[f"bot_{k}"] = int(m.group(1)) + if out: + out["bot_enabled"] = 1 + return out + + +def parse_clock(text): + """`clock` → (node_epoch, exact). None = neparsovatelné. + + Dva formáty, protože `clock` ve FW epoch teprve dostává: + + 12:34 - 7/8/2026 UTC (upstream: JEN minuty) + 12:34 - 7/8/2026 UTC (epoch 1786095587) (náš, přesný) + + `exact` říká, který to byl — volající podle toho volí práh. U minutového + formátu totiž `sprintf("%02d:%02d")` sekundy ZAHODÍ, takže i u naprosto + správně nastaveného uzlu vyjde rozdíl proti hostiteli 0-59 s a práh musí + být nad 59 s, jinak by se čas nastavoval při každém scrape. + + Den a měsíc jsou v FW `%d`, tedy BEZ vedoucí nuly (`7/8/2026`) — proto + regex a ne strptime s fixní šířkou.""" + m = re.search(r"epoch\s+(\d+)", text) + if m: + return int(m.group(1)), True + m = re.search(r"\b(\d{1,2}):(\d{2})\s*-\s*(\d{1,2})/(\d{1,2})/(\d{4})", text) + if not m: + return None + hh, mm, day, mon, year = (int(g) for g in m.groups()) + try: + dt = datetime(year, mon, day, hh, mm, tzinfo=timezone.utc) + except ValueError: # 31/2, hodina 25, … = rozsypaná odpověď + return None + return int(dt.timestamp()), False + + +# Nad kolik sekund rozdílu se čas přenastavuje. U minutového `clock` musí být +# práh nad 59 s (viz parse_clock); s epochem stačí pár sekund. +CLOCK_SKEW_COARSE = 120 +CLOCK_SKEW_EXACT = 5 + + +# konzolové příkazy repeateru vracející čistý JSON (dostupné lokálně = přes BLE) +STATS_CMDS = ("stats-packets", "stats-radio", "stats-core") + +# příkazy, které běžící FW nezná (staré FW bez mesh-analyzeru) — přestaň je zkoušet +_unsupported: set[str] = set() +_unknown_hits: dict = {} + + +def fw_lacks(cmd, reply): + """True, když `reply` je „Unknown command" už PODRUHÉ za sebou → `cmd` se + přestane zkoušet. Jeden výskyt nestačí: na slabém BLE linku může dorazit + pozdní odpověď na JINÝ příkaz (6. 10. 2026 si observer takhle zapsal, že FW + nezná `nodes`, a do restartu ho přestal číst). Platná odpověď počítadlo + nuluje.""" + if "Unknown command" not in reply: + _unknown_hits.pop(cmd, None) + return False + _unknown_hits[cmd] = _unknown_hits.get(cmd, 0) + 1 + if _unknown_hits[cmd] >= 2: + _unsupported.add(cmd) + return True + + +# rxlog/pktlog cursory přežívají reconnecty (module-global). Bez toho by se +# s BLE churnem resetovaly na 0 při KAŽDÉM spojení → re-čtení od začátku + +# falešný „drop". None = ještě nikdy nečteno (cold start). +RX_CURSOR = None +PKT_CURSOR = None + +# Persistence cursorů (22. 7. 2026): restart procesu dřív = cold start = ztráta +# jednoho duty cyklu paketů (pktlog backlog se nepřehrává). S watchdogem cyklu +# (exit po 3 selháních → systemd restart) by se to dělo častěji, tak cursory +# přežívají na disku. Reboot UZLU vynuluje seq → guard v poll_* (cursor > newest +# = přehrát ring od 0). Limit: když uzel rebootne a seq stihne přerůst starý +# cursor ještě před prvním pollem, mezera se nepozná — vzácné, přijatelné. +CURSOR_FILE = os.environ.get("MC_CURSOR_FILE") or os.path.join( + os.environ.get("STATE_DIRECTORY", "."), "cursors.json" +) # systemd StateDirectory= + + +def load_cursors(): + global RX_CURSOR, PKT_CURSOR + try: + with open(CURSOR_FILE) as f: + d = json.load(f) + RX_CURSOR, PKT_CURSOR = d.get("rx"), d.get("pkt") + log.info("cursory načteny (%s): rx=%s pkt=%s", CURSOR_FILE, RX_CURSOR, PKT_CURSOR) + except FileNotFoundError: + pass + except Exception as e: + log.warning("cursory: %s nečitelný (%s) — cold start", CURSOR_FILE, e) + + +def save_cursors(): + try: + tmp = CURSOR_FILE + ".tmp" + with open(tmp, "w") as f: + json.dump({"rx": RX_CURSOR, "pkt": PKT_CURSOR}, f) + os.replace(tmp, CURSOR_FILE) + except Exception as e: + log.warning("cursory: zápis do %s selhal: %s", CURSOR_FILE, e) + + +def _paged_done(buf: bytearray) -> bool: + """Stránkovaná odpověď (nodes/rxlog/pktlog) je kompletní, když poslední ukončený + řádek je trailer `E,...` — netřeba čekat na 1.2 s ticha (šetří ~1 s/stránku).""" + if not buf.endswith(b"\r\n"): + return False + tail = buf.rstrip().rsplit(b"\n", 1)[-1].lstrip() + if tail.startswith(b"->"): # jednořádková odpověď: trailer slepený s " -> " prefixem + tail = tail[2:].lstrip() + return tail.startswith(b"E,") + + +def make_query(client): + """Vrať query(cmd) navázaný na klienta: pošli příkaz, čti dokud odpověď proudí + (ticho 1.2 s / strop REPLY_WAIT / volitelný `done` prediktor konce). + Sdílený notify buffer.""" + buf = bytearray() + returned = [0] # kolik bajtů z buf už vrátila předchozí query() + + def on_tx(_handle, data: bytearray): + buf.extend(data) + + async def query(cmd, cap=REPLY_WAIT, done=None): + # Pozdní konec předchozí odpovědi. Na slabém linku (kolem −82 dBm) + # přijde část odpovědi až po 1.2 s ticha, kdy už query() vrátila + # začátek; bez tohohle by ten konec četl DALŠÍ příkaz jako svůj (6. 10.: + # `clock` dostal stats JSON, `nodes` dostal „Unknown command" od `bot`). + # Neukončený řádek = odpověď ještě běží, tak na ni chvíli počkej. + stale = len(buf) > returned[0] or (buf and not buf.endswith(b"\n")) + if stale: + last, quiet, waited = len(buf), 0.0, 0.0 + while quiet < 0.6 and waited < FIRST_BYTE_WAIT: + await asyncio.sleep(0.15) + waited += 0.15 + if len(buf) != last: + last = len(buf) + quiet = 0.0 + else: + quiet += 0.15 + log.debug("query(%s): zahozen pozdní konec předchozí odpovědi (%d B)", cmd, len(buf) - returned[0]) + buf.clear() + payload = (cmd + "\r").encode() + for i in range(0, len(payload), 20): # 20B kousky (BLE MTU jistota) + await client.write_gatt_char(NUS_RX, payload[i : i + 20], response=False) + last, quiet, waited = -1, 0.0, 0.0 + while waited < cap: + await asyncio.sleep(0.15) + waited += 0.15 + if done and done(buf): + break + if len(buf) != last: + last = len(buf) + quiet = 0.0 + else: + quiet += 0.15 + # Ticho se počítá až od prvního bajtu. Přes slabý BLE link (kolem + # −82 dBm) přichází začátek odpovědi i po víc než 1.2 s; + # dřív se to četlo jako prázdná odpověď (clock '', 0 sousedů). + if quiet >= (1.2 if buf else FIRST_BYTE_WAIT): + break + returned[0] = len(buf) + return buf.decode(errors="replace") + + return on_tx, query + + +def open_serial(port): + """Otevři USB konzoli uzlu. DTR/RTS MUSÍ jít nahoru, jinak CDC mlčí (dock-quiet).""" + import serial # optional dep: BLE cesta pyserial nepotřebuje + + s = serial.Serial(port, 115200, timeout=0) + s.dtr = True + s.rts = True + time.sleep(1.2) # firmware chvíli po otevření portu neodpovídá + s.reset_input_buffer() + return s + + +def make_serial_query(s): + """Sériový protějšek make_query — stejná semantika (ticho 1.2 s / strop REPLY_WAIT / + volitelný `done` prediktor), takže VŠECHNY parsery a polly fungují bez úprav. + + Dva rozdíly proti BLE: + - žádné 20B kouskování (to je limit BLE MTU, ne linky), + - konzole příkaz ECHUJE. Echo se zahazuje tady, na švu transportu, aby parsery + zůstaly pro oba transporty identické: parse_console_value() vrací první + neprefixovaný řádek, takže `ver` by jinak vrátilo "ver" místo verze. + """ + + async def query(cmd, cap=REPLY_WAIT, done=None): + try: + s.reset_input_buffer() + except Exception: + pass + s.write((cmd + "\r\n").encode()) + s.flush() + buf = bytearray() + last, quiet, waited = -1, 0.0, 0.0 + while quiet < 1.2 and waited < cap: + await asyncio.sleep(0.15) + waited += 0.15 + n = s.in_waiting + if n: + buf.extend(s.read(n)) + if done and done(buf): + break + if len(buf) != last: + last = len(buf) + quiet = 0.0 + else: + quiet += 0.15 + lines = buf.decode(errors="replace").replace("\r", "\n").split("\n") + for i, ln in enumerate(lines): # zahoď první řádek == echo příkazu + if ln.strip() == cmd.strip(): + del lines[i] + break + return "\n".join(lines) + + return query + + +async def serial_session(mc): + """Trvalé sériové spojení. Na rozdíl od BLE se USB konzole s rádiem nebije, takže + ŽÁDNÝ duty cycle: drain jede pořád a nedělá hluchá okna. U BLE právě ta okna stála + pktlog DROPy (64slotový PKTFEED nestačil na 120 s duty-off).""" + global T_NODES, T_FULL + s = open_serial(SERIAL_PORT) + query = make_serial_query(s) + log.info("sériová konzole otevřena: %s", SERIAL_PORT) + mc.publish(f"{MQTT_TOPIC}/serial", "connected", qos=1, retain=True) + obs_retry_at = 0.0 + try: + while True: + now = time.monotonic() + # obs_init MUSÍ jít ze smyčky, ne před ni: sériová session je TRVALÁ, + # takže jeho "feed odložen do příští session" by tady znamenalo navždy + # (u BLE to spraví další duty cyklus). Děje se to po zapojení desky — + # konzole chvíli po bootu nic nevydá (4. 8. 2026: get public.key vrátil + # 0 znaků při uptime 16 s). Backoff, ať to nespamuje ERRORem každé 2 s. + if OBS_ENABLE and not OBS.pub and now >= obs_retry_at: + await obs_init(query) + obs_retry_at = now + 30 + if now - T_FULL >= INTERVAL: + # jméno/verze/rádio osvěžit jako u BLE, kde to dělá každá session + if OBS_ENABLE and OBS.pub: + await obs_init(query) + await scrape_full(query, mc) + T_FULL = now + if now - T_NODES >= NODES_INTERVAL: + await poll_nodes(query, mc) + T_NODES = now + await poll_rxlog(query, mc) + await poll_pktlog(query, mc) + save_cursors() # restart procesu ≠ ztráta pozice v ringu + await asyncio.sleep(RXLOG_INTERVAL) + finally: + mc.publish(f"{MQTT_TOPIC}/serial", "disconnected", qos=1, retain=True) + try: + s.close() + except Exception: + pass + + +async def serial_main(mc): + """Smyčka sériového transportu. Chybějící port NENÍ chyba — deska prostě ještě + není zapojená, tak se čeká tiše (jinak by to zaplavilo journal jako crashloop + BLE varianty). Proto se tady taky nikdy neexituje: unita zůstane `active` a chytí + desku v momentě, kdy ji zapojíš.""" + log.info( + "observer běží: SERIAL %s → MQTT %s:%d %s | scrape %ds, nodes %ds, rxlog %ds", + SERIAL_PORT, + MQTT_HOST, + MQTT_PORT, + MQTT_TOPIC, + INTERVAL, + NODES_INTERVAL, + RXLOG_INTERVAL, + ) + load_cursors() + waiting = False + while True: + if not os.path.exists(SERIAL_PORT): + if not waiting: + log.warning("port %s neexistuje — čekám na zapojení desky", SERIAL_PORT) + waiting = True + await asyncio.sleep(5) + continue + waiting = False + try: + await serial_session(mc) + except Exception as e: + log.error("sériové spojení: %r — retry za 15 s", e) + await asyncio.sleep(15) + + +async def obs_init(query): + """Přečti identitu uzlu z konzole a nastartuj/aktualizuj observer sink. + prv.key NIKDY nelogovat a nikam neukládat — jde do RAM Observeru a tečka. + Při MC_OBS_AUTH=none (vlastní broker) se prv.key vůbec nečte.""" + if not OBS_ENABLE: + return + pub = parse_console_value(await query("get public.key")) + name = parse_console_value(await query("get name")) + ver = parse_console_value(await query("ver")) + radio = parse_console_value(await query("get radio")) + if not pub or len(pub) != 64: + log.error( + "observer: konzole nevydala public.key (%s znaků) — feed odložen do příští session", len(pub) if pub else 0 + ) + return + prv = None + if OBS_AUTH == "token": + prv = parse_console_value(await query("get prv.key")) + if not prv or len(prv) != 128: + log.error( + "observer: konzole nevydala prv.key (%s znaků) — feed odložen do příští session", len(prv) if prv else 0 + ) + return + try: + bytes.fromhex(pub) + if prv: + bytes.fromhex(prv) + except ValueError: + log.error("observer: klíče nejsou validní hex — feed odložen") + return + if prv: + # self-check: pubkey odvozený ze scalar části prv.key MUSÍ sedět na public.key + # (odhalí zkomolený přenos konzolí i případnou změnu layoutu klíče ve FW) + derived = _ed_compress(_ed_mul(_ED_B, int.from_bytes(bytes.fromhex(prv)[:32], "little"))).hex().upper() + if derived != pub.upper(): + log.error( + "observer: prv.key neodpovídá public.key (odvozeno %s…, konzole %s…) — feed odložen", + derived[:8], + pub.upper()[:8], + ) + return + OBS.start(name or NODE, pub, prv, ver or "unknown", radio or "unknown") + + +async def scrape_bot(query): + """`bot` countery → dict k přimíchání do stats. Uzel bez kanálového bota + (build bez bota, starší FW) příkaz nezná, tak se po druhém „Unknown command" přestane + zkoušet — stejně jako `nodes` výš.""" + if "bot" in _unsupported: + return {} + reply = await query("bot") + if fw_lacks("bot", reply): + if "bot" in _unsupported: + log.info("FW nezná `bot` — countery kanálového bota přeskočeny (uzel bez bota)") + return {} + return parse_bot(reply) + + +# kolikrát tenhle proces hodiny uzlu srovnal (counter, ne příznak — viz níž) +_clock_sets = 0 + + +async def sync_clock(query): + """Hodiny uzlu → countery do stats, a když je uzel pozadu, srovnej je. + + Proč to musí dělat observer: uzel bez GPS nemá čím. Automatické cesty jsou + v celém FW dvě — GPS (`MicroNMEALocationProvider`) a `BaseChatMesh`, který + repeater build vůbec nelinkuje — a `clock sync` po konzoli NEMŮŽE projít, + protože `simple_repeater/main.cpp` předává `sender_timestamp = 0` pro USB + i BLE (dělí jeden buffer), takže strážce `sender_timestamp > curr` nikdy + neprojde. Zbývá `time `. + + Bez tohohle běžel jeden náš uzel od nasazení 811 dní pozadu — `VolatileRTCClock` má + base_time zadrátovaný na 15. 5. 2024 a nikdo mu čas nikdy nenastavil. A to + není kosmetika: čas z RTC jde do KAŽDÉHO vysílaného advertu (`Mesh.cpp`) a + příjemce starý timestamp zahodí jako replay, takže se ze špatných hodin + stane zahozená odpověď. + + Uzel s GPS si hodiny srovnává sám, takže tam z tohohle zůstane jen čtení. + + Counter, ne příznak: bez `clock_set_count` se nepozná „srovnalo se to a drží" + od „nikdy to nejelo" — přesně ta lekce z `bot_replies`. + + Uzel NAPŘED před hostitelem se odsud opravit nedá: `time` má strážce + `secs > curr` a jediná cesta dozadu je `clkreboot`, který REBOOTUJE — a + reboot vzdálené desky ji umí shodit z USB až do replugu. Takže jen WARNING + a nech to na člověku.""" + global _clock_sets + if "clock" in _unsupported: + return {} + reply = await query("clock") + if fw_lacks("clock", reply): + if "clock" in _unsupported: + log.info("FW nezná `clock` — synchronizace hodin přeskočena") + return {} + parsed = parse_clock(reply) + if parsed is None: + log.warning("`clock` nedal čas: %r", reply.strip()[:120]) + return {} + node, exact = parsed + now = int(time.time()) + skew = now - node + out = {"clock_skew_secs": skew, "clock_set_count": _clock_sets} + if skew < 0: + log.warning( + "uzel má hodiny %d s NAPŘED (%s) — `time` to odmítne a srovnat " + "to jde jen `clkreboot`em, čili rebootem. Nechávám na tobě.", + -skew, + datetime.fromtimestamp(node, timezone.utc).isoformat(), + ) + return out + if skew <= (CLOCK_SKEW_EXACT if exact else CLOCK_SKEW_COARSE): + return out + set_reply = await query(f"time {now}") + # „cannot go backwards" tady není chyba, jen závod: uzel se mezitím srovnal + # sám (GPS), nebo je čas hostitele o vlásek pozadu. Rozhodne další scrape. + if "OK" in set_reply: + _clock_sets += 1 + out["clock_set_count"] = _clock_sets + log.info( + "hodiny uzlu srovnány: byl %s (%+d s), nastaveno %d — %s", + datetime.fromtimestamp(node, timezone.utc).isoformat(), + -skew, + now, + set_reply.strip()[:80], + ) + else: + log.warning("`time %d` neprošlo: %r", now, set_reply.strip()[:120]) + return out + + +async def scrape_full(query, mc): + """Plný scrape (kompat): neighbors + stats + sensors → MQTT (jako dřív).""" + neighbours = parse_neighbours(await query(CMD)) + stats = {} + for c in STATS_CMDS: + stats.update(parse_json_reply(await query(c))) + stats.update(await scrape_bot(query)) + # Hodiny až za stats: `uptime_secs` ze `stats-core` je to, čím se dá zpětně + # dokázat, že uzel jel na base_time z konstruktoru (base + uptime == čas). + stats.update(await sync_clock(query)) + sensors = parse_sensors(await query("sensor read")) + + ts = int(time.time()) + doc = { + "node": NODE, + "ts": ts, + "count": len(neighbours), + "neighbours": neighbours, + "stats": stats, + "sensors": sensors, + } + mc.publish(f"{MQTT_TOPIC}/neighbours", json.dumps(doc), qos=0, retain=False) + for n in neighbours: + mc.publish( + f"{MQTT_TOPIC}/neighbour/{n['pubkey_prefix']}", + json.dumps({**n, "node": NODE, "ts": ts}), + qos=0, + retain=False, + ) + if stats: + mc.publish(f"{MQTT_TOPIC}/stats", json.dumps({"node": NODE, "ts": ts, **stats}), qos=0, retain=False) + if sensors: + mc.publish(f"{MQTT_TOPIC}/sensors", json.dumps({"node": NODE, "ts": ts, **sensors}), qos=0, retain=False) + mc.publish(f"{MQTT_TOPIC}/last_scrape", str(ts), qos=0, retain=False) + OBS.publish_status(stats or None) # observer status jede v rytmu plného scrape + log.info( + "full scrape: %d sousedů | stats: %s | senzory: %s", len(neighbours), stats or "(žádné)", sensors or "(žádné)" + ) + + +async def poll_nodes(query, mc): + """Přečti celý `nodes` registr (paged offset 0→total) → retained snapshot na MQTT.""" + if "nodes" in _unsupported: + return + rows = [] + offset = 0 + for _ in range(50): # strop proti nekonečnu + reply = await query(f"nodes {offset}" if offset else "nodes", done=_paged_done) + if fw_lacks("nodes", reply): + if "nodes" in _unsupported: + log.info("FW nezná `nodes` — analyzer registr přeskočen (starý FW?)") + return + page, nxt, total = parse_nodes(reply) + rows.extend(page) + if nxt is None or total is None or nxt >= total or nxt == offset: + break + offset = nxt + ts = int(time.time()) + mc.publish( + f"{MQTT_TOPIC}/nodes", + json.dumps({"node": NODE, "ts": ts, "count": len(rows), "nodes": rows}), + qos=0, + retain=True, + ) # snapshot → retained (fresh konzument dostane hned) + log.info("nodes: %d slyšených repeaterů/roomů", len(rows)) + + +async def poll_rxlog(query, mc): + """Drain `rxlog` od uloženého RX_CURSOR (přežívá reconnect) → stream na MQTT. + Cold start (RX_CURSOR None): začni od toho co kruh drží, BEZ hlášení dropu (nic jsme + nezmeškali, jen startujeme). Warm: cursor+1 < oldest = kruh nám přepsal záznamy = drop.""" + global RX_CURSOR + if "rxlog" in _unsupported: + return + # Strop na jeden poll: ~3 záznamy/stránku (160B reply cap) → až ~180 záznamů/cyklus. + # 20 nestačilo na denní bursty (advert + kopie od okolních repeaterů přijdou během + # sekund) — ring 96 pak přetékal po jednotkách záznamů, viz meshcore_rxlog_dropped_total. + for _ in range(60): + cur = 0 if RX_CURSOR is None else RX_CURSOR + reply = await query(f"rxlog {cur}", done=_paged_done) + if fw_lacks("rxlog", reply): + if "rxlog" in _unsupported: + log.info("FW nezná `rxlog` — analyzer firehose přeskočen (starý FW?)") + return + recs, last, oldest, newest = parse_rxlog(reply) + if last is None or oldest is None: + break # nečitelná / prázdná odpověď + if newest is not None and cur > newest: + log.warning( + "rxlog: cursor %d > newest %d — uzel rebootoval (seq reset), jedu od začátku ringu", cur, newest + ) + RX_CURSOR = None # None = cold-start sémantika (bez falešného dropu) + continue + cold = RX_CURSOR is None + dropped = 0 if cold else (oldest - cur - 1 if cur + 1 < oldest else 0) + if recs or dropped: + ts = int(time.time()) + mc.publish( + f"{MQTT_TOPIC}/rxlog", + json.dumps( + { + "node": NODE, + "ts": ts, + "records": recs, + "dropped": dropped, + "ring": {"oldest": oldest, "newest": newest}, + } + ), + qos=0, + retain=False, + ) + if dropped: + log.warning( + "rxlog DROP: kruh přepsal %d záznamů (cursor %d < oldest %d) — poll rychleji / zvětši RXLOG_SIZE", + dropped, + cur, + oldest, + ) + RX_CURSOR = last # posuň cursor (global → přežije reconnect) + if last <= cur or (newest is not None and last >= newest): + break # nic nového / dohnáno + + +async def poll_pktlog(query, mc): + """Drain `pktlog` (surové rámce) → observer feed + lokální MQTT kopie. + + Cold start (PKT_CURSOR None): NEpřehrávat backlog ringu — živý komunitní feed + nemá stát o restart-duplikáty se starými timestampy. Trailer prozradí newest + i bez čtení záznamů (cursor 2^32-1 nematchne nic), od něj se jede nově.""" + global PKT_CURSOR + if not OBS_ENABLE or "pktlog" in _unsupported: + return + if PKT_CURSOR is None: + reply = await query("pktlog 4294967295", done=_paged_done) + if fw_lacks("pktlog", reply): + if "pktlog" in _unsupported: + log.info("FW nezná `pktlog` — observer feed přeskočen (starý FW?)") + return + _, _, _, newest = parse_pktlog(reply) + PKT_CURSOR = newest if newest is not None else 0 + log.info("observer: pktlog cursor startuje na %d (backlog se nepřehrává)", PKT_CURSOR) + return + # plný rámec ≈ 550 B řádek → 1-3 záznamy/1000B stránku; 40 stránek bohatě + # pokryje 32-slotový ring i s rezervou na souběžný přítok + for _ in range(40): + cur = PKT_CURSOR + reply = await query(f"pktlog {cur}", done=_paged_done) + if fw_lacks("pktlog", reply): + return + recs, last, oldest, newest = parse_pktlog(reply) + if last is None or oldest is None: + break + if newest is not None and cur > newest: + log.warning("pktlog: cursor %d > newest %d — uzel rebootoval (seq reset), přehrávám ring od 0", cur, newest) + PKT_CURSOR = 0 # ring drží jen po-rebootové rámce → přehrát celý + continue + dropped = oldest - cur - 1 if (cur and cur + 1 < oldest) else 0 + if dropped: + log.warning( + "pktlog DROP: kruh přepsal %d záznamů (cursor %d < oldest %d) — zvětši PKTFEED_SIZE / rychlejší poll", + dropped, + cur, + oldest, + ) + for rec in recs: + msg = obs_packet_json(rec) + if msg is None: + log.warning( + "pktlog: neparsovatelný rámec seq=%s (%d B) — přeskočen", + rec.get("seq"), + len(rec.get("raw", "")) // 2, + ) + continue + OBS.publish_packet(msg) + # lokální kopie stejného tvaru (pokud je MC_MQTT_HOST) + mc.publish(f"{MQTT_TOPIC}/packets", json.dumps(msg), qos=0, retain=False) + PKT_CURSOR = last + if last <= cur or (newest is not None and last >= newest): + break + + +T_NODES = 0.0 # cadence přežívá reconnecty (duty cycle se odpojuje každý průchod) +T_FULL = 0.0 + + +async def session(client, mc): + """Jeden drain průchod na jednom BLE spojení: rxlog+pktlog vždy, nodes/full scrape + podle cadence (NODES_INTERVAL/INTERVAL). Volající se po návratu ODPOJÍ (duty cycle), + viz OFF_INTERVAL — trvalé spojení blokovalo DIRECT forwarding repeateru.""" + global T_NODES, T_FULL + on_tx, query = make_query(client) + await client.start_notify(NUS_TX, on_tx) + mc.publish(f"{MQTT_TOPIC}/ble", "connected", qos=1, retain=True) + try: + await obs_init(query) # identita pro observer feed (no-op bez MC_OBS_ENABLE) + now = time.monotonic() + if now - T_FULL >= INTERVAL: + await scrape_full(query, mc) + T_FULL = now + if now - T_NODES >= NODES_INTERVAL: + await poll_nodes(query, mc) + T_NODES = now + await poll_rxlog(query, mc) + await poll_pktlog(query, mc) + finally: + try: + await client.stop_notify(NUS_TX) + except Exception: + pass + + +def config_error(): + """Chyba konfigurace jako text, None = v pořádku.""" + if not (SERIAL_PORT or BLE_ADDR or BLE_NAME): + return "set MC_SERIAL_PORT (USB) or MC_BLE_ADDR / MC_BLE_NAME (BLE)" + if OBS_ENABLE and not OBS_IATA: + return "MC_OBS_ENABLE=1 needs MC_OBS_IATA (the region's airport code, e.g. PRG)" + if not OBS_ENABLE and not MQTT_HOST: + return "nothing to publish to: set MC_OBS_ENABLE=1 and/or MC_MQTT_HOST" + return None + + +async def main(): + err = config_error() + if err: + log.error("config: %s", err) + sys.exit(2) + mc = make_mqtt() + if SERIAL_PORT: # USB konzole místo BLE; BLE větev níž zůstává nedotčená + if OBS_ENABLE: + log.info( + "observer feed ZAPNUT: %s:%d (%s, TLS %s, auth %s) IATA=%s aud=%s", + OBS_HOST, + OBS_PORT, + OBS_TRANSPORT, + OBS_TLS, + OBS_AUTH, + OBS_IATA, + OBS_AUDIENCE, + ) + await serial_main(mc) + return + log.info( + "observer běží: BLE %s → MQTT %s:%d %s | scrape %ds, nodes %ds, rxlog %ds", + BLE_ADDR or BLE_NAME, + MQTT_HOST, + MQTT_PORT, + MQTT_TOPIC, + INTERVAL, + NODES_INTERVAL, + RXLOG_INTERVAL, + ) + if OBS_ENABLE: + log.info( + "observer feed ZAPNUT: %s:%d (%s, TLS %s, auth %s) IATA=%s aud=%s", + OBS_HOST, + OBS_PORT, + OBS_TRANSPORT, + OBS_TLS, + OBS_AUTH, + OBS_IATA, + OBS_AUDIENCE, + ) + else: + log.info("observer feed vypnut (MC_OBS_ENABLE=1 pro zapnutí)") + # Watchdog cyklu (22. 7. 2026): scan i connect mají nominální timeouty, ale + # když USB churn (crash-loopující SDR na téže sběrnici jako BT dongle) zasekne + # bluetoothd, D-Bus volání pod bleakem nikdy neodpoví a smyčka visela navěky + # (pozorováno: poslední drain 10:53, pak 50+ min ticho). wait_for() task + # zruší i když D-Bus mlčí; po 3 selháních za sebou exit(1) → systemd + # Restart=on-failure nahodí čerstvý proces (nové D-Bus spojení). + cycle_timeout = int(os.environ.get("MC_CYCLE_TIMEOUT", "900")) + fails = 0 + load_cursors() # restart procesu ≠ ztráta duty cyklu (viz CURSOR_FILE) + + async def cycle(): + dev = await find_device() # scan při každém (re)connectu → spolehlivé discovery + async with BleakClient(dev, timeout=30) as client: + log.info("BLE připojeno k %s", dev.address) + await session(client, mc) + + while True: + try: + await asyncio.wait_for(cycle(), timeout=cycle_timeout) + fails = 0 + save_cursors() # po úspěšném drainu — restart pak naváže, ne cold start + # duty cycle: odpojeno → repeater má volno na DIRECT forwarding + mc.publish(f"{MQTT_TOPIC}/ble", "disconnected", qos=1, retain=True) + log.info("drain hotov, BLE odpojeno na %d s (duty cycle)", OFF_INTERVAL) + await asyncio.sleep(OFF_INTERVAL) + except Exception as e: + fails += 1 + log.error("BLE spojení (%d/3): %r — reconnect za 15 s", fails, e) + mc.publish(f"{MQTT_TOPIC}/ble", "disconnected", qos=1, retain=True) + await clear_stale_ble_connection() + if fails >= 3: + log.error("3 cykly za sebou selhaly — exit(1), systemd restartne s čerstvým D-Bus") + sys.exit(1) + await asyncio.sleep(15) + + +def cli(): + try: + asyncio.run(main()) + except KeyboardInterrupt: + pass + + +if __name__ == "__main__": + cli() diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000..24acfcc --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,37 @@ +[build-system] +requires = ["setuptools>=68"] +build-backend = "setuptools.build_meta" + +[project] +name = "meshcore-repeater-observer" +dynamic = ["version"] +description = "Observer feed and stats from a MeshCore repeater's console over BLE or USB" +readme = "README.md" +license = "MIT" +requires-python = ">=3.10" +dependencies = [ + "bleak>=0.22", + "paho-mqtt>=1.6", + "pyserial>=3.5", +] + +[project.optional-dependencies] +dev = ["pytest", "ruff", "mypy", "cryptography"] + +[project.scripts] +meshcore-repeater-observer = "meshcore_repeater_observer:cli" + +[tool.setuptools] +py-modules = ["meshcore_repeater_observer"] + +[tool.setuptools.dynamic] +version = { attr = "meshcore_repeater_observer.__version__" } + +[tool.ruff] +line-length = 120 + +[tool.ruff.lint] +select = ["E", "F", "W", "I", "B", "UP"] + +[tool.mypy] +ignore_missing_imports = true diff --git a/tests/test_observer.py b/tests/test_observer.py new file mode 100644 index 0000000..4ebeaca --- /dev/null +++ b/tests/test_observer.py @@ -0,0 +1,167 @@ +"""Parsers, the meshcoretomqtt transform and the JWT signature -- no radio, no broker.""" + +import hashlib +import importlib +import json +import os +import subprocess +import sys +from base64 import urlsafe_b64decode +from pathlib import Path + +import pytest + +ROOT = Path(__file__).resolve().parent.parent +sys.path.insert(0, str(ROOT)) + + +def load(env=None): + """Import the module with a clean MC_* environment (it reads env at import).""" + for k in [k for k in os.environ if k.startswith("MC_")]: + del os.environ[k] + os.environ.update(env or {}) + import meshcore_repeater_observer as mod + + return importlib.reload(mod) + + +@pytest.fixture +def ob(): + return load() + + +def test_parse_pktlog(ob): + text = " -> P,7,1793600000,40,-92,1104AABB\r\nP,8,1793600001,-12,-110,15\r\nE,8,3,8\r\n" + recs, last, oldest, newest = ob.parse_pktlog(text) + assert [r["seq"] for r in recs] == [7, 8] and (last, oldest, newest) == (8, 3, 8) + assert recs[0]["snr"] == 40 and recs[0]["rssi"] == -92 and recs[0]["raw"] == "1104AABB" + + +def test_parse_rxlog(ob): + recs, last, oldest, newest = ob.parse_rxlog("R,5,1793600000,abcd,11,24,-95,5361\nE,5,1,5\n") + assert recs == [ + {"seq": 5, "when": 1793600000, "pkthash": "abcd", "hdr": 0x11, "snr": 6.0, "rssi": -95, "path": "5361"} + ] + assert (last, oldest, newest) == (5, 1, 5) + + +def test_parse_nodes_name_with_commas(ob): + rows, nxt, total = ob.parse_nodes("N,ab12,2,50100000,14200000,20,-90,30,deadbeef,5361,name, with, commas\nE,1,1\n") + assert rows[0]["name"] == "name, with, commas" and rows[0]["lat"] == 50.1 and rows[0]["snr"] == 5.0 + assert (nxt, total) == (1, 1) + + +def test_paged_done(ob): + assert ob._paged_done(bytearray(b"P,1,2,3,4,ab\r\nE,1,1,1\r\n")) + assert ob._paged_done(bytearray(b" -> E,0,0,0\r\n")) + assert not ob._paged_done(bytearray(b"P,1,2,3,4,ab\r\n")) + + +def test_clock_both_formats(ob): + assert ob.parse_clock("12:34 - 7/8/2026 UTC (epoch 1786095587)") == (1786095587, True) + from datetime import datetime, timezone + + node, exact = ob.parse_clock("12:34 - 7/8/2026 UTC") + assert not exact and node == int(datetime(2026, 8, 7, 12, 34, tzinfo=timezone.utc).timestamp()) + assert ob.parse_clock("garbage") is None + + +def test_frame_and_hash(ob): + payload = bytes(range(40)) + flood_advert = bytes([(4 << 2) | 1, 0]) + payload # route F, type 4, no path + route, ptype, plb, pl = ob.parse_raw_frame(flood_advert) + assert (route, ptype, plb, pl) == (1, 4, 0, payload) + assert ob.meshcore_packet_hash(4, 0, payload) == hashlib.sha256(bytes([4]) + payload).digest()[:8].hex().upper() + # 2-byte path hashes, two hops: (2-1)<<6 | 2 + with_path = bytes([(4 << 2) | 1, 0x42]) + b"\x53\x61\x77\x88" + payload + assert ob.parse_raw_frame(with_path)[3] == payload + assert ob.parse_raw_frame(b"\x11") is None + + +def test_packet_json(ob): + ob.OBS.name, ob.OBS.pub = "my-rpt", "AB" * 32 + raw = (bytes([(4 << 2) | 1, 0]) + bytes(40)).hex() + msg = ob.obs_packet_json({"seq": 1, "when": 1793600000, "snr": 41, "rssi": -100, "raw": raw}) + assert msg["origin"] == "my-rpt" and msg["route"] == "F" and msg["packet_type"] == "4" + assert msg["SNR"] == "10" and msg["RSSI"] == "-100" and msg["raw"] == raw.upper() and len(msg["hash"]) == 16 + assert ob.obs_packet_json({"seq": 1, "when": 0, "snr": 0, "rssi": 0, "raw": "zz"}) is None + + +def orlp_keypair(seed: bytes, ob): + """orlp/ed25519 keypair layout: prv64 = clamped scalar || prefix (lib/ed25519/keypair.c).""" + h = bytearray(hashlib.sha512(seed).digest()) + h[0] &= 248 + h[31] &= 63 + h[31] |= 64 + a = int.from_bytes(h[:32], "little") + pub = ob._ed_compress(ob._ed_mul(ob._ED_B, a)) + return pub, bytes(h) + + +def test_signature_verifies_with_cryptography(ob): + ed = pytest.importorskip("cryptography.hazmat.primitives.asymmetric.ed25519") + seed = bytes(range(32)) + pub, prv = orlp_keypair(seed, ob) + # the same key derived the standard way (RFC 8032 seed) must give the same public key + std = ed.Ed25519PrivateKey.from_private_bytes(seed).public_key() + from cryptography.hazmat.primitives import serialization + + assert std.public_bytes(serialization.Encoding.Raw, serialization.PublicFormat.Raw) == pub + sig = ob.ed25519_sign_orlp(b"hello", pub, prv) + std.verify(sig, b"hello") # raises on a bad signature + + +def test_jwt_audience_is_broker_host(): + ob = load({"MC_OBS_ENABLE": "1", "MC_OBS_IATA": "PRG"}) + pub, prv = orlp_keypair(b"\x01" * 32, ob) + tok = ob.make_auth_token(pub.hex(), prv.hex()) + head, body, sig = tok.split(".") + payload = json.loads(urlsafe_b64decode(body + "=" * (-len(body) % 4))) + assert json.loads(urlsafe_b64decode(head + "==")) == {"alg": "Ed25519", "typ": "JWT"} + assert payload["aud"] == "mqtt1.meshcore.cz" == ob.OBS_HOST + assert payload["publicKey"] == pub.hex().upper() and payload["exp"] - payload["iat"] == ob.OBS_TOKEN_TTL + assert len(sig) == 128 and sig == sig.upper() # uppercase hex, not base64url + ob2 = load({"MC_OBS_MQTT_HOST": "mqtt2.meshcore.website"}) + assert ob2.OBS_AUDIENCE == "mqtt2.meshcore.website" + + +@pytest.mark.parametrize( + "env,expect", + [ + ({}, "MC_SERIAL_PORT"), + ({"MC_SERIAL_PORT": "/dev/x", "MC_OBS_ENABLE": "1"}, "MC_OBS_IATA"), + ({"MC_SERIAL_PORT": "/dev/x"}, "nothing to publish"), + ({"MC_SERIAL_PORT": "/dev/x", "MC_OBS_ENABLE": "1", "MC_OBS_IATA": "PRG"}, None), + ({"MC_BLE_ADDR": "AA:BB:CC:DD:EE:FF", "MC_MQTT_HOST": "localhost"}, None), + ], +) +def test_config_error(env, expect): + err = load(env).config_error() + assert (err is None) if expect is None else (expect in err) + + +def test_local_mqtt_optional(): + ob = load({"MC_SERIAL_PORT": "/dev/x", "MC_OBS_ENABLE": "1", "MC_OBS_IATA": "PRG"}) + assert isinstance(ob.make_mqtt(), ob.NullMQTT) + assert ob.MQTT_TOPIC == "repeater-observer/repeater" + + +def test_help_without_dependencies(): + code = ( + "import sys, builtins; real = builtins.__import__\n" + "def imp(n, *a, **k):\n" + " if n.split('.')[0] in ('bleak', 'paho', 'serial'): raise ImportError(n)\n" + " return real(n, *a, **k)\n" + "builtins.__import__ = imp; sys.argv = ['x', '--help']\n" + "import runpy; runpy.run_path('meshcore_repeater_observer.py', run_name='__main__')" + ) + r = subprocess.run([sys.executable, "-c", code], cwd=ROOT, capture_output=True, text=True) + assert r.returncode == 0 and "MC_SERIAL_PORT" in r.stdout + + +def test_mqtt_client_with_installed_paho(ob): + # paho 2.x refuses Client() without callback_api_version; 1.x has no such argument + c = ob.mqtt_client(client_id="t", clean_session=True, transport="websockets") + c.on_connect = lambda cl, ud, fl, rc: None + c.on_disconnect = lambda cl, ud, rc: None + c.username_pw_set("v1_AB", "token")