Bump project version to 2.0.3 and apply runtime patches for LXMF error handling

Author: Giu Platania

TASK.md

@@ -1,4 +1,6 @@
 # TASKS
+- 2026-03-01: DONE. Patch the installed LXMF runtime at startup so integer sync-offer error codes do not crash peer sync and block propagated messages from reaching the hub/UI.
+- 2026-03-01: DONE. Bump project version to 2.0.2 across Python, UI, and Electron manifests.
 - 2026-03-01: DONE. Fix LXMF peer offer-response handling so remote integer error codes do not crash sync processing with "'int' is not iterable".
 - 2026-03-01: DONE. Make app info prefer the configured hub display name so the UI shows the runtime hub name instead of the package name.
 - 2026-03-01: DONE. Add a remote launcher script that installs the backend from local source, installs npm when needed, and starts the API plus UI with the WebSocket URL derived from the API URL by default.

electron/package.json

@@ -1,7 +1,7 @@
 {
   "name": "rch-desktop",
   "private": true,
-  "version": "2.0.1",
+  "version": "2.0.3",
   "description": "Electron shell for Reticulum Community Hub.",
   "homepage": "https://github.com/FreeTAKTeam/Reticulum-Community-Hub",
   "main": "dist/main.js",

pyproject.toml

@@ -1,6 +1,6 @@
 [tool.poetry]
 name = "ReticulumTelemetryHub"
-version = "2.0.1"
+version = "2.0.3"
 description = "Reticulum-Telemetry-Hub (RTH) manages a complete TCP node across a Reticulum-based network, enabling communication and data sharing between clients like Sideband or Meshchat."
 authors = ["naman108, corvo"]
 readme = "README.md"

reticulum_telemetry_hub/lxmf_runtime.py

@@ -0,0 +1,109 @@
+"""Runtime compatibility patches for the external LXMF package."""
+
+from __future__ import annotations
+
+import importlib
+from functools import wraps
+from typing import Any
+from typing import Callable
+
+_OFFER_RESPONSE_PATCHED = "__rch_offer_response_patched__"
+
+
+def apply_lxmf_runtime_patches() -> None:
+    """Patch external LXMF runtime behavior required by the hub."""
+
+    lxmpeer_module = importlib.import_module("LXMF.LXMPeer")
+    _patch_offer_response_class(lxmpeer_module.LXMPeer)
+
+
+def _patch_offer_response_class(peer_class: type[Any]) -> None:
+    """Wrap ``offer_response`` so integer error codes are handled safely."""
+
+    offer_response = getattr(peer_class, "offer_response", None)
+    if not callable(offer_response):
+        return
+
+    if getattr(offer_response, _OFFER_RESPONSE_PATCHED, False):
+        return
+
+    patched_offer_response = _build_offer_response_wrapper(offer_response)
+    setattr(patched_offer_response, _OFFER_RESPONSE_PATCHED, True)
+    setattr(peer_class, "offer_response", patched_offer_response)
+
+
+def _build_offer_response_wrapper(
+    original_offer_response: Callable[..., Any],
+) -> Callable[..., Any]:
+    """Build a wrapper around the installed LXMF ``offer_response`` handler."""
+
+    @wraps(original_offer_response)
+    def patched_offer_response(self: Any, request_receipt: Any) -> Any:
+        response = getattr(request_receipt, "response", None)
+        if type(response) is int and _handle_integer_offer_response(self, response):
+            return None
+
+        return original_offer_response(self, request_receipt)
+
+    return patched_offer_response
+
+
+def _handle_integer_offer_response(peer: Any, response: int) -> bool:
+    """Return True when an integer response has been handled locally."""
+
+    peer_class = peer.__class__
+    known_error_responses = (
+        (
+            getattr(peer_class, "ERROR_INVALID_KEY", None),
+            "Remote indicated that the peering key was invalid, sync aborted",
+        ),
+        (
+            getattr(peer_class, "ERROR_INVALID_DATA", None),
+            "Remote indicated that the sync offer data was invalid, sync aborted",
+        ),
+        (
+            getattr(peer_class, "ERROR_INVALID_STAMP", None),
+            "Remote indicated that the sync offer stamp was invalid, sync aborted",
+        ),
+        (
+            getattr(peer_class, "ERROR_TIMEOUT", None),
+            "Remote indicated that the sync offer timed out, sync aborted",
+        ),
+    )
+    for expected_response, message in known_error_responses:
+        if expected_response is not None and response == expected_response:
+            _abort_sync_offer(peer, message)
+            return True
+
+    pass_through_responses = {
+        expected_response
+        for expected_response in (
+            getattr(peer_class, "ERROR_NO_IDENTITY", None),
+            getattr(peer_class, "ERROR_NO_ACCESS", None),
+            getattr(peer_class, "ERROR_THROTTLED", None),
+        )
+        if expected_response is not None
+    }
+    if response in pass_through_responses:
+        return False
+
+    _abort_sync_offer(
+        peer,
+        f"Remote returned unknown sync offer response {response}, sync aborted",
+    )
+    return True
+
+
+def _abort_sync_offer(peer: Any, message: str) -> None:
+    """Abort the current LXMF sync and tear down the active peer link."""
+
+    import RNS
+
+    RNS.log(message, RNS.LOG_VERBOSE)
+
+    link = getattr(peer, "link", None)
+    if link is not None:
+        link.teardown()
+
+    peer.link = None
+    peer.state = getattr(peer.__class__, "IDLE", getattr(peer, "state", None))

reticulum_telemetry_hub/reticulum_server/__main__.py

@@ -63,6 +63,7 @@
 from reticulum_telemetry_hub.config.models import HubAppConfig
 from reticulum_telemetry_hub.embedded_lxmd import EmbeddedLxmd
 from reticulum_telemetry_hub.lxmf_daemon.LXMF import display_name_from_app_data
+from reticulum_telemetry_hub.lxmf_runtime import apply_lxmf_runtime_patches
 from reticulum_telemetry_hub.reticulum_server.appearance import apply_icon_appearance
 from reticulum_telemetry_hub.reticulum_server.announce_capabilities import (
     AnnounceCapabilitiesConfig,
@@ -78,6 +79,8 @@
 from reticulum_telemetry_hub.lxmf_telemetry.telemetry_controller import (
     TelemetryController,
 )
+
+apply_lxmf_runtime_patches()
 from reticulum_telemetry_hub.lxmf_telemetry.sampler import TelemetrySampler
 from reticulum_telemetry_hub.lxmf_telemetry.telemeter_manager import TelemeterManager
 from reticulum_telemetry_hub.reticulum_server.services import (

tests/test_lxmf_peer.py

@@ -4,6 +4,10 @@
 
 import importlib
 
+import RNS
+
+from reticulum_telemetry_hub.lxmf_runtime import _patch_offer_response_class
+
 
 def test_offer_response_handles_integer_error_without_iterating(monkeypatch) -> None:
     """Abort cleanly when a remote peer returns an integer error code."""
@@ -33,3 +37,60 @@ def __init__(self, response: int) -> None:
     assert link.torn_down is True
     assert peer.link is None
     assert peer.state == lxmpeer_module.LXMPeer.IDLE
+
+
+def test_runtime_patch_handles_installed_lxmf_integer_errors(monkeypatch) -> None:
+    """Intercept installed LXMF integer errors before the upstream handler iterates them."""
+
+    monkeypatch.setattr(RNS, "log", lambda *args, **kwargs: None)
+
+    class DummyLink:
+        def __init__(self) -> None:
+            self.torn_down = False
+
+        def teardown(self) -> None:
+            self.torn_down = True
+
+    class DummyReceipt:
+        def __init__(self, response: int) -> None:
+            self.response = response
+
+    class DummyPeer:
+        ERROR_NO_IDENTITY = 1
+        ERROR_NO_ACCESS = 2
+        ERROR_THROTTLED = 3
+        ERROR_INVALID_KEY = 4
+        ERROR_INVALID_DATA = 5
+        ERROR_INVALID_STAMP = 6
+        ERROR_TIMEOUT = 7
+        IDLE = "idle"
+
+        def __init__(self) -> None:
+            self.link = None
+            self.state = "busy"
+            self.original_called = False
+            self.last_response = None
+
+        def offer_response(self, request_receipt) -> None:
+            self.original_called = True
+            self.last_response = request_receipt.response
+
+    _patch_offer_response_class(DummyPeer)
+
+    rejected_peer = DummyPeer()
+    rejected_peer.link = DummyLink()
+
+    rejected_peer.offer_response(DummyReceipt(DummyPeer.ERROR_INVALID_KEY))
+
+    assert rejected_peer.original_called is False
+    assert rejected_peer.link is None
+    assert rejected_peer.state == DummyPeer.IDLE
+
+    passthrough_peer = DummyPeer()
+    passthrough_peer.link = DummyLink()
+
+    passthrough_peer.offer_response(DummyReceipt(DummyPeer.ERROR_NO_ACCESS))
+
+    assert passthrough_peer.original_called is True
+    assert passthrough_peer.link is not None
+    assert passthrough_peer.last_response == DummyPeer.ERROR_NO_ACCESS

ui/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rth-core-ui",
-  "version": "2.0.1",
+  "version": "2.0.3",
   "private": true,
   "type": "module",
   "scripts": {