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

mmrelay/__init__.py

@@ -2,4 +2,4 @@
 Meshtastic Matrix Relay - Bridge between Meshtastic mesh networks and Matrix chat rooms.
 """
 
-__version__ = "1.2.2"
+__version__ = "1.2.4"

mmrelay/cli.py

@@ -238,11 +238,11 @@ def print_version():
 def _validate_e2ee_dependencies():
     """
     Check whether end-to-end encryption (E2EE) is usable on the current platform.
-    
+
     Returns:
         bool: True if the platform is supported and required E2EE libraries can be imported;
         False otherwise.
-    
+
     Notes:
         - This function performs only local checks (platform and importability) and does not perform
           network I/O.
@@ -1499,13 +1499,13 @@ def handle_auth_logout(args):
 def handle_service_command(args):
     """
     Dispatch service-related subcommands.
-    
+
     Currently supports the "install" subcommand which imports and runs mmrelay.setup_utils.install_service().
     Returns 0 on successful installation, 1 on failure or for unknown subcommands.
-    
+
     Parameters:
         args: argparse.Namespace with a `service_command` attribute indicating the requested action.
-    
+
     Returns:
         int: Exit code (0 on success, 1 on error).
     """
@@ -1524,15 +1524,15 @@ def handle_service_command(args):
 
 def _diagnose_config_paths(args):
     """
-    Print a diagnostic summary of resolved configuration file search paths and their directory accessibility.
-    
-    Uses get_config_paths(args) to compute the ordered list of candidate config file locations, then prints each path with a concise directory status icon:
+    Prints a diagnostic summary of resolved configuration file search paths and their directory accessibility.
+
+    Each candidate config path is printed with a status icon:
     - ✅ directory exists and is writable
     - ⚠️ directory exists but is not writable
     - ❌ directory does not exist
-    
+
     Parameters:
-        args (argparse.Namespace): Parsed CLI arguments used to determine the config search order.
+        args (argparse.Namespace): CLI arguments used to determine the ordered list of candidate config paths (passed to get_config_paths).
     """
     print("1. Testing configuration paths...")
     from mmrelay.config import get_config_paths
@@ -1551,11 +1551,11 @@ def _diagnose_config_paths(args):
 def _diagnose_sample_config_accessibility():
     """
     Check availability of the bundled sample configuration and print a short diagnostic.
-    
+
     Performs two non-destructive checks and prints human-readable results:
     1) Verifies whether the sample config file exists at the path returned by mmrelay.tools.get_sample_config_path().
     2) Attempts to read the embedded resource "sample_config.yaml" from the mmrelay.tools package via importlib.resources and reports success and the content length.
-    
+
     Returns:
         bool: True if a filesystem sample config exists at the resolved path; False otherwise.
     """
@@ -1586,18 +1586,15 @@ def _diagnose_sample_config_accessibility():
 
 def _diagnose_platform_specific(args):
     """
-    Run platform-specific diagnostic checks.
-    
-    On Windows, imports and runs Windows-specific requirement checks and a configuration-generation
-    test from mmrelay.windows_utils, printing per-component results and any warnings. On non-Windows
-    platforms this reports that platform-specific tests are not required.
-    
+    Run platform-specific diagnostic checks and print a concise report.
+
+    On Windows, executes Windows-specific requirement checks and a configuration-generation test using the provided CLI arguments; on non-Windows platforms, reports that platform-specific tests are not required.
+
     Parameters:
-        args (argparse.Namespace): Parsed CLI arguments; passed through to the Windows
-            config-generation test when running on Windows.
-    
+        args (argparse.Namespace): CLI arguments forwarded to the Windows configuration-generation test (used only when running on Windows).
+
     Returns:
-        bool: True if the platform is Windows (Windows checks were executed), False otherwise.
+        bool: `True` if Windows checks were executed (running on Windows), `False` otherwise.
     """
     print("3. Platform-specific diagnostics...")
     import sys
@@ -1704,7 +1701,7 @@ logging:
 def _diagnose_minimal_config_template():
     """
     Validate the built-in minimal YAML configuration template and print a concise pass/fail status.
-    
+
     Attempts to parse the string returned by _get_minimal_config_template() using yaml.safe_load. Prints a single-line result showing a ✅ with the template character length when the template is valid YAML, or a ❌ with the YAML parsing error when invalid. This is a non-destructive diagnostic helper that prints output and does not return a value.
     """
     print("4. Testing minimal config template fallback...")
@@ -1720,15 +1717,15 @@ def _diagnose_minimal_config_template():
 
 def handle_config_diagnose(args):
     """
-    Run non-destructive diagnostics for the MMRelay configuration subsystem and print a human-readable report.
-    
-    Performs four checks: resolves candidate config paths and reports directory accessibility; verifies packaged sample config availability (filesystem and importlib.resources fallback); runs platform-specific diagnostics (Windows-focused where applicable); and validates the built-in minimal YAML template. Prints findings and suggested next steps to stdout/stderr.
-    
+    Run a set of non-destructive diagnostics for the MMRelay configuration subsystem and print a concise, human-readable report.
+
+    Performs four checks without modifying user files: (1) resolves and reports candidate configuration file paths and their directory accessibility, (2) verifies availability and readability of the packaged sample configuration, (3) executes platform-specific diagnostics (Windows checks when applicable), and (4) validates the built-in minimal YAML configuration template. Results and actionable guidance are written to stdout/stderr; additional Windows-specific guidance may be printed to stderr on unexpected failures.
+
     Parameters:
-        args (argparse.Namespace): Parsed CLI arguments used to resolve config search paths and to control platform-specific checks.
-    
+        args (argparse.Namespace): Parsed CLI arguments used to determine configuration search paths and to control platform-specific diagnostic behavior.
+
     Returns:
-        int: Exit code (0 on success, 1 on failure).
+        int: Exit code where `0` indicates diagnostics completed successfully and `1` indicates a failure occurred (an error summary is printed to stderr).
     """
     print("MMRelay Configuration System Diagnostics")
     print("=" * 40)

mmrelay/config.py

@@ -196,14 +196,12 @@ def get_log_dir():
 
 def get_e2ee_store_dir():
     """
-    Return the absolute path to the E2EE data store directory, creating it if missing.
-    
-    On Linux and macOS this is "<base_dir>/store" where base_dir is returned by get_base_dir().
-    On Windows this is "<custom_data_dir>/store" when module-level custom_data_dir is set; otherwise it uses
-    platformdirs.user_data_dir(APP_NAME, APP_AUTHOR)/store.
-    
+    Get the absolute path to the application's end-to-end encryption (E2EE) data store directory, creating it if necessary.
+
+    On Linux and macOS the directory is located under the application base directory; on Windows it uses the configured custom data directory when set, otherwise the platform-specific user data directory. The directory will be created if it does not exist.
+
     Returns:
-        str: Absolute path to the ensured store directory. The directory is created if it does not exist.
+        store_dir (str): Absolute path to the ensured E2EE store directory.
     """
     if sys.platform in ["linux", "darwin"]:
         # Use ~/.mmrelay/store/ for Linux and Mac
@@ -388,12 +386,12 @@ def is_e2ee_enabled(config):
 def check_e2ee_enabled_silently(args=None):
     """
     Check silently whether End-to-End Encryption (E2EE) is enabled in the first readable configuration file.
-    
+
     Searches candidate configuration paths returned by get_config_paths(args) in priority order, loads the first readable YAML file, and returns True if that configuration enables E2EE (via is_e2ee_enabled). I/O and YAML parsing errors are ignored and the function continues to the next candidate. On Windows this always returns False.
-    
+
     Parameters:
         args (optional): Parsed command-line arguments that can influence config search order.
-    
+
     Returns:
         bool: True if E2EE is enabled in the first valid configuration file found; otherwise False.
     """
@@ -493,16 +491,16 @@ def load_credentials():
 def save_credentials(credentials):
     """
     Persist a JSON-serializable credentials mapping to <base_dir>/credentials.json.
-    
+
     Writes the provided credentials (a JSON-serializable mapping) to the application's
     base configuration directory as credentials.json, creating the base directory if
     necessary. On Unix-like systems the file permissions are adjusted to be
     restrictive (0o600) when possible. I/O and permission errors are caught and
     logged; the function does not raise them.
-    
+
     Parameters:
         credentials (dict): JSON-serializable mapping of credentials to persist.
-    
+
     Returns:
         None
     """
@@ -822,18 +820,18 @@ def load_config(config_file=None, args=None):
 def validate_yaml_syntax(config_content, config_path):
     """
     Validate YAML text for syntax and common style issues, parse it with PyYAML, and return results.
-    
+
     Performs lightweight line-based checks for frequent mistakes (using '=' instead of ':'
     for mappings and non-standard boolean words like 'yes'/'no' or 'on'/'off') and then
     attempts to parse the content with yaml.safe_load. If only style warnings are found,
     parsing is considered successful and warnings are returned; if parsing fails or true
     syntax errors are detected, a detailed error message is returned that references
     config_path to identify the source.
-    
+
     Parameters:
         config_content (str): Raw YAML text to validate.
         config_path (str): Path or label used in error messages to identify the source of the content.
-    
+
     Returns:
         tuple:
             is_valid (bool): True if YAML parsed successfully (style warnings allowed), False on syntax/parsing error.

mmrelay/constants/queue.py

@@ -6,7 +6,10 @@ delays, size limits, and water marks for queue management.
 """
 
 # Message timing constants
-DEFAULT_MESSAGE_DELAY = 2.0  # Firmware-enforced minimum delay in seconds
+DEFAULT_MESSAGE_DELAY = (
+    2.5  # Set above the 2.0s firmware limit to prevent message dropping
+)
+MINIMUM_MESSAGE_DELAY = 2.1  # Minimum delay enforced to stay above firmware limit
 
 # Queue size management
 MAX_QUEUE_SIZE = 500

mmrelay/e2ee_utils.py

@@ -80,8 +80,13 @@ def get_e2ee_status(
         importlib.import_module("olm")
 
         if os.getenv("MMRELAY_TESTING") != "1":
-            importlib.import_module("nio.crypto").OlmDevice
-            importlib.import_module("nio.store").SqliteStore
+            nio_crypto = importlib.import_module("nio.crypto")
+            if not hasattr(nio_crypto, "OlmDevice"):
+                raise ImportError("nio.crypto.OlmDevice is unavailable")
+
+            nio_store = importlib.import_module("nio.store")
+            if not hasattr(nio_store, "SqliteStore"):
+                raise ImportError("nio.store.SqliteStore is unavailable")
 
         status["dependencies_installed"] = True
     except ImportError:

mmrelay/log_utils.py

@@ -69,14 +69,13 @@ _COMPONENT_LOGGERS = {
 
 def configure_component_debug_logging():
     """
-    Configure log levels for external component loggers based on config["logging"]["debug"].
+    Configure log levels and handlers for external component loggers based on config.
 
-    Reads per-component entries under `config["logging"]["debug"]` and applies one of:
-    - falsy or missing: silence the component by setting its loggers to CRITICAL+1
-    - boolean True: enable DEBUG for the component's loggers
-    - string: interpret as a logging level name (case-insensitive); invalid names fall back to DEBUG
+    Reads `config["logging"]["debug"]` and for each component:
+    - If enabled (True or a valid log level string), sets the component's loggers to the specified level and attaches the main application's handlers to them. This makes component logs appear in the console and log file.
+    - If disabled (falsy or missing), silences the component by setting its loggers to a level higher than CRITICAL.
 
-    This function mutates the levels of loggers listed in _COMPONENT_LOGGERS and runs only once per process; no-op if called again or if global `config` is None.
+    This function runs only once. It is not thread-safe and should be called early in the application startup, after the main logger is configured but before other modules are imported.
     """
     global _component_debug_configured, config
 
@@ -84,7 +83,22 @@ def configure_component_debug_logging():
     if _component_debug_configured or config is None:
         return
 
-    debug_config = config.get("logging", {}).get("debug", {})
+    # Get the main application logger and its handlers to attach to component loggers
+    main_logger = logging.getLogger(APP_DISPLAY_NAME)
+    main_handlers = main_logger.handlers
+    debug_settings = config.get("logging", {}).get("debug")
+
+    # Ensure debug_config is a dictionary, handling malformed configs gracefully
+    if isinstance(debug_settings, dict):
+        debug_config = debug_settings
+    else:
+        if debug_settings is not None:
+            main_logger.warning(
+                "Debug logging section is not a dictionary. "
+                "All component debug logging will be disabled. "
+                "Check your config.yaml debug section formatting."
+            )
+        debug_config = {}
 
     for component, loggers in _COMPONENT_LOGGERS.items():
         component_config = debug_config.get(component)
@@ -105,8 +119,15 @@ def configure_component_debug_logging():
                 # Invalid config, fall back to DEBUG
                 log_level = logging.DEBUG
 
+            # Configure all loggers for this component
             for logger_name in loggers:
-                logging.getLogger(logger_name).setLevel(log_level)
+                component_logger = logging.getLogger(logger_name)
+                component_logger.setLevel(log_level)
+                component_logger.propagate = False  # Prevent duplicate logging
+                # Attach main handlers to the component logger
+                for handler in main_handlers:
+                    if handler not in component_logger.handlers:
+                        component_logger.addHandler(handler)
         else:
             # Component debug is disabled - completely suppress external library logging
             # Use a level higher than CRITICAL to effectively disable all messages

mmrelay/main.py

@@ -73,9 +73,18 @@ def print_banner():
 
 async def main(config):
     """
-    Coordinates the main asynchronous relay loop between Meshtastic and Matrix clients.
+    Coordinate the asynchronous relay loop between Meshtastic and Matrix clients.
 
-    Initializes the database, loads plugins, starts the message queue, and establishes connections to both Meshtastic and Matrix. Joins configured Matrix rooms, registers event callbacks for message and membership events, and periodically updates node names from the Meshtastic network. Monitors connection health, manages the Matrix sync loop with reconnection and shutdown handling, and ensures graceful shutdown of all components. Optionally wipes the message map on startup and shutdown if configured.
+    Initializes the database and plugins, starts the message queue, connects to Meshtastic and Matrix, joins configured Matrix rooms, registers event callbacks, monitors connection health, runs the Matrix sync loop with automatic retries, and ensures an orderly shutdown of all components (including optional message map wiping on startup and shutdown).
+
+    Parameters:
+        config (dict): Application configuration mapping. Expected keys used by this function include:
+            - "matrix_rooms": list of room dicts with at least an "id" entry,
+            - "meshtastic": optional dict with "message_delay",
+            - "database" (preferred) or legacy "db": optional dict containing "msg_map" with "wipe_on_restart" boolean.
+
+    Raises:
+        ConnectionError: If connecting to Matrix fails and no Matrix client can be obtained.
     """
     # Extract Matrix configuration
     from typing import List
@@ -154,9 +163,9 @@ async def main(config):
 
     async def shutdown():
         """
-        Signal the application to shut down.
-        
-        Sets the Meshtastic shutdown flag and triggers the local shutdown event so tasks waiting on that event can begin shutdown/cleanup. This coroutine only signals shutdown; it does not close clients or perform cleanup itself.
+        Signal the application to begin shutdown.
+
+        Set the Meshtastic shutdown flag and set the local shutdown event so any coroutines waiting on that event can start cleanup.
         """
         matrix_logger.info("Shutdown signal received. Closing down...")
         meshtastic_utils.shutting_down = True  # Set the shutting_down flag

mmrelay/matrix_utils.py

@@ -13,7 +13,6 @@ import time
 from typing import Any, Dict, Optional, Union
 from urllib.parse import urlparse
 
-import meshtastic.protobuf.portnums_pb2
 from nio import (
     AsyncClient,
     AsyncClientConfig,
@@ -113,15 +112,15 @@ def _is_room_alias(value: Any) -> bool:
 def _iter_room_alias_entries(mapping):
     """
     Yield (alias_or_id, setter) pairs for entries in a Matrix room mapping.
-    
+
     Each yielded tuple contains:
     - alias_or_id (str): the room alias or room ID found in the entry (may be an alias starting with '#' or a canonical room ID). If a dict entry has no `"id"` key, an empty string is yielded.
     - setter (callable): a function accepting a single argument `new_id` which updates the underlying mapping in-place to replace the alias with the resolved room ID.
-    
+
     Supports two mapping shapes:
     - list: items may be strings (alias/ID) or dicts with an `"id"` key.
     - dict: values may be strings (alias/ID) or dicts with an `"id"` key.
-    
+
     The setter updates the original collection (list element or dict value) so callers can resolve aliases and persist resolved IDs back into the provided mapping.
     """
 
@@ -150,13 +149,13 @@ def _iter_room_alias_entries(mapping):
 async def _resolve_aliases_in_mapping(mapping, resolver):
     """
     Resolve Matrix room alias entries found in a mapping (list or dict) by calling an async resolver and replacing aliases with resolved room IDs in-place.
-    
+
     This function iterates entries produced by _iter_room_alias_entries(mapping). For each entry whose key/value looks like a Matrix room alias (a string starting with '#'), it awaits the provided resolver coroutine with the alias; if the resolver returns a truthy room ID, the corresponding entry in the original mapping is updated via the entry's setter. If mapping is not a list or dict, the function logs a warning and returns without modifying anything.
-    
+
     Parameters:
         mapping (list|dict): A mapping of Matrix rooms where some entries may be aliases (e.g., "#room:example.org").
         resolver (Callable[[str], Awaitable[Optional[str]]]): Async callable that accepts an alias and returns a resolved room ID (or falsy on failure).
-    
+
     Returns:
         None
     """
@@ -178,12 +177,12 @@ async def _resolve_aliases_in_mapping(mapping, resolver):
 def _update_room_id_in_mapping(mapping, alias, resolved_id) -> bool:
     """
     Replace a room alias with its resolved room ID in a mapping.
-    
+
     Parameters:
         mapping (list|dict): A matrix_rooms mapping represented as a list of aliases or a dict of entries; only list and dict types are supported.
         alias (str): The room alias to replace (e.g., "#room:server").
         resolved_id (str): The canonical room ID to substitute for the alias (e.g., "!abcdef:server").
-    
+
     Returns:
         bool: True if the alias was found and replaced with resolved_id; False if the mapping type is unsupported or the alias was not present.
     """
@@ -789,29 +788,18 @@ def bot_command(command, event):
 
 async def connect_matrix(passed_config=None):
     """
-    Create and initialize a matrix-nio AsyncClient connected to the configured Matrix homeserver, optionally enabling End-to-End Encryption (E2EE).
-
-    This routine selects credentials in the following order:
-    1. credentials.json (preferred; restores full session including device_id and E2EE store).
-    2. Automatic login using username/password from the provided config (saved to credentials.json on success).
-    3. Direct token-based values from the config matrix section.
+    Initialize and return a configured matrix-nio AsyncClient connected to the configured Matrix homeserver.
 
-    Behavior summary:
-    - Validates presence of a top-level "matrix_rooms" configuration and raises ValueError if missing.
-    - Builds an AsyncClient with a certifi-backed SSL context when available.
-    - When E2EE is enabled in configuration and dependencies are present, prepares the encryption store, restores session state, and uploads device keys if needed.
-    - Performs an initial full_state sync and resolves room aliases configured as aliases to room IDs.
-    - Populates module-level globals used elsewhere (e.g., matrix_client, bot_user_name, matrix_homeserver, matrix_rooms, matrix_access_token, bot_user_id).
-    - Returns the initialized AsyncClient instance ready for use.
+    Creates or restores client credentials (prefers credentials.json, falls back to automatic login using username/password from config, then to direct tokens in config), optionally enables End-to-End Encryption when configured and dependencies are available, performs an initial full-state sync to populate rooms, resolves room aliases found in configuration, and sets module-level connection state used by other functions.
 
     Parameters:
-        passed_config (dict | None): Optional configuration to use for this connection attempt. If provided, it replaces the module-level config for this call.
+        passed_config (dict | None): Optional configuration to use for this connection attempt; when provided it overrides the module-level config for this call.
 
     Returns:
-        AsyncClient | None: An initialized matrix-nio AsyncClient on success, or None if connection cannot be established due to missing configuration/credentials.
+        AsyncClient | None: A ready-to-use matrix-nio AsyncClient on success, or `None` if connection or credentials are unavailable.
 
     Raises:
-        ValueError: If the top-level "matrix_rooms" configuration is missing from the (effective) config.
+        ValueError: If the required top-level "matrix_rooms" configuration is missing.
         ConnectionError: If the initial Matrix sync fails or times out.
     """
     global matrix_client, bot_user_name, matrix_homeserver, matrix_rooms, matrix_access_token, bot_user_id, config
@@ -1010,8 +998,15 @@ async def connect_matrix(passed_config=None):
                     # Also check for other required E2EE dependencies unless tests skip them
                     if os.getenv("MMRELAY_TESTING") != "1":
                         try:
-                            from nio.crypto import OlmDevice as _OlmDevice
-                            from nio.store import SqliteStore as _SqliteStore
+                            nio_crypto = importlib.import_module("nio.crypto")
+                            if not hasattr(nio_crypto, "OlmDevice"):
+                                raise ImportError("nio.crypto.OlmDevice is unavailable")
+
+                            nio_store = importlib.import_module("nio.store")
+                            if not hasattr(nio_store, "SqliteStore"):
+                                raise ImportError(
+                                    "nio.store.SqliteStore is unavailable"
+                                )
 
                             logger.debug("All E2EE dependencies are available")
                         except ImportError:
@@ -1034,6 +1029,10 @@ async def connect_matrix(passed_config=None):
                             "Skipping additional E2EE dependency imports in test mode"
                         )
 
+                    if e2ee_enabled:
+                        # Ensure nio still receives a store path even when dependency
+                        # checks are skipped (e.g. production runs without MMRELAY_TESTING);
+                        # without this the client will not load encryption state.
                         # Get store path from config or use default
                         if (
                             "encryption" in config["matrix"]
@@ -1050,8 +1049,6 @@ async def connect_matrix(passed_config=None):
                                 config["matrix"]["e2ee"]["store_path"]
                             )
                         else:
-                            from mmrelay.config import get_e2ee_store_dir
-
                             e2ee_store_path = get_e2ee_store_dir()
 
                         # Create store directory if it doesn't exist
@@ -1215,7 +1212,7 @@ async def connect_matrix(passed_config=None):
             async def _resolve_alias(alias: str) -> Optional[str]:
                 """
                 Resolve a Matrix room alias to its canonical room ID.
-                
+
                 Attempts to resolve the provided room alias using the module's Matrix client. Returns the resolved room ID string on success; returns None if the alias cannot be resolved or if an error/timeout occurs (errors from the underlying nio client are caught and handled internally).
                 """
                 logger.debug(f"Resolving alias from config: {alias}")
@@ -1778,17 +1775,17 @@ async def login_matrix_bot(
 async def join_matrix_room(matrix_client, room_id_or_alias: str) -> None:
     """
     Join the bot to a Matrix room by ID or alias.
-    
+
     Resolves a room alias (e.g. "#room:server") to its canonical room ID, updates the in-memory
     matrix_rooms mapping with the resolved ID (if available), and attempts to join the resolved
     room ID. No-op if the client is already joined to the room. Errors during alias resolution
     or join are caught and logged; the function does not raise exceptions.
-    
+
     Parameters documented only where meaning is not obvious:
         room_id_or_alias (str): A Matrix room identifier, either a canonical room ID (e.g. "!abc:server")
             or a room alias (starts with '#'). When an alias is provided, it will be resolved and
             the resolved room ID will be used for joining and recorded in the module's matrix_rooms mapping.
-    
+
     Returns:
         None
     """
@@ -2221,12 +2218,12 @@ def strip_quoted_lines(text: str) -> str:
 async def get_user_display_name(room, event):
     """
     Return the display name for the event sender, preferring a room-specific name.
-    
+
     If the room provides a per-room display name for the sender, that name is returned.
     Otherwise the function performs an asynchronous lookup against the homeserver for the
     user's global display name and returns it if present. If no display name is available,
     the sender's Matrix ID (MXID) is returned.
-    
+
     Returns:
         str: A human-readable display name or the sender's MXID.
     """
@@ -2320,15 +2317,20 @@ async def send_reply_to_meshtastic(
     reply_id=None,
 ):
     """
-    Enqueue a Matrix reply for transmission over Meshtastic, either as a structured reply or a regular broadcast.
-    
-    If Meshtastic broadcasting is disabled the function returns without action. When storage_enabled is True the function will create a mapping entry (using event.event_id and room.room_id) and attach it to the queued message when possible. If reply_id is provided the message is sent as a structured reply targeting that Meshtastic message ID; otherwise it is sent as a regular text broadcast. Failures are logged; the function does not raise on enqueue errors.
-    Parameters that add non-obvious context:
-        room_config (dict): Room-specific configuration — must include "meshtastic_channel" (an integer channel index).
-        room: Matrix room object (room.room_id is used for mapping metadata).
-        event: Matrix event object (event.event_id is used for mapping metadata).
-        storage_enabled (bool): When True, attempt to create and attach a message-mapping record to the queued item.
-        reply_id (int | None): If provided, send as a structured reply targeting this Meshtastic message ID.
+    Enqueue a Matrix reply to be delivered over Meshtastic as either a structured reply or a regular broadcast.
+
+    If broadcasting is disabled this function does nothing. When storage_enabled is True, it constructs a mapping record that links the originating Matrix event to the Meshtastic message and attaches it to the queued message so replies and reactions can be correlated later. Errors are logged; the function does not raise.
+
+    Parameters:
+        reply_message (str): Text payload already formatted for Meshtastic.
+        full_display_name (str): Sender display name used in queue descriptions and logs.
+        room_config (dict): Room-specific configuration; must contain "meshtastic_channel" (integer channel index).
+        room: Matrix room object; its room_id is used for mapping metadata.
+        event: Matrix event object; its event_id is used for mapping metadata.
+        text (str): Original Matrix message text used when building mapping metadata.
+        storage_enabled (bool): If True, create and attach a message-mapping record to the queued Meshtastic message.
+        local_meshnet_name (str | None): Local meshnet name included in mapping metadata when present.
+        reply_id (int | None): If provided, send as a structured Meshtastic reply targeting this Meshtastic message ID; otherwise send a regular broadcast.
     """
     loop = asyncio.get_running_loop()
     meshtastic_interface = await loop.run_in_executor(None, connect_meshtastic)
@@ -2433,22 +2435,26 @@ async def handle_matrix_reply(
     meshnet_name=None,
 ):
     """
-    Relay a Matrix reply back to Meshtastic when the replied-to Matrix event maps to a Meshtastic message.
-    
-    If the replied-to Matrix event has a stored Meshtastic mapping, format a Meshtastic reply preserving sender attribution and queue it as a reply that references the original Meshtastic message ID. If no mapping exists, do nothing and return False so normal Matrix processing can continue.
-    
+    Forward a Matrix reply to Meshtastic when the replied-to Matrix event maps to a Meshtastic message.
+
+    If the Matrix event identified by reply_to_event_id has an associated Meshtastic mapping, format a Meshtastic reply that preserves sender attribution and enqueue it referencing the original Meshtastic message ID. If no mapping exists, do nothing.
+
     Parameters:
-        reply_to_event_id (str): Matrix event ID being replied to; used to locate the corresponding Meshtastic mapping.
-        storage_enabled (bool): If True, message mappings may be created/updated when sending the reply.
-        local_meshnet_name (str): Local meshnet name used to determine cross-meshnet reply formatting.
-        config (dict): Relay configuration passed to formatting routines.
-        mesh_text_override (str | None): Optional override text to send to Meshtastic instead of derived text.
-        longname (str | None): Sender long display name used for prefixing in the Meshtastic message.
-        shortname (str | None): Sender short display name used for prefixing in the Meshtastic message.
-        meshnet_name (str | None): Remote meshnet name of the original Matrix/meshtastic mapping (if any).
-    
+        room: Matrix room object where the reply originated.
+        event: Matrix event object representing the reply.
+        reply_to_event_id (str): Matrix event ID being replied to; used to locate the Meshtastic mapping.
+        text (str): The reply text from Matrix.
+        room_config (dict): Per-room relay configuration used when sending to Meshtastic.
+        storage_enabled (bool): Whether message mapping/storage is enabled.
+        local_meshnet_name (str): Local meshnet name used to determine cross-meshnet formatting.
+        config (dict): Global relay configuration passed to formatting routines.
+        mesh_text_override (str | None): Optional override text to send instead of the derived text.
+        longname (str | None): Sender long display name used for prefixing.
+        shortname (str | None): Sender short display name used for prefixing.
+        meshnet_name (str | None): Remote meshnet name associated with the original mapping, if any.
+
     Returns:
-        bool: True if a mapping was found and the reply was queued to Meshtastic; False if no mapping existed and nothing was sent.
+        bool: `True` if a mapping was found and the reply was queued to Meshtastic, `False` otherwise.
     """
     # Look up the original message in the message map
     loop = asyncio.get_running_loop()
@@ -2545,23 +2551,14 @@ async def on_room_message(
     ],
 ) -> None:
     """
-    Handle an incoming Matrix room event and, when applicable, relay it to Meshtastic.
-    
-    Processes text, notice, emote, and reaction events (including replies and messages relayed from other meshnets) for configured rooms. Behavior highlights:
-    - Ignores events from before the bot started and events sent by the bot itself.
-    - Uses per-room configuration and global interaction settings to decide whether to process or ignore the event.
-    - Routes reactions back to the originating Meshtastic message when a mapping exists (supports local and remote-meshnet reaction handling).
-    - Bridges Matrix replies to Meshtastic replies when a corresponding Meshtastic mapping is found and replies are enabled.
-    - Relays regular Matrix messages to Meshtastic using configured prefix/truncation rules; handles special detection-sensor port forwarding.
-    - Integrates with the plugin system; plugins may consume or modify messages. Messages identified as bot commands are not relayed to Meshtastic.
-    
+    Handle an incoming Matrix room event and relay it to Meshtastic when applicable.
+
+    Processes text, notice, emote, and reaction events for configured rooms: ignores events from before the bot started and events sent by the bot itself; respects per-room configuration and global interaction settings; routes reactions back to the originating Meshtastic message when a mapping exists (including forwarding remote-meshnet emote reactions as radio text); bridges Matrix replies to Meshtastic replies when a corresponding mapping is found and replies are enabled; relays regular Matrix messages to Meshtastic using configured prefix and truncation rules; and honours detection-sensor forwarding when enabled. Integrates with the plugin system and treats recognized bot commands as non-relayed.
+
     Side effects:
     - May enqueue Meshtastic send operations (text or data) via the internal queue.
-    - May read/write persistent message mappings to support reaction/reply bridging.
-    - May call Matrix APIs (e.g., to fetch display names).
-    
-    Returns:
-    - None
+    - May read and write persistent message mappings to support reply/reaction bridging.
+    - May call Matrix APIs (e.g., to fetch display names) and connect to Meshtastic.
     """
     # DEBUG: Log all Matrix message events to trace reception
     logger.debug(
@@ -2971,6 +2968,9 @@ async def on_room_message(
                 if get_meshtastic_config_value(
                     config, "detection_sensor", DEFAULT_DETECTION_SENSOR
                 ):
+                    # Import meshtastic protobuf only when needed to delay logger creation
+                    import meshtastic.protobuf.portnums_pb2
+
                     success = queue_message(
                         meshtastic_interface.sendData,
                         data=full_message.encode("utf-8"),

mmrelay/meshtastic_utils.py

@@ -44,8 +44,17 @@ from mmrelay.constants.network import (
     CONNECTION_TYPE_TCP,
     DEFAULT_BACKOFF_TIME,
     ERRNO_BAD_FILE_DESCRIPTOR,
-INFINITE_RETRIES,
+    INFINITE_RETRIES,
 )
+from mmrelay.db_utils import (
+    get_longname,
+    get_message_map_by_meshtastic_id,
+    get_shortname,
+    save_longname,
+    save_shortname,
+)
+from mmrelay.log_utils import get_logger
+from mmrelay.runtime_utils import is_running_as_service
 
 # Maximum number of timeout retries when retries are configured as infinite.
 MAX_TIMEOUT_RETRIES_INFINITE = 5
@@ -62,16 +71,6 @@ except ImportError:
         pass
 
 
-from mmrelay.db_utils import (
-    get_longname,
-    get_message_map_by_meshtastic_id,
-    get_shortname,
-    save_longname,
-    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
 
@@ -153,15 +152,15 @@ def _submit_coro(coro, loop=None):
 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.
     """
@@ -270,13 +269,13 @@ 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, 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): 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.
     """
@@ -464,7 +463,7 @@ def connect_meshtastic(passed_config=None, force_connect=False):
                     subscribed_to_connection_lost = True
                     logger.debug("Subscribed to meshtastic.connection.lost")
 
-        except (ConnectionRefusedError, MemoryError) as e:
+        except (ConnectionRefusedError, MemoryError):
             # Handle critical errors that should not be retried
             logger.exception("Critical connection error")
             return None
@@ -1142,17 +1141,17 @@ def sendTextReply(
 ):
     """
     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:
         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 result returned by the interface's _sendPacket call (typically the sent MeshPacket), or
         None if the interface is not available or sending fails.

mmrelay/message_queue.py

@@ -473,11 +473,12 @@ class MessageQueue:
 
     def _should_send_message(self) -> bool:
         """
-        Return True if it is currently safe to send a message via Meshtastic.
-        
-        Performs runtime checks: ensures the global reconnecting flag is not set, a Meshtastic client object is available, and — if the client exposes `is_connected` (callable or boolean) — that it reports connected. Returns False if any check fails.
-        
-        If importing the Meshtastic utilities raises ImportError, the method will asynchronously stop this MessageQueue and return False.
+        Check whether the queue may send a Meshtastic message.
+
+        Performs runtime checks: returns True only if the reconnection flag is not set, a Meshtastic client object exists, and—if the client exposes `is_connected`—that check indicates the client is connected. If importing Meshtastic utilities raises ImportError, a critical log is emitted and the queue is stopped asynchronously.
+
+        Returns:
+            `True` if not reconnecting, a Meshtastic client exists, and the client is connected when checkable; `False` otherwise.
         """
         # Import here to avoid circular imports
         try:
@@ -517,18 +518,18 @@ class MessageQueue:
 
     def _handle_message_mapping(self, result, mapping_info):
         """
-        Persist a sent message mapping (mesh message id → Matrix event) and optionally prune old mappings.
-        
-        If mapping_info contains 'matrix_event_id', 'room_id', and 'text', stores a mapping using result.id as the mesh message id. If 'msgs_to_keep' is present and > 0 it prunes older mappings to retain that many entries; otherwise DEFAULT_MSGS_TO_KEEP is used.
-        
+        Persist a mapping from a sent Meshtastic message to a Matrix event and optionally prune old mappings.
+
+        Stores a mapping when `mapping_info` contains `matrix_event_id`, `room_id`, and `text`, using `result.id` as the Meshtastic message id. If `mapping_info["msgs_to_keep"]` is present and greater than 0, prunes older mappings to retain that many entries; otherwise uses DEFAULT_MSGS_TO_KEEP.
+
         Parameters:
-            result: Send function result object with an `id` attribute (the mesh message id).
+            result: An object returned by the send function with an `id` attribute representing the Meshtastic message id.
             mapping_info (dict): Mapping details. Relevant keys:
-                - matrix_event_id (str)
-                - room_id (str)
-                - text (str)
-                - meshnet (optional): passed to the store operation
-                - msgs_to_keep (optional, int): number of mappings to retain for pruning
+                - matrix_event_id (str): Matrix event ID to map to.
+                - room_id (str): Matrix room ID where the event was sent.
+                - text (str): Message text to associate with the mapping.
+                - meshnet (optional): Mesh network identifier to pass to storage.
+                - msgs_to_keep (optional, int): Number of mappings to retain when pruning.
         """
         try:
             # Import here to avoid circular imports

mmrelay/plugins/base_plugin.py

@@ -11,7 +11,7 @@ from mmrelay.constants.database import (
     DEFAULT_MAX_DATA_ROWS_PER_NODE_BASE,
     DEFAULT_TEXT_TRUNCATION_LENGTH,
 )
-from mmrelay.constants.queue import DEFAULT_MESSAGE_DELAY
+from mmrelay.constants.queue import DEFAULT_MESSAGE_DELAY, MINIMUM_MESSAGE_DELAY
 from mmrelay.db_utils import (
     delete_plugin_data,
     get_plugin_data,
@@ -77,7 +77,7 @@ class BasePlugin(ABC):
         Raises:
             ValueError: If the plugin name is not set via parameter or class attribute.
 
-        Loads plugin-specific configuration from the global config, validates assigned channels, and determines the response delay, enforcing a minimum of 2.0 seconds. Logs a warning if deprecated configuration options are used or if channels are not mapped.
+        Loads plugin-specific configuration from the global config, validates assigned channels, and determines the response delay, enforcing a minimum of 2.1 seconds. Logs a warning if deprecated configuration options are used or if channels are not mapped.
         """
         # Allow plugin_name to be passed as a parameter for simpler initialization
         # This maintains backward compatibility while providing a cleaner API
@@ -174,12 +174,12 @@ class BasePlugin(ABC):
 
             if delay is not None:
                 self.response_delay = delay
-                # Enforce minimum delay of 2 seconds due to firmware constraints
-                if self.response_delay < 2.0:
+                # Enforce minimum delay above firmware limit to prevent message dropping
+                if self.response_delay < MINIMUM_MESSAGE_DELAY:
                     self.logger.warning(
-                        f"{delay_key} of {self.response_delay}s is below minimum of 2.0s (firmware constraint). Using 2.0s."
+                        f"{delay_key} of {self.response_delay}s is below minimum of {MINIMUM_MESSAGE_DELAY}s (above firmware limit). Using {MINIMUM_MESSAGE_DELAY}s."
                     )
-                    self.response_delay = 2.0
+                    self.response_delay = MINIMUM_MESSAGE_DELAY
 
     def start(self):
         """
@@ -261,7 +261,7 @@ class BasePlugin(ABC):
         """
         Return the configured delay in seconds before sending a Meshtastic response.
 
-        The delay is determined by the `meshtastic.message_delay` configuration option, defaulting to 2.2 seconds with a minimum of 2.0 seconds. The deprecated `plugin_response_delay` option is also supported for backward compatibility.
+        The delay is determined by the `meshtastic.message_delay` configuration option, defaulting to 2.5 seconds with a minimum of 2.1 seconds. The deprecated `plugin_response_delay` option is also supported for backward compatibility.
 
         Returns:
             float: The response delay in seconds.

mmrelay/plugins/mesh_relay_plugin.py

@@ -122,7 +122,7 @@ class Plugin(BasePlugin):
 
         if not channel_mapped:
             self.logger.debug(f"Skipping message from unmapped channel {channel}")
-            return None
+            return False
 
         await matrix_client.room_send(
             room_id=room["id"],
@@ -135,20 +135,19 @@ class Plugin(BasePlugin):
             },
         )
 
-        return None
+        return True
 
     def matches(self, event):
         """
-        Return True if the Matrix event's content body exactly matches the relayed-packet marker.
-        
-        Checks event.source["content"]["body"] (when a string) against the anchored pattern
-        "Processed <anything> radio packet" and returns True on match, otherwise False.
-        
+        Determine whether a Matrix event's message body contains the bridged-packet marker.
+
+        Checks event.source["content"]["body"] (when it is a string) against the anchored pattern `^Processed (.+) radio packet$`.
+
         Parameters:
-            event: Matrix event object with a .source mapping expected to contain a "content" dict.
-        
+            event: Matrix event object whose `.source` mapping is expected to contain a `"content"` dict with a `"body"` string.
+
         Returns:
-            bool: True if the body matches the relayed-packet pattern, False otherwise.
+            True if the content body matches `^Processed (.+) radio packet$`, False otherwise.
         """
         # Check for the presence of necessary keys in the event
         content = event.source.get("content", {})
@@ -181,7 +180,7 @@ class Plugin(BasePlugin):
         """
         # Use the event for matching instead of full_message
         if not self.matches(event):
-            return None
+            return False
 
         channel = None
         if config is not None:
@@ -192,18 +191,18 @@ class Plugin(BasePlugin):
 
         if channel is None:
             self.logger.debug(f"Skipping message from unmapped channel {channel}")
-            return None
+            return False
 
         packet_json = event.source["content"].get("meshtastic_packet")
         if not packet_json:
             self.logger.debug("Missing embedded packet")
-            return None
+            return False
 
         try:
             packet = json.loads(packet_json)
-        except (json.JSONDecodeError, TypeError) as e:
-            self.logger.exception(f"Error processing embedded packet: {e}")
-            return None
+        except (json.JSONDecodeError, TypeError):
+            self.logger.exception("Error processing embedded packet")
+            return False
 
         from mmrelay.meshtastic_utils import connect_meshtastic
 
@@ -220,4 +219,4 @@ class Plugin(BasePlugin):
         meshtastic_client._sendPacket(
             meshPacket=meshPacket, destinationId=packet["toId"]
         )
-        return None
+        return True

mmrelay/setup_utils.py

@@ -359,11 +359,11 @@ def is_service_active():
 def create_service_file():
     """
     Create or update the per-user systemd unit file for MMRelay.
-    
-    Ensures the user systemd directory (~/.config/systemd/user) and the MMRelay logs directory (~/.mmrelay/logs) exist, obtains a service unit template (using the module's template-loading fallbacks), substitutes known placeholders (working directory, packaged launcher, and config path), and normalizes the Unit's ExecStart to the resolved MMRelay invocation (an mmrelay executable on PATH or a Python `-m mmrelay` fallback) while preserving any trailing arguments. The final unit is written to ~/.config/systemd/user/mmrelay.service.
-    
+
+    Ensures the user systemd directory (~/.config/systemd/user) and the MMRelay logs directory (~/.mmrelay/logs) exist, obtains a service unit template using the module's template-loading fallbacks, substitutes known placeholders (working directory, packaged launcher, and config path), normalizes the Unit's ExecStart to the resolved MMRelay invocation (an mmrelay executable on PATH or a Python `-m mmrelay` fallback) while preserving any trailing arguments, and writes the resulting unit to ~/.config/systemd/user/mmrelay.service.
+
     Returns:
-        bool: True if the service file was written successfully; False if no template could be obtained or writing the file failed.
+        bool: True if the service file was written successfully; False if a template could not be obtained or writing the file failed.
     """
     # Get executable paths once to avoid duplicate calls and output
     executable_path = get_executable_path()
@@ -581,7 +581,7 @@ def check_lingering_enabled():
 def enable_lingering():
     """
     Enable systemd "lingering" for the current user by running `sudo loginctl enable-linger <user>`.
-    
+
     Determines the username from environment variables or getpass.getuser(), invokes the privileged `loginctl` command to enable lingering, and returns True if the command exits successfully. On failure (non-zero exit, missing username, or subprocess/OSError), returns False and prints an error message to stderr.
     """
     try:

mmrelay/tools/sample-docker-compose-prebuilt.yaml

@@ -7,13 +7,24 @@ services:
     user: "${UID:-1000}:${GID:-1000}"
     environment:
       - TZ=UTC # Set timezone (PYTHONUNBUFFERED and MPLCONFIGDIR are set in Dockerfile)
+
     volumes:
       # Mount your config directory - create ~/.mmrelay/config.yaml first
       # See docs/DOCKER.md for setup instructions
-      # For SELinux systems (RHEL/CentOS/Fedora), add :Z flag to prevent permission denied errors
-      - ${MMRELAY_HOME:-$HOME}/.mmrelay/config.yaml:/app/config.yaml:ro,Z
-      - ${MMRELAY_HOME:-$HOME}/.mmrelay:/app/data:Z
-      # For non-SELinux systems, you can use:
-      # - ${MMRELAY_HOME:-$HOME}/.mmrelay/config.yaml:/app/config.yaml:ro
-      # - ${MMRELAY_HOME:-$HOME}/.mmrelay:/app/data
-      # Tip: For correct permissions and paths, ensure UID, GID, and MMRELAY_HOME are set in a .env file or exported
+      # For non-SELinux systems (most common):
+      - ${MMRELAY_HOME:-$HOME}/.mmrelay/config.yaml:/app/config.yaml:ro
+      - ${MMRELAY_HOME:-$HOME}/.mmrelay:/app/data
+      # For SELinux systems (RHEL/CentOS/Fedora), add :Z flag to prevent permission denied errors:
+      # - ${MMRELAY_HOME:-$HOME}/.mmrelay/config.yaml:/app/config.yaml:ro,Z
+      # - ${MMRELAY_HOME:-$HOME}/.mmrelay:/app/data:Z
+
+      # For BLE connections, uncomment these lines (Linux only):
+      # - /var/run/dbus:/var/run/dbus:ro
+
+    # For BLE connections, uncomment these options (Linux only). See DOCKER.md for alternatives.
+    # network_mode: host
+    # security_opt:
+    #   - apparmor=unconfined # Recommended for BLE to allow DBus communication
+    # privileged: true # Alternative if apparmor=unconfined is not acceptable
+
+    # Tip: For correct permissions and paths, ensure UID, GID, and MMRELAY_HOME are set in a .env file or exported

mmrelay/tools/sample-docker-compose.yaml

@@ -7,13 +7,24 @@ services:
     user: "${UID:-1000}:${GID:-1000}"
     environment:
       - TZ=UTC # Set timezone (PYTHONUNBUFFERED and MPLCONFIGDIR are set in Dockerfile)
+
     volumes:
       # Mount your config directory - create ~/.mmrelay/config.yaml first
       # Run 'make config' to set up the files
-      # For SELinux systems (RHEL/CentOS/Fedora), add :Z flag to prevent permission denied errors
-      - ${MMRELAY_HOME:-$HOME}/.mmrelay/config.yaml:/app/config.yaml:ro,Z
-      - ${MMRELAY_HOME:-$HOME}/.mmrelay:/app/data:Z
-      # For non-SELinux systems, you can use:
-      # - ${MMRELAY_HOME:-$HOME}/.mmrelay/config.yaml:/app/config.yaml:ro
-      # - ${MMRELAY_HOME:-$HOME}/.mmrelay:/app/data
-      # Tip: For correct permissions and paths, ensure UID, GID, and MMRELAY_HOME are set in a .env file or exported
+      # For non-SELinux systems (most common):
+      - ${MMRELAY_HOME:-$HOME}/.mmrelay/config.yaml:/app/config.yaml:ro
+      - ${MMRELAY_HOME:-$HOME}/.mmrelay:/app/data
+      # For SELinux systems (RHEL/CentOS/Fedora), add :Z flag to prevent permission denied errors:
+      # - ${MMRELAY_HOME:-$HOME}/.mmrelay/config.yaml:/app/config.yaml:ro,Z
+      # - ${MMRELAY_HOME:-$HOME}/.mmrelay:/app/data:Z
+
+      # For BLE connections, uncomment these lines (Linux only):
+      # - /var/run/dbus:/var/run/dbus:ro
+
+    # For BLE connections, uncomment these options (Linux only). See DOCKER.md for alternatives.
+    # network_mode: host
+    # security_opt:
+    #   - apparmor=unconfined # Recommended for BLE to allow DBus communication
+    # privileged: true # Alternative if apparmor=unconfined is not acceptable
+
+    # Tip: For correct permissions and paths, ensure UID, GID, and MMRELAY_HOME are set in a .env file or exported

mmrelay/windows_utils.py

@@ -28,7 +28,7 @@ def is_windows() -> bool:
 def setup_windows_console() -> None:
     """
     Configure the Windows console for UTF-8 output and ANSI (VT100) color support.
-    
+
     Best-effort operation: on Windows this attempts to set stdout/stderr encoding to UTF-8
     (if supported) and enable Virtual Terminal Processing so ANSI color sequences and
     Unicode render correctly. No-op on non-Windows platforms; failures are silently ignored.

{mmrelay-1.2.2.dist-info → mmrelay-1.2.4.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mmrelay
-Version: 1.2.2
+Version: 1.2.4
 Summary: Bridge between Meshtastic mesh networks and Matrix chat rooms
 Home-page: https://github.com/jeremiah-k/meshtastic-matrix-relay
 Author: Geoff Whittington, Jeremiah K., and contributors
@@ -18,7 +18,7 @@ Classifier: Topic :: Communications
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
 License-File: LICENSE
-Requires-Dist: meshtastic>=2.6.4
+Requires-Dist: meshtastic>=2.7.3
 Requires-Dist: Pillow==11.3.0
 Requires-Dist: matrix-nio==0.25.2
 Requires-Dist: matplotlib==3.10.1

{mmrelay-1.2.2.dist-info → mmrelay-1.2.4.dist-info}/RECORD

@@ -1,19 +1,19 @@
-mmrelay/__init__.py,sha256=vnKf5ECNyF96YnmUUlBJS4Xwn1kTGb2VbI75clrcZV4,120
+mmrelay/__init__.py,sha256=DMVdCPD3oN7x0SkEuR6Pq5etPc622-e-kkxsSN2rl2A,120
 mmrelay/__main__.py,sha256=Z839i5jxZmhdoPvR1-reWoQL4Xpmty81p8TsTKsJLC8,814
-mmrelay/cli.py,sha256=PNUnt1K83QI6vtPwc6hsL5Iaw9OaNDh5aS1Rlid64KE,79403
+mmrelay/cli.py,sha256=T4apzc8aS7smXh0bpqoMSDHpHOOxcjls9-vSB-ue5Nk,79543
 mmrelay/cli_utils.py,sha256=h0JKhU_sToO2_Orf9ddO8x07_L1k201V61yXydfU2es,28887
-mmrelay/config.py,sha256=XOmQomLuQRl6MnvKOn8tSjU8jaDp6rurjtgacRkhFaw,38330
+mmrelay/config.py,sha256=H93dRHAsZOtPQmeO5RZd-S7qx5zsoAn7bt1GgXdOPqw,38285
 mmrelay/db_utils.py,sha256=utt254MipaIRTaGqSAe7N9L_S7eIPSnQsOQj6Gk2E3U,22502
-mmrelay/e2ee_utils.py,sha256=krRXJzeo_tpW9QfcmpZe0A3kPoQ14tUrDQW7dxsx2sc,16656
-mmrelay/log_utils.py,sha256=psTzfRUTp1aVIE8U-7bzS7qc1ulU9EavqAEbDt8hUQA,9126
-mmrelay/main.py,sha256=mF1D7Psbk46CIOfGEtG3onG3Yn5Zk-3oZF_t2pTv1JY,16785
-mmrelay/matrix_utils.py,sha256=56VTa1ptf5eY-mcwUMTaAw09fztkoMs4j-UTi6nRUsY,134552
-mmrelay/meshtastic_utils.py,sha256=IJp0xD6HSqNEmOymVtgJaExtP83KhZrCM_SWDPqEIvU,48821
-mmrelay/message_queue.py,sha256=Ze9l_vDQBiWUX68jFvBbuMTJzyfcU4sW1jRyrN2tjC8,28005
+mmrelay/e2ee_utils.py,sha256=7cSb3F-FYqFcibSmb7eJzQJoRdq4Xk0_L5oppza3PHE,16914
+mmrelay/log_utils.py,sha256=CGTsHkeviCUKbe_SArYqOjPE5xRTslikMwzrag9LSFE,10290
+mmrelay/main.py,sha256=TlINxwGgk5pVe8gUuxzv29tYlZPuHYdqLcYsmrkUurI,17015
+mmrelay/matrix_utils.py,sha256=QPjwgkEKPgGLNFzeTXgfVusyfran7U_2NDs9UayTLWg,134586
+mmrelay/meshtastic_utils.py,sha256=wbVa8HDjbYNOTDLttVMGeRwTsYt8zJilUv_63FnmHoo,48783
+mmrelay/message_queue.py,sha256=aSitms4pr34VZ7nycpXuPw5ioA6x5xEdnwZ7_nh1Npw,28243
 mmrelay/plugin_loader.py,sha256=iXUpLGyjir7sfxtnL1REHdg5i5ZGWaHO_6sRQqf_JCE,59052
 mmrelay/runtime_utils.py,sha256=u8DtpfI-U7Ip3SAwjn214WfMTzc-xr5wffjN0i7WBZc,1261
-mmrelay/setup_utils.py,sha256=TNB2lRewKjt5aPFwVvQQeYZuE0eWvz3krn2pn-GZJvg,32738
-mmrelay/windows_utils.py,sha256=cXqXIszPAva-GLSY0Xxxai7PO7UBryAb9aPhdHdDo0I,13064
+mmrelay/setup_utils.py,sha256=SCFGx9e1wHZt87u2JMAhPUYOy-Ui4eV3irmzy0Zh9lE,32727
+mmrelay/windows_utils.py,sha256=FqjjsrCWhYxvEH5TcfVBuONCpA19VX9kcx7jHKsRWbM,13060
 mmrelay/constants/__init__.py,sha256=M8AXeIcS1JuS8OwmfTmhcCOkAz5XmWlNQ53GBxYOx94,1494
 mmrelay/constants/app.py,sha256=iNKqQMp5WZSfzsuRXYZ00znVm_ZyfwqiWMQgAblG6rY,725
 mmrelay/constants/config.py,sha256=B1A_OZLLNXHM9rHOwc01ZaJBvFugR2eXlhYYl4nUxlY,2479
@@ -21,28 +21,28 @@ mmrelay/constants/database.py,sha256=4cHfYfBePDUUtVSflrWyStcxKSQv7VE-jSrb1IzAjls
 mmrelay/constants/formats.py,sha256=cjbrfNNFCKoGSFsFHR1QQDEQudiGquA9MUapfm0_ZNI,494
 mmrelay/constants/messages.py,sha256=Reu_-6gZGGZQVP6BuqBm01QBhVTFjHVRQSPTUcQJG2Q,1531
 mmrelay/constants/network.py,sha256=QjROOAMxcP1pA1F_gUtuXzm2tORCqo5koqZbwrZRSns,1186
-mmrelay/constants/queue.py,sha256=yyWSrtq06b5GWzZwdl6IFtrMvxEuF9PdKSNPh8DdL2M,565
+mmrelay/constants/queue.py,sha256=cNK0cLsgBfQ6nVJm9_Scxj-ICv4RU6DU_PYsUwNyU_E,675
 mmrelay/plugins/__init__.py,sha256=KVMQIXRhe0wlGj4O3IZ0vOIQRKFkfPYejHXhJL17qrc,51
-mmrelay/plugins/base_plugin.py,sha256=Nh_zz-Z49qYatS4i38C2bLOl1sNDUgWsqpD8NLJdnl0,20807
+mmrelay/plugins/base_plugin.py,sha256=lcgKwrAMAIT9RjiC1Nyfs3fgdzUu3OQhCTZEjqh1_wg,20915
 mmrelay/plugins/debug_plugin.py,sha256=adX0cRJHUEDLldajybPfiRDDlvytkZe5aN_dSgNKP2Y,870
 mmrelay/plugins/drop_plugin.py,sha256=x4S-e0Muun2Dy1H2qwRMTBB1ptLmy7ZZJhgPu-KefGs,5394
 mmrelay/plugins/health_plugin.py,sha256=svV_GfpAVL0QhiVzi3PVZ1mNpsOL1NHSmkRF-Mn_ExE,2250
 mmrelay/plugins/help_plugin.py,sha256=S7nBhsANK46Zv9wPHOVegPGcuYGMErBsxAnrRlSSCwg,2149
 mmrelay/plugins/map_plugin.py,sha256=eHV_t3TFcypBD4xT_OQx0hD6_iGkLJOADjwYVny0PvE,11292
-mmrelay/plugins/mesh_relay_plugin.py,sha256=O5I_5H4Y8CSonuLoS4lGhlNee1F7RVmSv551WCSsufM,8477
+mmrelay/plugins/mesh_relay_plugin.py,sha256=OE07Kz5NvmyjXH3hneK5_eTPQ41mriJGZgsPcg-gpOQ,8428
 mmrelay/plugins/nodes_plugin.py,sha256=RDabzyG5hKG5aYWecsRUcLSjMCCv6Pngmq2Qpld1A1U,2903
 mmrelay/plugins/ping_plugin.py,sha256=8uFnT3qfO3RBaTUOx348voIfKpzXB3zTfcT6Gtfc8kM,4070
 mmrelay/plugins/telemetry_plugin.py,sha256=8SxWv4BLXMUTbiVaD3MjlMMdQyS7S_1OfLlVNAUMSO0,6306
 mmrelay/plugins/weather_plugin.py,sha256=ZmTNlkEjeCvZWHlO7VMend3vnj4h2qWeeU4RUQJY2vM,14183
 mmrelay/tools/__init__.py,sha256=WFjDQjdevgg19_zT6iEoL29rvb1JPqYSd8708Jn5D7A,838
 mmrelay/tools/mmrelay.service,sha256=6_TAskmTh9pXQSDRDeh0EXl2BfsUgm9Q3W9ob5tWCS8,600
-mmrelay/tools/sample-docker-compose-prebuilt.yaml,sha256=RT3IWA4DuLfIB5C7fUT1cDaYhOAxXiUjBan1M6PlvKc,958
-mmrelay/tools/sample-docker-compose.yaml,sha256=pbE9nXSA9DcEbdwhCQ0mZzzmhYRi3L9y8crx3a_YrTE,940
+mmrelay/tools/sample-docker-compose-prebuilt.yaml,sha256=ytQRW882VAecbWO1LsRsU6UbudybNhC-iv2w0Fta1Ls,1368
+mmrelay/tools/sample-docker-compose.yaml,sha256=1UqZFvnJuhVwfNJ92C0qQ5KSdNRVjk8YbRNZgD8yF_M,1350
 mmrelay/tools/sample.env,sha256=RP-o3rX3jnEIrVG2rqCZq31O1yRXou4HcGrXWLVbKKw,311
 mmrelay/tools/sample_config.yaml,sha256=odAeiU-wesWuwnZGyXzVjxaXVYc26p8QI1HOEA-Tvco,6396
-mmrelay-1.2.2.dist-info/licenses/LICENSE,sha256=aB_07MhnK-bL5WLI1ucXLUSdW_yBVoepPRYB0kaAOl8,35204
-mmrelay-1.2.2.dist-info/METADATA,sha256=JKh3iEvvM3Tgr01iAyWuhPPxOkMcpxgPgXQFXgsLtyY,6167
-mmrelay-1.2.2.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mmrelay-1.2.2.dist-info/entry_points.txt,sha256=SJZwGUOEpQ-qx4H8UL4xKFnKeInGUaZNW1I0ddjK7Ws,45
-mmrelay-1.2.2.dist-info/top_level.txt,sha256=B_ZLCRm7NYAmI3PipRUyHGymP-C-q16LSeMGzmqJfo4,8
-mmrelay-1.2.2.dist-info/RECORD,,
+mmrelay-1.2.4.dist-info/licenses/LICENSE,sha256=aB_07MhnK-bL5WLI1ucXLUSdW_yBVoepPRYB0kaAOl8,35204
+mmrelay-1.2.4.dist-info/METADATA,sha256=SOYGlz1SUe7pRR-VESGmmpy_jO49fwctDcQFvvkjBHo,6167
+mmrelay-1.2.4.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mmrelay-1.2.4.dist-info/entry_points.txt,sha256=SJZwGUOEpQ-qx4H8UL4xKFnKeInGUaZNW1I0ddjK7Ws,45
+mmrelay-1.2.4.dist-info/top_level.txt,sha256=B_ZLCRm7NYAmI3PipRUyHGymP-C-q16LSeMGzmqJfo4,8
+mmrelay-1.2.4.dist-info/RECORD,,