mmrelay 1.2.1__py3-none-any.whl → 1.2.2__py3-none-any.whl

mmrelay/meshtastic_utils.py

@@ -2,13 +2,14 @@ import asyncio
 import contextlib
 import inspect
 import io
-import os
 import re
 import threading
 import time
 from concurrent.futures import Future
+from concurrent.futures import TimeoutError as FuturesTimeoutError
 from typing import List
 
+import meshtastic
 import meshtastic.ble_interface
 import meshtastic.serial_interface
 import meshtastic.tcp_interface
@@ -42,12 +43,13 @@ from mmrelay.constants.network import (
     CONNECTION_TYPE_SERIAL,
     CONNECTION_TYPE_TCP,
     DEFAULT_BACKOFF_TIME,
-    DEFAULT_RETRY_ATTEMPTS,
     ERRNO_BAD_FILE_DESCRIPTOR,
-    INFINITE_RETRIES,
-    SYSTEMD_INIT_SYSTEM,
+INFINITE_RETRIES,
 )
 
+# Maximum number of timeout retries when retries are configured as infinite.
+MAX_TIMEOUT_RETRIES_INFINITE = 5
+
 # Import BLE exceptions conditionally
 try:
     from bleak.exc import BleakDBusError, BleakError
@@ -68,6 +70,7 @@ from mmrelay.db_utils import (
     save_shortname,
 )
 from mmrelay.log_utils import get_logger
+from mmrelay.runtime_utils import is_running_as_service
 
 # Global config variable that will be set from config.py
 config = None
@@ -122,28 +125,83 @@ def _submit_coro(coro, loop=None):
         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()
+        # No running loop: check if we can safely create a new loop
         try:
-            result = asyncio.run(coro)
-            f.set_result(result)
+            # Try to get the current event loop policy and create a new loop
+            # This is safer than asyncio.run() which can cause deadlocks
+            policy = asyncio.get_event_loop_policy()
+            logger.debug(
+                "No running event loop detected; creating a temporary loop to execute coroutine"
+            )
+            new_loop = policy.new_event_loop()
+            asyncio.set_event_loop(new_loop)
+            try:
+                result = new_loop.run_until_complete(coro)
+                f = Future()
+                f.set_result(result)
+                return f
+            finally:
+                new_loop.close()
+                asyncio.set_event_loop(None)
         except Exception as e:
+            # Ultimate fallback: create a completed Future with the exception
+            f = Future()
             f.set_exception(e)
-        return f
+            return f
+
+
+def _resolve_plugin_timeout(cfg: dict | None, default: float = 5.0) -> float:
+    """
+    Resolve and return a positive plugin timeout value from the given configuration.
+    
+    Attempts to read meshtastic.plugin_timeout from cfg and convert it to a positive float.
+    If the value is missing, non-numeric, or not greater than 0, the provided default is returned.
+    Invalid or non-positive values will cause a warning to be logged.
+    
+    Parameters:
+        cfg (dict | None): Configuration mapping that may contain a "meshtastic" section.
+        default (float): Fallback timeout (seconds) used when cfg does not provide a valid value.
+    
+    Returns:
+        float: A positive timeout in seconds.
+    """
+
+    raw_value = default
+    if isinstance(cfg, dict):
+        try:
+            raw_value = cfg.get("meshtastic", {}).get("plugin_timeout", default)
+        except AttributeError:
+            raw_value = default
+
+    try:
+        timeout = float(raw_value)
+        if timeout > 0:
+            return timeout
+        logger.warning(
+            "Non-positive meshtastic.plugin_timeout value %r; using %ss fallback.",
+            raw_value,
+            default,
+        )
+    except (TypeError, ValueError):
+        logger.warning(
+            "Invalid meshtastic.plugin_timeout value %r; using %ss fallback.",
+            raw_value,
+            default,
+        )
+
+    return default
 
 
 def _get_device_metadata(client):
     """
-    Retrieve device metadata from a Meshtastic client.
+    Retrieve firmware 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.
+    Calls client.localNode.getMetadata() (if present) and captures its stdout/stderr to extract a firmware version and raw output. Returns a dict with:
+    - firmware_version: parsed version string or "unknown" when not found,
+    - raw_output: captured output (truncated to 4096 characters with a trailing ellipsis if longer),
+    - success: True when a firmware_version was successfully parsed.
 
-    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
-        }
+    If the client lacks localNode.getMetadata or parsing fails, returns defaults without raising.
     """
     result = {"firmware_version": "unknown", "raw_output": "", "success": False}
 
@@ -175,7 +233,7 @@ def _get_device_metadata(client):
         # 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*['\"]?",
+            r"(?i)\bfirmware[\s_/-]*version\b\s*[:=]\s*['\"]?\s*([^\s\r\n'\"]+)",
             console_output,
         )
         if match:
@@ -192,35 +250,18 @@ def _get_device_metadata(client):
     return result
 
 
-def is_running_as_service():
-    """
-    Determine if the application is running as a systemd service.
-
-    Returns:
-        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.
+def serial_port_exists(port_name):
     """
-    # Check for INVOCATION_ID environment variable (set by systemd)
-    if os.environ.get("INVOCATION_ID"):
-        return True
+    Return True if a serial port with the given device name is present on the system.
 
-    # Check if parent process is systemd
-    try:
-        with open("/proc/self/status") as f:
-            for line in f:
-                if line.startswith("PPid:"):
-                    ppid = int(line.split()[1])
-                    with open(f"/proc/{ppid}/comm") as p:
-                        return p.read().strip() == SYSTEMD_INIT_SYSTEM
-    except (FileNotFoundError, PermissionError, ValueError):
-        pass
-
-    return False
+    Checks available serial ports via pyserial's list_ports and compares their `.device`
+    strings to the provided port_name.
 
+    Parameters:
+        port_name (str): Device name to check (e.g., '/dev/ttyUSB0' on Unix or 'COM3' on Windows).
 
-def serial_port_exists(port_name):
-    """
-    Check if the specified serial port exists.
-    This prevents attempting connections on non-existent ports.
+    Returns:
+        bool: True if the port is found, False otherwise.
     """
     ports = [p.device for p in serial.tools.list_ports.comports()]
     return port_name in ports
@@ -228,14 +269,14 @@ def serial_port_exists(port_name):
 
 def connect_meshtastic(passed_config=None, force_connect=False):
     """
-    Establish and return a Meshtastic client connection (serial, BLE, or TCP), with configurable retries and event subscription.
-
-    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.
-
+    Establish and return a Meshtastic client connection (serial, BLE, or TCP), with configurable retries, exponential backoff, and single-time event subscription.
+    
+    Attempts to (re)connect using the module configuration and updates module-level state on success (meshtastic_client, matrix_rooms, and event subscriptions). Supports the legacy "network" alias for TCP, verifies serial port presence before connecting, and honors a retry limit (or infinite retries when unspecified). On successful connection the client's node info and firmware metadata are probed and message/connection-lost handlers are subscribed once for the process lifetime.
+    
     Parameters:
-        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.
-
+        passed_config (dict, optional): If provided, replaces the module-level configuration (and may update matrix_rooms).
+        force_connect (bool, optional): When True, forces creating a new connection even if one already exists.
+    
     Returns:
         The connected Meshtastic client instance on success, or None if connection cannot be established or shutdown is in progress.
     """
@@ -302,77 +343,92 @@ def connect_meshtastic(passed_config=None, force_connect=False):
             logger.warning(
                 "Using 'network' connection type (legacy). 'tcp' is now the preferred name and 'network' will be deprecated in a future version."
             )
-        retry_limit = INFINITE_RETRIES  # 0 means infinite retries
-        attempts = DEFAULT_RETRY_ATTEMPTS
-        successful = False
-
-        while (
-            not successful
-            and (retry_limit == 0 or attempts <= retry_limit)
-            and not shutting_down
-        ):
-            try:
-                if connection_type == CONNECTION_TYPE_SERIAL:
-                    # Serial connection
-                    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}")
+    # Move retry loop outside the lock to prevent blocking other threads
+    meshtastic_settings = config.get("meshtastic", {}) if config else {}
+    retry_limit_raw = meshtastic_settings.get("retries")
+    if retry_limit_raw is None:
+        retry_limit_raw = meshtastic_settings.get("retry_limit", INFINITE_RETRIES)
+        if "retry_limit" in meshtastic_settings:
+            logger.warning(
+                "'retry_limit' is deprecated in meshtastic config; use 'retries' instead"
+            )
+    try:
+        retry_limit = int(retry_limit_raw)
+    except (TypeError, ValueError):
+        retry_limit = INFINITE_RETRIES
+    attempts = 0
+    timeout_attempts = 0
+    successful = False
+
+    while (
+        not successful
+        and (retry_limit == 0 or attempts <= retry_limit)
+        and not shutting_down
+    ):
+        try:
+            client = None
+            if connection_type == CONNECTION_TYPE_SERIAL:
+                # Serial connection
+                serial_port = config["meshtastic"].get(CONFIG_KEY_SERIAL_PORT)
+                if not serial_port:
+                    logger.error(
+                        "No serial port specified in Meshtastic configuration."
+                    )
+                    return None
 
-                    # Check if serial port exists before connecting
-                    if not serial_port_exists(serial_port):
-                        logger.warning(
-                            f"Serial port {serial_port} does not exist. Waiting..."
-                        )
-                        time.sleep(5)
-                        attempts += 1
-                        continue
+                logger.info(f"Connecting to serial port {serial_port}")
 
-                    meshtastic_client = meshtastic.serial_interface.SerialInterface(
-                        serial_port
+                # Check if serial port exists before connecting
+                if not serial_port_exists(serial_port):
+                    logger.warning(
+                        f"Serial port {serial_port} does not exist. Waiting..."
                     )
+                    time.sleep(5)
+                    attempts += 1
+                    continue
 
-                elif connection_type == CONNECTION_TYPE_BLE:
-                    # BLE connection
-                    ble_address = config["meshtastic"].get(CONFIG_KEY_BLE_ADDRESS)
-                    if ble_address:
-                        logger.info(f"Connecting to BLE address {ble_address}")
-
-                        # Connect without progress indicator
-                        meshtastic_client = meshtastic.ble_interface.BLEInterface(
-                            address=ble_address,
-                            noProto=False,
-                            debugOut=None,
-                            noNodes=False,
-                        )
-                    else:
-                        logger.error("No BLE address provided.")
-                        return None
-
-                elif connection_type == CONNECTION_TYPE_TCP:
-                    # TCP connection
-                    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
+                client = meshtastic.serial_interface.SerialInterface(serial_port)
 
-                    logger.info(f"Connecting to host {target_host}")
+            elif connection_type == CONNECTION_TYPE_BLE:
+                # BLE connection
+                ble_address = config["meshtastic"].get(CONFIG_KEY_BLE_ADDRESS)
+                if ble_address:
+                    logger.info(f"Connecting to BLE address {ble_address}")
 
                     # Connect without progress indicator
-                    meshtastic_client = meshtastic.tcp_interface.TCPInterface(
-                        hostname=target_host
+                    client = meshtastic.ble_interface.BLEInterface(
+                        address=ble_address,
+                        noProto=False,
+                        debugOut=None,
+                        noNodes=False,
                     )
                 else:
-                    logger.error(f"Unknown connection type: {connection_type}")
+                    logger.error("No BLE address provided.")
                     return None
 
-                successful = True
+            elif connection_type == CONNECTION_TYPE_TCP:
+                # TCP connection
+                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
+                client = meshtastic.tcp_interface.TCPInterface(hostname=target_host)
+            else:
+                logger.error(f"Unknown connection type: {connection_type}")
+                return None
+
+            successful = True
+
+            # Acquire lock only for the final setup and subscription
+            with meshtastic_lock:
+                meshtastic_client = client
                 nodeInfo = meshtastic_client.getMyNodeInfo()
 
                 # Safely access node info fields
@@ -408,43 +464,69 @@ def connect_meshtastic(passed_config=None, force_connect=False):
                     subscribed_to_connection_lost = True
                     logger.debug("Subscribed to meshtastic.connection.lost")
 
-            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(
-                        2**attempts, 60
-                    )  # Consistent exponential backoff, capped at 60s
-                    logger.warning(
-                        f"Connection attempt {attempts} failed: {e}. Retrying in {wait_time} seconds..."
-                    )
-                    time.sleep(wait_time)
-                else:
-                    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..."
+        except (ConnectionRefusedError, MemoryError) as e:
+            # Handle critical errors that should not be retried
+            logger.exception("Critical connection error")
+            return None
+        except (FuturesTimeoutError, TimeoutError) as e:
+            if shutting_down:
+                break
+            attempts += 1
+            if retry_limit == INFINITE_RETRIES:
+                timeout_attempts += 1
+                if timeout_attempts > MAX_TIMEOUT_RETRIES_INFINITE:
+                    logger.exception(
+                        "Connection timed out after %s attempts (unlimited retries); aborting",
+                        attempts,
                     )
-                    time.sleep(wait_time)
-                else:
-                    logger.error(f"Connection failed after {attempts} attempts: {e}")
                     return None
+            elif attempts > retry_limit:
+                logger.exception("Connection failed after %s attempts", attempts)
+                return None
+
+            wait_time = min(2**attempts, 60)
+            logger.warning(
+                "Connection attempt %s timed out (%s). Retrying in %s seconds...",
+                attempts,
+                e,
+                wait_time,
+            )
+            time.sleep(wait_time)
+        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(2**attempts, 60)  # Consistent exponential backoff
+                logger.warning(
+                    "Connection attempt %s failed: %s. Retrying in %s seconds...",
+                    attempts,
+                    e,
+                    wait_time,
+                )
+                time.sleep(wait_time)
+            else:
+                logger.exception("Connection failed after %s attempts", attempts)
+                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)
+                logger.warning(
+                    "An unexpected error occurred on attempt %s: %s. Retrying in %s seconds...",
+                    attempts,
+                    e,
+                    wait_time,
+                )
+                time.sleep(wait_time)
+            else:
+                logger.exception("Connection failed after %s attempts", attempts)
+                return None
 
     return meshtastic_client
 
@@ -513,26 +595,32 @@ async def reconnect():
 
                 # Show reconnection countdown with Rich (if not in a service)
                 if not is_running_as_service():
-                    from rich.progress import (
-                        BarColumn,
-                        Progress,
-                        TextColumn,
-                        TimeRemainingColumn,
-                    )
-
-                    with Progress(
-                        TextColumn("[cyan]Meshtastic: Reconnecting in"),
-                        BarColumn(),
-                        TextColumn("[cyan]{task.percentage:.0f}%"),
-                        TimeRemainingColumn(),
-                        transient=True,
-                    ) as progress:
-                        task = progress.add_task("Waiting", total=backoff_time)
-                        for _ in range(backoff_time):
-                            if shutting_down:
-                                break
-                            await asyncio.sleep(1)
-                            progress.update(task, advance=1)
+                    try:
+                        from rich.progress import (
+                            BarColumn,
+                            Progress,
+                            TextColumn,
+                            TimeRemainingColumn,
+                        )
+                    except ImportError:
+                        logger.debug(
+                            "Rich not available; falling back to simple reconnection delay"
+                        )
+                        await asyncio.sleep(backoff_time)
+                    else:
+                        with Progress(
+                            TextColumn("[cyan]Meshtastic: Reconnecting in"),
+                            BarColumn(),
+                            TextColumn("[cyan]{task.percentage:.0f}%"),
+                            TimeRemainingColumn(),
+                            transient=True,
+                        ) as progress:
+                            task = progress.add_task("Waiting", total=backoff_time)
+                            for _ in range(backoff_time):
+                                if shutting_down:
+                                    break
+                                await asyncio.sleep(1)
+                                progress.update(task, advance=1)
                 else:
                     await asyncio.sleep(backoff_time)
                 if shutting_down:
@@ -548,10 +636,10 @@ async def reconnect():
                 if meshtastic_client:
                     logger.info("Reconnected successfully.")
                     break
-            except Exception as e:
+            except Exception:
                 if shutting_down:
                     break
-                logger.error(f"Reconnection attempt failed: {e}")
+                logger.exception("Reconnection attempt failed")
                 backoff_time = min(backoff_time * 2, 300)  # Cap backoff at 5 minutes
     except asyncio.CancelledError:
         logger.info("Reconnection task was cancelled.")
@@ -597,11 +685,10 @@ def on_meshtastic_message(packet, interface):
         return
 
     # Import the configuration helpers
-    from mmrelay.matrix_utils import get_interaction_settings, message_storage_enabled
+    from mmrelay.matrix_utils import get_interaction_settings
 
     # Get interaction settings
     interactions = get_interaction_settings(config)
-    message_storage_enabled(interactions)
 
     # Filter packets based on interaction settings
     if packet.get("decoded", {}).get("portnum") == TEXT_MESSAGE_APP:
@@ -760,8 +847,11 @@ def on_meshtastic_message(packet, interface):
 
         # Check if channel is mapped to a Matrix room
         channel_mapped = False
-        for room in matrix_rooms:
-            if room["meshtastic_channel"] == channel:
+        iterable_rooms = (
+            matrix_rooms.values() if isinstance(matrix_rooms, dict) else matrix_rooms
+        )
+        for room in iterable_rooms:
+            if isinstance(room, dict) and room.get("meshtastic_channel") == channel:
                 channel_mapped = True
                 break
 
@@ -819,22 +909,41 @@ def on_meshtastic_message(packet, interface):
         from mmrelay.plugin_loader import load_plugins
 
         plugins = load_plugins()
+        plugin_timeout = _resolve_plugin_timeout(config, default=5.0)
 
         found_matching_plugin = False
         for plugin in plugins:
             if not found_matching_plugin:
                 try:
-                    result = _submit_coro(
+                    result_future = _submit_coro(
                         plugin.handle_meshtastic_message(
                             packet, formatted_message, longname, meshnet_name
                         ),
                         loop=loop,
                     )
-                    found_matching_plugin = result.result()
+                    if result_future is None:
+                        logger.warning(
+                            "Plugin %s returned no awaitable; skipping.",
+                            plugin.plugin_name,
+                        )
+                        found_matching_plugin = False
+                        continue
+                    try:
+                        found_matching_plugin = result_future.result(
+                            timeout=plugin_timeout
+                        )
+                    except FuturesTimeoutError as exc:
+                        logger.warning(
+                            "Plugin %s did not respond within %ss: %s",
+                            plugin.plugin_name,
+                            plugin_timeout,
+                            exc,
+                        )
+                        found_matching_plugin = False
                     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}")
+                except Exception:
+                    logger.exception(f"Plugin {plugin.plugin_name} failed")
                     # Continue processing other plugins
 
         # If message is a DM or handled by plugin, do not relay further
@@ -855,8 +964,13 @@ def on_meshtastic_message(packet, interface):
             logger.error("matrix_rooms is empty. Cannot relay message to Matrix.")
             return
 
-        for room in matrix_rooms:
-            if room["meshtastic_channel"] == channel:
+        iterable_rooms = (
+            matrix_rooms.values() if isinstance(matrix_rooms, dict) else matrix_rooms
+        )
+        for room in iterable_rooms:
+            if not isinstance(room, dict):
+                continue
+            if room.get("meshtastic_channel") == channel:
                 # Storing the message_map (if enabled) occurs inside matrix_relay() now,
                 # controlled by relay_reactions.
                 try:
@@ -873,19 +987,20 @@ def on_meshtastic_message(packet, interface):
                         ),
                         loop=loop,
                     )
-                except Exception as e:
-                    logger.error(f"Error relaying message to Matrix: {e}")
+                except Exception:
+                    logger.exception("Error relaying message to Matrix")
     else:
         # Non-text messages via plugins
         portnum = decoded.get("portnum")
         from mmrelay.plugin_loader import load_plugins
 
         plugins = load_plugins()
+        plugin_timeout = _resolve_plugin_timeout(config, default=5.0)
         found_matching_plugin = False
         for plugin in plugins:
             if not found_matching_plugin:
                 try:
-                    result = _submit_coro(
+                    result_future = _submit_coro(
                         plugin.handle_meshtastic_message(
                             packet,
                             formatted_message=None,
@@ -894,27 +1009,48 @@ def on_meshtastic_message(packet, interface):
                         ),
                         loop=loop,
                     )
-                    found_matching_plugin = result.result()
+                    if result_future is None:
+                        logger.warning(
+                            "Plugin %s returned no awaitable; skipping.",
+                            plugin.plugin_name,
+                        )
+                        found_matching_plugin = False
+                        continue
+                    try:
+                        found_matching_plugin = result_future.result(
+                            timeout=plugin_timeout
+                        )
+                    except FuturesTimeoutError as exc:
+                        logger.warning(
+                            "Plugin %s did not respond within %ss: %s",
+                            plugin.plugin_name,
+                            plugin_timeout,
+                            exc,
+                        )
+                        found_matching_plugin = False
                     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}")
+                except Exception:
+                    logger.exception(f"Plugin {plugin.plugin_name} failed")
                     # Continue processing other plugins
 
 
 async def check_connection():
     """
-    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.
+    Periodically verify the Meshtastic connection and initiate a reconnect when the device appears unresponsive.
+
+    Runs until the module-level shutting_down flag becomes True. Behavior:
+    - Controlled by config["meshtastic"]["health_check"]:
+      - "enabled" (bool, default True) — enable/disable periodic checks.
+      - "heartbeat_interval" (int, seconds, default 60) — interval between checks.
+      - Backward compatibility: if "heartbeat_interval" exists directly under config["meshtastic"], that value is used.
+    - BLE connections are excluded from periodic checks (Bleak provides real-time disconnect detection).
+    - For non-BLE connections:
+      - Calls _get_device_metadata(client) in an executor; if metadata parsing fails, performs a fallback probe via client.getMyNodeInfo().
+      - If both probes fail and no reconnection is currently in progress, calls on_lost_meshtastic_connection(...) to start a reconnection.
+    No return value; side effect is scheduling/triggering reconnection when the device is unresponsive.
     """
     global meshtastic_client, shutting_down, config
 
@@ -953,12 +1089,17 @@ async def check_connection():
                     ble_skip_logged = True
             else:
                 try:
-                    # Use helper function to get device metadata
-                    metadata = _get_device_metadata(meshtastic_client)
+                    loop = asyncio.get_running_loop()
+                    # Use helper function to get device metadata, run in executor
+                    metadata = await loop.run_in_executor(
+                        None, _get_device_metadata, meshtastic_client
+                    )
                     if not metadata["success"]:
                         # Fallback probe: device responding at all?
                         try:
-                            _ = meshtastic_client.getMyNodeInfo()
+                            _ = await loop.run_in_executor(
+                                None, meshtastic_client.getMyNodeInfo
+                            )
                         except Exception as probe_err:
                             raise Exception(
                                 "Metadata and nodeInfo probes failed"
@@ -1000,18 +1141,21 @@ def sendTextReply(
     channelIndex: int = 0,
 ):
     """
-    Sends a text message as a reply to a specific previous message via the Meshtastic interface.
-
+    Send a Meshtastic text reply that references a previous Meshtastic message.
+    
+    Builds a Data payload containing `text` and `reply_id`, wraps it in a MeshPacket on `channelIndex`,
+    and sends it using the provided Meshtastic interface.
+    
     Parameters:
-        interface: The Meshtastic interface to send through.
-        text (str): The message content to send.
-        reply_id (int): The ID of the message being replied to.
-        destinationId: The recipient address (defaults to broadcast).
-        wantAck (bool): Whether to request acknowledgment for the message.
-        channelIndex (int): The channel index to send the message on.
-
+        text (str): UTF-8 text to send.
+        reply_id (int): ID of the Meshtastic message being replied to.
+        destinationId (int | str, optional): Recipient address or node ID (defaults to broadcast).
+        wantAck (bool, optional): If True, request an acknowledgement for the packet.
+        channelIndex (int, optional): Channel index to send the packet on.
+    
     Returns:
-        The sent MeshPacket with its ID field populated, or None if sending fails or the interface is unavailable.
+        The result returned by the interface's _sendPacket call (typically the sent MeshPacket), or
+        None if the interface is not available or sending fails.
     """
     logger.debug(f"Sending text reply: '{text}' replying to message ID {reply_id}")
 
@@ -1037,8 +1181,8 @@ def sendTextReply(
         return interface._sendPacket(
             mesh_packet, destinationId=destinationId, wantAck=wantAck
         )
-    except Exception as e:
-        logger.error(f"Failed to send text reply: {e}")
+    except Exception:
+        logger.exception("Failed to send text reply")
         return None