mmrelay 1.1.3__py3-none-any.whl → 1.2.0__py3-none-any.whl

mmrelay/meshtastic_utils.py

@@ -1,9 +1,12 @@
 import asyncio
 import contextlib
+import inspect
 import io
 import os
+import re
 import threading
 import time
+from concurrent.futures import Future
 from typing import List
 
 import meshtastic.ble_interface
@@ -11,10 +14,52 @@ import meshtastic.serial_interface
 import meshtastic.tcp_interface
 import serial  # For serial port exceptions
 import serial.tools.list_ports  # Import serial tools for port listing
-from bleak.exc import BleakDBusError, BleakError
 from meshtastic.protobuf import mesh_pb2, portnums_pb2
 from pubsub import pub
 
+from mmrelay.config import get_meshtastic_config_value
+from mmrelay.constants.config import (
+    CONFIG_KEY_MESHNET_NAME,
+    CONFIG_SECTION_MESHTASTIC,
+    DEFAULT_DETECTION_SENSOR,
+)
+from mmrelay.constants.formats import (
+    DETECTION_SENSOR_APP,
+    EMOJI_FLAG_VALUE,
+    TEXT_MESSAGE_APP,
+)
+from mmrelay.constants.messages import (
+    DEFAULT_CHANNEL_VALUE,
+    PORTNUM_NUMERIC_VALUE,
+)
+from mmrelay.constants.network import (
+    CONFIG_KEY_BLE_ADDRESS,
+    CONFIG_KEY_CONNECTION_TYPE,
+    CONFIG_KEY_HOST,
+    CONFIG_KEY_SERIAL_PORT,
+    CONNECTION_TYPE_BLE,
+    CONNECTION_TYPE_NETWORK,
+    CONNECTION_TYPE_SERIAL,
+    CONNECTION_TYPE_TCP,
+    DEFAULT_BACKOFF_TIME,
+    DEFAULT_RETRY_ATTEMPTS,
+    ERRNO_BAD_FILE_DESCRIPTOR,
+    INFINITE_RETRIES,
+    SYSTEMD_INIT_SYSTEM,
+)
+
+# Import BLE exceptions conditionally
+try:
+    from bleak.exc import BleakDBusError, BleakError
+except ImportError:
+    # Define dummy exception classes if bleak is not available
+    class BleakDBusError(Exception):
+        pass
+
+    class BleakError(Exception):
+        pass
+
+
 from mmrelay.db_utils import (
     get_longname,
     get_message_map_by_meshtastic_id,
@@ -35,6 +80,7 @@ matrix_rooms: List[dict] = []
 # Initialize logger for Meshtastic
 logger = get_logger(name="Meshtastic")
 
+
 # Global variables for the Meshtastic connection and event loop management
 meshtastic_client = None
 event_loop = None  # Will be set from main.py
@@ -52,12 +98,106 @@ subscribed_to_messages = False
 subscribed_to_connection_lost = False
 
 
+def _submit_coro(coro, loop=None):
+    """
+    Submit an asyncio coroutine for execution on the appropriate event loop and return a Future representing its result.
+
+    If `loop` (or the module-level `event_loop`) is an open asyncio event loop, the coroutine is scheduled thread-safely via `asyncio.run_coroutine_threadsafe`. If there is a currently running loop in the calling thread, the coroutine is scheduled with that loop's `create_task`. If no running loop exists, the coroutine is executed synchronously with `asyncio.run` and its result (or raised exception) is wrapped in a completed Future. If `coro` is not a coroutine, returns None.
+
+    Parameters:
+        coro: The coroutine object to execute.
+        loop: Optional asyncio event loop to target. If omitted, the module-level `event_loop` is used.
+
+    Returns:
+        A Future-like object representing the coroutine's eventual result, or None if `coro` is not a coroutine.
+    """
+    if not inspect.iscoroutine(coro):
+        # Defensive guard for tests that mistakenly patch async funcs to return None
+        return None
+    loop = loop or event_loop
+    if loop and isinstance(loop, asyncio.AbstractEventLoop) and not loop.is_closed():
+        return asyncio.run_coroutine_threadsafe(coro, loop)
+    # Fallback: schedule on a real loop if present; tests can override this.
+    try:
+        running = asyncio.get_running_loop()
+        return running.create_task(coro)
+    except RuntimeError:
+        # No running loop: run synchronously and wrap the result in a completed Future
+        f = Future()
+        try:
+            result = asyncio.run(coro)
+            f.set_result(result)
+        except Exception as e:
+            f.set_exception(e)
+        return f
+
+
+def _get_device_metadata(client):
+    """
+    Retrieve device metadata from a Meshtastic client.
+
+    Attempts to call client.localNode.getMetadata() to extract a firmware version and capture the raw output. If the client lacks a usable localNode.getMetadata method or parsing fails, returns defaults. The captured raw output is truncated to 4096 characters.
+
+    Returns:
+        dict: {
+            "firmware_version": str,  # parsed firmware version or "unknown"
+            "raw_output": str,        # captured output from getMetadata() (possibly truncated)
+            "success": bool           # True when a firmware_version was successfully parsed
+        }
+    """
+    result = {"firmware_version": "unknown", "raw_output": "", "success": False}
+
+    try:
+        # Preflight: client may be a mock without localNode/getMetadata
+        if not getattr(client, "localNode", None) or not hasattr(
+            client.localNode, "getMetadata"
+        ):
+            logger.debug(
+                "Meshtastic client has no localNode.getMetadata(); skipping metadata retrieval"
+            )
+            return result
+
+        # Capture getMetadata() output to extract firmware version
+        output_capture = io.StringIO()
+        with contextlib.redirect_stdout(output_capture), contextlib.redirect_stderr(
+            output_capture
+        ):
+            client.localNode.getMetadata()
+
+        console_output = output_capture.getvalue()
+        output_capture.close()
+
+        # Cap raw_output length to avoid memory bloat
+        if len(console_output) > 4096:
+            console_output = console_output[:4096] + "…"
+        result["raw_output"] = console_output
+
+        # Parse firmware version from the output using robust regex
+        # Case-insensitive, handles quotes, whitespace, and various formats
+        match = re.search(
+            r"(?i)\bfirmware_version\s*:\s*['\"]?\s*([^\s\r\n'\"]+)\s*['\"]?",
+            console_output,
+        )
+        if match:
+            parsed = match.group(1).strip()
+            if parsed:
+                result["firmware_version"] = parsed
+                result["success"] = True
+
+    except Exception as e:
+        logger.debug(
+            "Could not retrieve device metadata via localNode.getMetadata()", exc_info=e
+        )
+
+    return result
+
+
 def is_running_as_service():
     """
     Determine if the application is running as a systemd service.
 
     Returns:
-        bool: True if running under systemd (as indicated by the INVOCATION_ID environment variable or parent process), False otherwise.
+        bool: True if the process is running under systemd, either by detecting the INVOCATION_ID environment variable or by checking if the parent process is systemd; otherwise, False.
     """
     # Check for INVOCATION_ID environment variable (set by systemd)
     if os.environ.get("INVOCATION_ID"):
@@ -70,7 +210,7 @@ def is_running_as_service():
                 if line.startswith("PPid:"):
                     ppid = int(line.split()[1])
                     with open(f"/proc/{ppid}/comm") as p:
-                        return p.read().strip() == "systemd"
+                        return p.read().strip() == SYSTEMD_INIT_SYSTEM
     except (FileNotFoundError, PermissionError, ValueError):
         pass
 
@@ -88,22 +228,26 @@ def serial_port_exists(port_name):
 
 def connect_meshtastic(passed_config=None, force_connect=False):
     """
-    Establishes and manages a connection to a Meshtastic device using serial, BLE, or TCP, with automatic retries and event subscriptions.
+    Establish and return a Meshtastic client connection (serial, BLE, or TCP), with configurable retries and event subscription.
 
-    If a configuration is provided, updates the global configuration and Matrix room mappings. If already connected and not forced, returns the existing client. Handles reconnection logic with exponential backoff, verifies serial port existence, and subscribes to message and connection lost events upon successful connection.
+    Attempts to (re)connect using the module configuration and updates module-level state on success (meshtastic_client, matrix_rooms, and event subscriptions). Validates required configuration keys, supports the legacy "network" alias for TCP, verifies serial port presence before connecting, and performs exponential backoff on connection failures. Subscribes once to message and connection-lost events when a connection is established.
 
     Parameters:
-        passed_config (dict, optional): Configuration dictionary to use for the connection.
-        force_connect (bool, optional): If True, forces a new connection even if one already exists.
+        passed_config (dict, optional): Configuration to use for the connection; if provided, replaces the module-level config and may update matrix_rooms.
+        force_connect (bool, optional): If True, forces creating a new connection even if one already exists.
 
     Returns:
-        meshtastic_client: The connected Meshtastic client instance, or None if connection fails or shutdown is in progress.
+        The connected Meshtastic client instance on success, or None if connection cannot be established or shutdown is in progress.
     """
-    global meshtastic_client, shutting_down, config, matrix_rooms
+    global meshtastic_client, shutting_down, reconnecting, config, matrix_rooms
     if shutting_down:
         logger.debug("Shutdown in progress. Not attempting to connect.")
         return None
 
+    if reconnecting and not force_connect:
+        logger.debug("Reconnection already in progress. Not attempting new connection.")
+        return None
+
     # Update the global config if a config is passed
     if passed_config is not None:
         config = passed_config
@@ -129,17 +273,37 @@ def connect_meshtastic(passed_config=None, force_connect=False):
             logger.error("No configuration available. Cannot connect to Meshtastic.")
             return None
 
+        # Check if meshtastic config section exists
+        if (
+            CONFIG_SECTION_MESHTASTIC not in config
+            or config[CONFIG_SECTION_MESHTASTIC] is None
+        ):
+            logger.error(
+                "No Meshtastic configuration section found. Cannot connect to Meshtastic."
+            )
+            return None
+
+        # Check if connection_type is specified
+        if (
+            CONFIG_KEY_CONNECTION_TYPE not in config[CONFIG_SECTION_MESHTASTIC]
+            or config[CONFIG_SECTION_MESHTASTIC][CONFIG_KEY_CONNECTION_TYPE] is None
+        ):
+            logger.error(
+                "No connection type specified in Meshtastic configuration. Cannot connect to Meshtastic."
+            )
+            return None
+
         # Determine connection type and attempt connection
-        connection_type = config["meshtastic"]["connection_type"]
+        connection_type = config[CONFIG_SECTION_MESHTASTIC][CONFIG_KEY_CONNECTION_TYPE]
 
         # Support legacy "network" connection type (now "tcp")
-        if connection_type == "network":
-            connection_type = "tcp"
+        if connection_type == CONNECTION_TYPE_NETWORK:
+            connection_type = CONNECTION_TYPE_TCP
             logger.warning(
                 "Using 'network' connection type (legacy). 'tcp' is now the preferred name and 'network' will be deprecated in a future version."
             )
-        retry_limit = 0  # 0 means infinite retries
-        attempts = 1
+        retry_limit = INFINITE_RETRIES  # 0 means infinite retries
+        attempts = DEFAULT_RETRY_ATTEMPTS
         successful = False
 
         while (
@@ -148,9 +312,15 @@ def connect_meshtastic(passed_config=None, force_connect=False):
             and not shutting_down
         ):
             try:
-                if connection_type == "serial":
+                if connection_type == CONNECTION_TYPE_SERIAL:
                     # Serial connection
-                    serial_port = config["meshtastic"]["serial_port"]
+                    serial_port = config["meshtastic"].get(CONFIG_KEY_SERIAL_PORT)
+                    if not serial_port:
+                        logger.error(
+                            "No serial port specified in Meshtastic configuration."
+                        )
+                        return None
+
                     logger.info(f"Connecting to serial port {serial_port}")
 
                     # Check if serial port exists before connecting
@@ -166,9 +336,9 @@ def connect_meshtastic(passed_config=None, force_connect=False):
                         serial_port
                     )
 
-                elif connection_type == "ble":
+                elif connection_type == CONNECTION_TYPE_BLE:
                     # BLE connection
-                    ble_address = config["meshtastic"].get("ble_address")
+                    ble_address = config["meshtastic"].get(CONFIG_KEY_BLE_ADDRESS)
                     if ble_address:
                         logger.info(f"Connecting to BLE address {ble_address}")
 
@@ -183,9 +353,15 @@ def connect_meshtastic(passed_config=None, force_connect=False):
                         logger.error("No BLE address provided.")
                         return None
 
-                elif connection_type == "tcp":
+                elif connection_type == CONNECTION_TYPE_TCP:
                     # TCP connection
-                    target_host = config["meshtastic"]["host"]
+                    target_host = config["meshtastic"].get(CONFIG_KEY_HOST)
+                    if not target_host:
+                        logger.error(
+                            "No host specified in Meshtastic configuration for TCP connection."
+                        )
+                        return None
+
                     logger.info(f"Connecting to host {target_host}")
 
                     # Connect without progress indicator
@@ -198,9 +374,25 @@ def connect_meshtastic(passed_config=None, force_connect=False):
 
                 successful = True
                 nodeInfo = meshtastic_client.getMyNodeInfo()
-                logger.info(
-                    f"Connected to {nodeInfo['user']['shortName']} / {nodeInfo['user']['hwModel']}"
-                )
+
+                # Safely access node info fields
+                user_info = nodeInfo.get("user", {}) if nodeInfo else {}
+                short_name = user_info.get("shortName", "unknown")
+                hw_model = user_info.get("hwModel", "unknown")
+
+                # Get firmware version from device metadata
+                metadata = _get_device_metadata(meshtastic_client)
+                firmware_version = metadata["firmware_version"]
+
+                if metadata.get("success"):
+                    logger.info(
+                        f"Connected to {short_name} / {hw_model} / Meshtastic Firmware version {firmware_version}"
+                    )
+                else:
+                    logger.info(f"Connected to {short_name} / {hw_model}")
+                    logger.debug(
+                        "Device firmware version unavailable from getMetadata()"
+                    )
 
                 # Subscribe to message and connection lost events (only once per application run)
                 global subscribed_to_messages, subscribed_to_connection_lost
@@ -216,26 +408,42 @@ def connect_meshtastic(passed_config=None, force_connect=False):
                     subscribed_to_connection_lost = True
                     logger.debug("Subscribed to meshtastic.connection.lost")
 
-            except (
-                serial.SerialException,
-                BleakDBusError,
-                BleakError,
-                Exception,
-            ) as e:
+            except (TimeoutError, ConnectionRefusedError, MemoryError) as e:
+                # Handle critical errors that should not be retried
+                logger.error(f"Critical connection error: {e}")
+                return None
+            except (serial.SerialException, BleakDBusError, BleakError) as e:
+                # Handle specific connection errors
                 if shutting_down:
                     logger.debug("Shutdown in progress. Aborting connection attempts.")
                     break
                 attempts += 1
                 if retry_limit == 0 or attempts <= retry_limit:
                     wait_time = min(
-                        attempts * 2, 30
-                    )  # Exponential backoff capped at 30s
+                        2**attempts, 60
+                    )  # Consistent exponential backoff, capped at 60s
                     logger.warning(
-                        f"Attempt #{attempts - 1} failed. Retrying in {wait_time} secs: {e}"
+                        f"Connection attempt {attempts} failed: {e}. Retrying in {wait_time} seconds..."
                     )
                     time.sleep(wait_time)
                 else:
-                    logger.error(f"Could not connect after {retry_limit} attempts: {e}")
+                    logger.error(f"Connection failed after {attempts} attempts: {e}")
+                    return None
+            except Exception as e:
+                if shutting_down:
+                    logger.debug("Shutdown in progress. Aborting connection attempts.")
+                    break
+                attempts += 1
+                if retry_limit == 0 or attempts <= retry_limit:
+                    wait_time = min(
+                        2**attempts, 60
+                    )  # Consistent exponential backoff, capped at 60s
+                    logger.warning(
+                        f"An unexpected error occurred on attempt {attempts}: {e}. Retrying in {wait_time} seconds..."
+                    )
+                    time.sleep(wait_time)
+                else:
+                    logger.error(f"Connection failed after {attempts} attempts: {e}")
                     return None
 
     return meshtastic_client
@@ -243,11 +451,15 @@ def connect_meshtastic(passed_config=None, force_connect=False):
 
 def on_lost_meshtastic_connection(interface=None, detection_source="unknown"):
     """
-    Handles loss of Meshtastic connection by initiating a reconnection sequence unless the system is shutting down or already reconnecting.
+    Mark the Meshtastic connection as lost, close the current client, and initiate an asynchronous reconnect.
 
-    Args:
-        interface: The Meshtastic interface (optional, for compatibility)
-        detection_source: Source that detected the connection loss (for debugging)
+    If a shutdown is in progress or a reconnect is already underway this function returns immediately. Otherwise it:
+    - sets the module-level `reconnecting` flag,
+    - attempts to close and clear the module-level `meshtastic_client` (handles already-closed file descriptors),
+    - schedules the reconnect() coroutine on the global event loop if that loop exists and is open.
+
+    Parameters:
+        detection_source (str): Identifier for where or how the loss was detected; used in log messages.
     """
     global meshtastic_client, reconnecting, shutting_down, event_loop, reconnect_task
     with meshtastic_lock:
@@ -266,7 +478,7 @@ def on_lost_meshtastic_connection(interface=None, detection_source="unknown"):
             try:
                 meshtastic_client.close()
             except OSError as e:
-                if e.errno == 9:
+                if e.errno == ERRNO_BAD_FILE_DESCRIPTOR:
                     # Bad file descriptor, already closed
                     pass
                 else:
@@ -275,18 +487,23 @@ def on_lost_meshtastic_connection(interface=None, detection_source="unknown"):
                 logger.warning(f"Error closing Meshtastic client: {e}")
         meshtastic_client = None
 
-        if event_loop:
-            reconnect_task = asyncio.run_coroutine_threadsafe(reconnect(), event_loop)
+        if event_loop and not event_loop.is_closed():
+            reconnect_task = event_loop.create_task(reconnect())
 
 
 async def reconnect():
     """
-    Asynchronously attempts to reconnect to the Meshtastic device using exponential backoff, stopping if a shutdown is initiated.
-
-    Reconnection attempts start with a 10-second delay, doubling up to a maximum of 5 minutes between attempts. If not running as a service, a progress bar is displayed during the wait. The process stops immediately if `shutting_down` is set to True or upon successful reconnection.
+    Attempt to re-establish a Meshtastic connection with exponential backoff.
+
+    This coroutine repeatedly tries to reconnect by invoking connect_meshtastic(force_connect=True)
+    in a thread executor until a connection is obtained, the global shutting_down flag is set,
+    or the task is cancelled. It begins with DEFAULT_BACKOFF_TIME and doubles the wait after each
+    failed attempt, capping the backoff at 300 seconds. The function ensures the module-level
+    reconnecting flag is cleared before it returns. asyncio.CancelledError is handled (logged)
+    and causes the routine to stop.
     """
     global meshtastic_client, reconnecting, shutting_down
-    backoff_time = 10
+    backoff_time = DEFAULT_BACKOFF_TIME
     try:
         while not shutting_down:
             try:
@@ -323,7 +540,11 @@ async def reconnect():
                         "Shutdown in progress. Aborting reconnection attempts."
                     )
                     break
-                meshtastic_client = connect_meshtastic(force_connect=True)
+                loop = asyncio.get_running_loop()
+                # Pass force_connect=True without overwriting the global config
+                meshtastic_client = await loop.run_in_executor(
+                    None, connect_meshtastic, None, True
+                )
                 if meshtastic_client:
                     logger.info("Reconnected successfully.")
                     break
@@ -340,17 +561,33 @@ async def reconnect():
 
 def on_meshtastic_message(packet, interface):
     """
-    Processes incoming Meshtastic messages and relays them to Matrix rooms or plugins based on message type and configuration.
+    Handle an incoming Meshtastic packet and relay it to Matrix rooms or plugins as configured.
+
+    This function inspects a Meshtastic `packet` (expected as a dict), applies interaction rules (reactions, replies, replies storage, detection-sensor filtering), and either:
+    - relays reactions or replies as appropriate to the mapped Matrix event/room,
+    - relays normal text messages to all Matrix rooms mapped to the message's Meshtastic channel (unless the message is a direct message to the relay node or a plugin handles it),
+    - or dispatches non-text or unhandled packets to plugins for processing.
 
-    Handles reactions and replies by relaying them to Matrix if enabled. Normal text messages are relayed to all mapped Matrix rooms unless handled by a plugin or directed to the relay node. Non-text messages are passed to plugins for processing. Messages from unmapped channels or disabled detection sensors are ignored. Ensures sender information is retrieved or stored as needed.
+    Behavior notes:
+    - Uses global configuration and matrix_rooms mappings; returns immediately if configuration or event loop is missing or if shutdown is in progress.
+    - Resolves sender display names from a local DB or node info and persists them when found.
+    - Honors interaction settings for reactions and replies, and the meshtastic `detection_sensor` configuration when handling detection sensor packets.
+    - Uses _submit_coro to schedule Matrix/plugin coroutines on the configured event loop.
+    - Side effects: schedules Matrix relays, may call plugin handlers, and may store sender metadata and message->Matrix mappings via other utilities.
+
+    No return value.
     """
     global config, matrix_rooms
 
+    # Validate packet structure
+    if not packet or not isinstance(packet, dict):
+        logger.error("Received malformed packet: packet is None or not a dict")
+        return
+
     # Log that we received a message (without the full packet details)
-    if packet.get("decoded", {}).get("text"):
-        logger.info(
-            f"Received Meshtastic message: {packet.get('decoded', {}).get('text')}"
-        )
+    decoded = packet.get("decoded")
+    if decoded and isinstance(decoded, dict) and decoded.get("text"):
+        logger.info(f"Received Meshtastic message: {decoded.get('text')}")
     else:
         logger.debug("Received non-text Meshtastic message")
 
@@ -367,13 +604,13 @@ def on_meshtastic_message(packet, interface):
     message_storage_enabled(interactions)
 
     # Filter packets based on interaction settings
-    if packet.get("decoded", {}).get("portnum") == "TEXT_MESSAGE_APP":
+    if packet.get("decoded", {}).get("portnum") == TEXT_MESSAGE_APP:
         decoded = packet.get("decoded", {})
         # Filter out reactions if reactions are disabled
         if (
             not interactions["reactions"]
             and "emoji" in decoded
-            and decoded.get("emoji") == 1
+            and decoded.get("emoji") == EMOJI_FLAG_VALUE
         ):
             logger.debug(
                 "Filtered out reaction packet due to reactions being disabled."
@@ -400,7 +637,7 @@ def on_meshtastic_message(packet, interface):
     decoded = packet.get("decoded", {})
     text = decoded.get("text")
     replyId = decoded.get("replyId")
-    emoji_flag = "emoji" in decoded and decoded["emoji"] == 1
+    emoji_flag = "emoji" in decoded and decoded["emoji"] == EMOJI_FLAG_VALUE
 
     # Determine if this is a direct message to the relay node
     from meshtastic.mesh_interface import BROADCAST_NUM
@@ -415,7 +652,7 @@ def on_meshtastic_message(packet, interface):
         # Message to someone else; ignoring for broadcasting logic
         is_direct_message = False
 
-    meshnet_name = config["meshtastic"]["meshnet_name"]
+    meshnet_name = config[CONFIG_SECTION_MESHTASTIC][CONFIG_KEY_MESHNET_NAME]
 
     # Reaction handling (Meshtastic -> Matrix)
     # If replyId and emoji_flag are present and reactions are enabled, we relay as text reactions in Matrix
@@ -444,7 +681,7 @@ def on_meshtastic_message(packet, interface):
             )
 
             # Relay the reaction as emote to Matrix, preserving the original meshnet name
-            asyncio.run_coroutine_threadsafe(
+            _submit_coro(
                 matrix_relay(
                     matrix_room_id,
                     reaction_message,
@@ -484,7 +721,7 @@ def on_meshtastic_message(packet, interface):
             logger.info(f"Relaying Meshtastic reply from {longname} to Matrix")
 
             # Relay the reply to Matrix with proper reply formatting
-            asyncio.run_coroutine_threadsafe(
+            _submit_coro(
                 matrix_relay(
                     matrix_room_id,
                     formatted_message,
@@ -510,12 +747,11 @@ def on_meshtastic_message(packet, interface):
         if channel is None:
             # If channel not specified, deduce from portnum
             if (
-                decoded.get("portnum") == "TEXT_MESSAGE_APP"
-                or decoded.get("portnum") == 1
+                decoded.get("portnum") == TEXT_MESSAGE_APP
+                or decoded.get("portnum") == PORTNUM_NUMERIC_VALUE
+                or decoded.get("portnum") == DETECTION_SENSOR_APP
             ):
-                channel = 0
-            elif decoded.get("portnum") == "DETECTION_SENSOR_APP":
-                channel = 0
+                channel = DEFAULT_CHANNEL_VALUE
             else:
                 logger.debug(
                     f"Unknown portnum {decoded.get('portnum')}, cannot determine channel"
@@ -534,9 +770,11 @@ def on_meshtastic_message(packet, interface):
             return
 
         # If detection_sensor is disabled and this is a detection sensor packet, skip it
-        if decoded.get("portnum") == "DETECTION_SENSOR_APP" and not config[
-            "meshtastic"
-        ].get("detection_sensor", False):
+        if decoded.get(
+            "portnum"
+        ) == DETECTION_SENSOR_APP and not get_meshtastic_config_value(
+            config, "detection_sensor", DEFAULT_DETECTION_SENSOR
+        ):
             logger.debug(
                 "Detection sensor packet received, but detection sensor processing is disabled."
             )
@@ -585,15 +823,19 @@ def on_meshtastic_message(packet, interface):
         found_matching_plugin = False
         for plugin in plugins:
             if not found_matching_plugin:
-                result = asyncio.run_coroutine_threadsafe(
-                    plugin.handle_meshtastic_message(
-                        packet, formatted_message, longname, meshnet_name
-                    ),
-                    loop=loop,
-                )
-                found_matching_plugin = result.result()
-                if found_matching_plugin:
-                    logger.debug(f"Processed by plugin {plugin.plugin_name}")
+                try:
+                    result = _submit_coro(
+                        plugin.handle_meshtastic_message(
+                            packet, formatted_message, longname, meshnet_name
+                        ),
+                        loop=loop,
+                    )
+                    found_matching_plugin = result.result()
+                    if found_matching_plugin:
+                        logger.debug(f"Processed by plugin {plugin.plugin_name}")
+                except Exception as e:
+                    logger.error(f"Plugin {plugin.plugin_name} failed: {e}")
+                    # Continue processing other plugins
 
         # If message is a DM or handled by plugin, do not relay further
         if is_direct_message:
@@ -618,7 +860,7 @@ def on_meshtastic_message(packet, interface):
                 # Storing the message_map (if enabled) occurs inside matrix_relay() now,
                 # controlled by relay_reactions.
                 try:
-                    asyncio.run_coroutine_threadsafe(
+                    _submit_coro(
                         matrix_relay(
                             room["id"],
                             formatted_message,
@@ -642,36 +884,37 @@ def on_meshtastic_message(packet, interface):
         found_matching_plugin = False
         for plugin in plugins:
             if not found_matching_plugin:
-                result = asyncio.run_coroutine_threadsafe(
-                    plugin.handle_meshtastic_message(
-                        packet,
-                        formatted_message=None,
-                        longname=None,
-                        meshnet_name=None,
-                    ),
-                    loop=loop,
-                )
-                found_matching_plugin = result.result()
-                if found_matching_plugin:
-                    logger.debug(
-                        f"Processed {portnum} with plugin {plugin.plugin_name}"
+                try:
+                    result = _submit_coro(
+                        plugin.handle_meshtastic_message(
+                            packet,
+                            formatted_message=None,
+                            longname=None,
+                            meshnet_name=None,
+                        ),
+                        loop=loop,
                     )
+                    found_matching_plugin = result.result()
+                    if found_matching_plugin:
+                        logger.debug(
+                            f"Processed {portnum} with plugin {plugin.plugin_name}"
+                        )
+                except Exception as e:
+                    logger.error(f"Plugin {plugin.plugin_name} failed: {e}")
+                    # Continue processing other plugins
 
 
 async def check_connection():
     """
-    Periodically checks the health of the Meshtastic connection and triggers reconnection if the connection is lost.
-
-    Health checks can be enabled/disabled via configuration. When enabled, for non-BLE connections,
-    invokes `localNode.getMetadata()` at configurable intervals (default 60 seconds) to verify connectivity.
-    If the check fails or the firmware version is missing, initiates reconnection logic.
-
-    BLE connections rely on real-time disconnection detection and skip periodic health checks.
-    The function runs continuously until shutdown is requested.
-
-    Configuration:
-        health_check.enabled: Enable/disable health checks (default: true)
-        health_check.heartbeat_interval: Interval between checks in seconds (default: 60)
+    Periodically verify Meshtastic connection health and trigger reconnection when the device is unresponsive.
+
+    Checks run continuously until shutdown. Behavior:
+    - Controlled by config['meshtastic']['health_check']:
+      - 'enabled' (bool, default True) — enable/disable periodic checks.
+      - 'heartbeat_interval' (int, seconds, default 60) — check interval. Backwards-compatible: if 'heartbeat_interval' exists directly under config['meshtastic'], that value is used.
+    - For non-BLE connections, calls _get_device_metadata(client). If metadata parsing fails, performs a fallback probe via client.getMyNodeInfo(); if both fail, on_lost_meshtastic_connection(...) is invoked to start reconnection.
+    - BLE connections are excluded from periodic checks because the underlying library detects disconnections in real time.
+    - No return value; runs as a background coroutine until global shutting_down is True.
     """
     global meshtastic_client, shutting_down, config
 
@@ -680,7 +923,7 @@ async def check_connection():
         logger.error("No configuration available. Cannot check connection.")
         return
 
-    connection_type = config["meshtastic"]["connection_type"]
+    connection_type = config[CONFIG_SECTION_MESHTASTIC][CONFIG_KEY_CONNECTION_TYPE]
 
     # Get health check configuration
     health_config = config["meshtastic"].get("health_check", {})
@@ -702,7 +945,7 @@ async def check_connection():
         if meshtastic_client and not reconnecting:
             # BLE has real-time disconnection detection in the library
             # Skip periodic health checks to avoid duplicate reconnection attempts
-            if connection_type == "ble":
+            if connection_type == CONNECTION_TYPE_BLE:
                 if not ble_skip_logged:
                     logger.info(
                         "BLE connection uses real-time disconnection detection - health checks disabled"
@@ -710,15 +953,21 @@ async def check_connection():
                     ble_skip_logged = True
             else:
                 try:
-                    output_capture = io.StringIO()
-                    with contextlib.redirect_stdout(
-                        output_capture
-                    ), contextlib.redirect_stderr(output_capture):
-                        meshtastic_client.localNode.getMetadata()
-
-                    console_output = output_capture.getvalue()
-                    if "firmware_version" not in console_output:
-                        raise Exception("No firmware_version in getMetadata output.")
+                    # Use helper function to get device metadata
+                    metadata = _get_device_metadata(meshtastic_client)
+                    if not metadata["success"]:
+                        # Fallback probe: device responding at all?
+                        try:
+                            _ = meshtastic_client.getMyNodeInfo()
+                        except Exception as probe_err:
+                            raise Exception(
+                                "Metadata and nodeInfo probes failed"
+                            ) from probe_err
+                        else:
+                            logger.debug(
+                                "Metadata parse failed but device responded to getMyNodeInfo(); skipping reconnect this cycle"
+                            )
+                            continue
 
                 except Exception as e:
                     # Only trigger reconnection if we're not already reconnecting
@@ -751,9 +1000,7 @@ def sendTextReply(
     channelIndex: int = 0,
 ):
     """
-    Send a Meshtastic text message as a reply to a specific previous message.
-
-    Creates and sends a reply message by setting the `reply_id` field in the Meshtastic Data protobuf, enabling proper reply threading. Returns the sent packet with its ID populated.
+    Sends a text message as a reply to a specific previous message via the Meshtastic interface.
 
     Parameters:
         interface: The Meshtastic interface to send through.
@@ -764,10 +1011,15 @@ def sendTextReply(
         channelIndex (int): The channel index to send the message on.
 
     Returns:
-        The sent MeshPacket with its ID field populated.
+        The sent MeshPacket with its ID field populated, or None if sending fails or the interface is unavailable.
     """
     logger.debug(f"Sending text reply: '{text}' replying to message ID {reply_id}")
 
+    # Check if interface is available
+    if interface is None:
+        logger.error("No Meshtastic interface available for sending reply")
+        return None
+
     # Create the Data protobuf message with reply_id set
     data_msg = mesh_pb2.Data()
     data_msg.portnum = portnums_pb2.PortNum.TEXT_MESSAGE_APP
@@ -781,9 +1033,13 @@ def sendTextReply(
     mesh_packet.id = interface._generatePacketId()
 
     # Send the packet using the existing infrastructure
-    return interface._sendPacket(
-        mesh_packet, destinationId=destinationId, wantAck=wantAck
-    )
+    try:
+        return interface._sendPacket(
+            mesh_packet, destinationId=destinationId, wantAck=wantAck
+        )
+    except Exception as e:
+        logger.error(f"Failed to send text reply: {e}")
+        return None
 
 
 if __name__ == "__main__":