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

mmrelay/matrix_utils.py

@@ -29,7 +29,74 @@ from mmrelay.db_utils import (
 from mmrelay.log_utils import get_logger
 
 # Do not import plugin_loader here to avoid circular imports
-from mmrelay.meshtastic_utils import connect_meshtastic
+from mmrelay.meshtastic_utils import connect_meshtastic, sendTextReply
+from mmrelay.message_queue import get_message_queue, queue_message
+
+logger = get_logger(name="matrix_utils")
+
+
+def _get_msgs_to_keep_config():
+    """
+    Retrieve the configured number of messages to retain for message mapping, supporting both current and legacy configuration formats.
+
+    Returns:
+        int: The number of messages to keep in the database for message mapping (default is 500).
+    """
+    global config
+    if not config:
+        return 500
+
+    msg_map_config = config.get("database", {}).get("msg_map", {})
+
+    # If not found in database config, check legacy db config
+    if not msg_map_config:
+        legacy_msg_map_config = config.get("db", {}).get("msg_map", {})
+
+        if legacy_msg_map_config:
+            msg_map_config = legacy_msg_map_config
+            logger.warning(
+                "Using 'db.msg_map' configuration (legacy). 'database.msg_map' is now the preferred format and 'db.msg_map' will be deprecated in a future version."
+            )
+
+    return msg_map_config.get("msgs_to_keep", 500)
+
+
+def _create_mapping_info(
+    matrix_event_id, room_id, text, meshnet=None, msgs_to_keep=None
+):
+    """
+    Constructs a dictionary containing metadata for mapping a Matrix event to a Meshtastic message in the message queue.
+
+    Removes quoted lines from the message text and includes relevant identifiers and configuration for message retention. Returns `None` if required parameters are missing.
+
+    Parameters:
+        matrix_event_id: The Matrix event ID to map.
+        room_id: The Matrix room ID where the event occurred.
+        text: The message text to be mapped; quoted lines are removed.
+        meshnet: Optional name of the target mesh network.
+        msgs_to_keep: Optional number of messages to retain for mapping; uses configuration default if not provided.
+
+    Returns:
+        dict: A dictionary with mapping information for use by the message queue, or `None` if required fields are missing.
+    """
+    if not matrix_event_id or not room_id or not text:
+        return None
+
+    if msgs_to_keep is None:
+        msgs_to_keep = _get_msgs_to_keep_config()
+
+    return {
+        "matrix_event_id": matrix_event_id,
+        "room_id": room_id,
+        "text": strip_quoted_lines(text),
+        "meshnet": meshnet,
+        "msgs_to_keep": msgs_to_keep,
+    }
+
+
+# Default prefix format constants
+DEFAULT_MESHTASTIC_PREFIX = "{display5}[M]: "
+DEFAULT_MATRIX_PREFIX = "[{long}/{mesh}]: "
 
 
 def get_interaction_settings(config):
@@ -70,15 +137,184 @@ def get_interaction_settings(config):
 
 def message_storage_enabled(interactions):
     """
-    Return True if message storage is required for enabled message interactions.
+    Determine if message storage is needed based on enabled message interactions.
+
+    Returns:
+        True if either reactions or replies are enabled in the interactions dictionary; otherwise, False.
+    """
+    return interactions["reactions"] or interactions["replies"]
+
+
+def _add_truncated_vars(format_vars, prefix, text):
+    """Helper function to add variable length truncation variables to format_vars dict."""
+    # Always add truncated variables, even for empty text (to prevent KeyError)
+    text = text or ""  # Convert None to empty string
+    logger.debug(f"Adding truncated vars for prefix='{prefix}', text='{text}'")
+    for i in range(1, 21):  # Support up to 20 chars, always add all variants
+        truncated_value = text[:i]
+        format_vars[f"{prefix}{i}"] = truncated_value
+        if i <= 6:  # Only log first few to avoid spam
+            logger.debug(f"  {prefix}{i} = '{truncated_value}'")
+
+
+def validate_prefix_format(format_string, available_vars):
+    """Validate prefix format string against available variables.
+
+    Args:
+        format_string (str): The format string to validate.
+        available_vars (dict): Dictionary of available variables with test values.
+
+    Returns:
+        tuple: (is_valid: bool, error_message: str or None)
+    """
+    try:
+        # Test format with dummy data
+        format_string.format(**available_vars)
+        return True, None
+    except (KeyError, ValueError) as e:
+        return False, str(e)
+
+
+def get_meshtastic_prefix(config, display_name, user_id=None):
+    """
+    Generate a Meshtastic message prefix using the configured format, supporting variable-length truncation and user-specific variables.
+
+    If prefix formatting is enabled in the configuration, returns a formatted prefix string for Meshtastic messages using the user's display name and optional Matrix user ID. Supports custom format strings with placeholders for the display name, truncated display name segments (e.g., `{display5}`), and user ID components. Falls back to a default format if the custom format is invalid or missing. Returns an empty string if prefixing is disabled.
+
+    Args:
+        config (dict): The application configuration dictionary.
+        display_name (str): The user's display name (room-specific or global).
+        user_id (str, optional): The user's Matrix ID (@user:server.com).
+
+    Returns:
+        str: The formatted prefix string if enabled, empty string otherwise.
+
+    Examples:
+        Basic usage:
+            get_meshtastic_prefix(config, "Alice Smith")
+            # Returns: "Alice[M]: " (with default format)
+
+        Custom format:
+            config = {"meshtastic": {"prefix_format": "{display8}> "}}
+            get_meshtastic_prefix(config, "Alice Smith")
+            # Returns: "Alice Sm> "
+    """
+    meshtastic_config = config.get("meshtastic", {})
+
+    # Check if prefixes are enabled
+    if not meshtastic_config.get("prefix_enabled", True):
+        return ""
+
+    # Get custom format or use default
+    prefix_format = meshtastic_config.get("prefix_format", DEFAULT_MESHTASTIC_PREFIX)
+
+    # Parse username and server from user_id if available
+    username = ""
+    server = ""
+    if user_id:
+        # Extract username and server from @username:server.com format
+        if user_id.startswith("@") and ":" in user_id:
+            parts = user_id[1:].split(":", 1)  # Remove @ and split on first :
+            username = parts[0]
+            server = parts[1] if len(parts) > 1 else ""
+
+    # Available variables for formatting with variable length support
+    format_vars = {
+        "display": display_name or "",
+        "user": user_id or "",
+        "username": username,
+        "server": server,
+    }
+
+    # Add variable length display name truncation (display1, display2, display3, etc.)
+    _add_truncated_vars(format_vars, "display", display_name)
+
+    try:
+        return prefix_format.format(**format_vars)
+    except (KeyError, ValueError) as e:
+        # Fallback to default format if custom format is invalid
+        logger.warning(
+            f"Invalid prefix_format '{prefix_format}': {e}. Using default format."
+        )
+        # The default format only uses 'display5', which is safe to format
+        return DEFAULT_MESHTASTIC_PREFIX.format(
+            display5=display_name[:5] if display_name else ""
+        )
+
+
+def get_matrix_prefix(config, longname, shortname, meshnet_name):
+    """
+    Generate a formatted prefix for Meshtastic messages relayed to Matrix, using configurable templates and variable-length truncation for sender and mesh network names.
 
     Parameters:
-        interactions (dict): Dictionary with 'reactions' and 'replies' boolean flags.
+        config (dict): The application configuration dictionary.
+        longname (str): Full Meshtastic sender name.
+        shortname (str): Short Meshtastic sender name.
+        meshnet_name (str): Name of the mesh network.
 
     Returns:
-        bool: True if reactions or replies are enabled; otherwise, False.
+        str: The formatted prefix string if prefixing is enabled; otherwise, an empty string.
+
+    Examples:
+        Basic usage:
+            get_matrix_prefix(config, "Alice", "Ali", "MyMesh")
+            # Returns: "[Alice/MyMesh]: " (with default format)
+
+        Custom format:
+            config = {"matrix": {"prefix_format": "({long4}): "}}
+            get_matrix_prefix(config, "Alice", "Ali", "MyMesh")
+            # Returns: "(Alic): "
     """
-    return interactions["reactions"] or interactions["replies"]
+    matrix_config = config.get("matrix", {})
+
+    # Enhanced debug logging for configuration troubleshooting
+    logger.debug(
+        f"get_matrix_prefix called with longname='{longname}', shortname='{shortname}', meshnet_name='{meshnet_name}'"
+    )
+    logger.debug(f"Matrix config section: {matrix_config}")
+
+    # Check if prefixes are enabled for Matrix direction
+    if not matrix_config.get("prefix_enabled", True):
+        logger.debug("Matrix prefixes are disabled, returning empty string")
+        return ""
+
+    # Get custom format or use default
+    matrix_prefix_format = matrix_config.get("prefix_format", DEFAULT_MATRIX_PREFIX)
+    logger.debug(
+        f"Using matrix prefix format: '{matrix_prefix_format}' (default: '{DEFAULT_MATRIX_PREFIX}')"
+    )
+
+    # Available variables for formatting with variable length support
+    format_vars = {
+        "long": longname,
+        "short": shortname,
+        "mesh": meshnet_name,
+    }
+
+    # Add variable length truncation for longname and mesh name
+    _add_truncated_vars(format_vars, "long", longname)
+    _add_truncated_vars(format_vars, "mesh", meshnet_name)
+
+    try:
+        result = matrix_prefix_format.format(**format_vars)
+        logger.debug(
+            f"Matrix prefix generated: '{result}' using format '{matrix_prefix_format}' with vars {format_vars}"
+        )
+        # Additional debug to help identify the issue
+        if result == f"[{longname}/{meshnet_name}]: ":
+            logger.debug(
+                "Generated prefix matches default format - check if custom configuration is being loaded correctly"
+            )
+        return result
+    except (KeyError, ValueError) as e:
+        # Fallback to default format if custom format is invalid
+        logger.warning(
+            f"Invalid matrix prefix_format '{matrix_prefix_format}': {e}. Using default format."
+        )
+        # The default format only uses 'long' and 'mesh', which are safe
+        return DEFAULT_MATRIX_PREFIX.format(
+            long=longname or "", mesh=meshnet_name or ""
+        )
 
 
 # Global config variable that will be set from config.py
@@ -459,7 +695,7 @@ async def get_user_display_name(room, event):
     return display_name_response.displayname or event.sender
 
 
-def format_reply_message(full_display_name, text):
+def format_reply_message(config, full_display_name, text):
     """
     Format a reply message by prefixing a truncated display name and removing quoted lines.
 
@@ -472,8 +708,7 @@ def format_reply_message(full_display_name, text):
     Returns:
         str: The formatted and truncated reply message.
     """
-    short_display_name = full_display_name[:5]
-    prefix = f"{short_display_name}[M]: "
+    prefix = get_meshtastic_prefix(config, full_display_name)
 
     # Strip quoted content from the reply text
     clean_text = strip_quoted_lines(text)
@@ -493,82 +728,86 @@ async def send_reply_to_meshtastic(
     reply_id=None,
 ):
     """
-    Sends a reply message from Matrix to Meshtastic and optionally stores the message mapping for future interactions.
-
-    If message storage is enabled and the message is successfully sent, stores a mapping between the Meshtastic packet ID and the Matrix event ID, after removing quoted lines from the reply text. Prunes old message mappings based on configuration to limit storage size. Logs errors if sending fails.
+    Queues a reply message from Matrix to be sent to Meshtastic, optionally as a structured reply, and includes message mapping metadata if storage is enabled.
 
-    Args:
-        reply_id: If provided, sends as a structured Meshtastic reply to this message ID
+    If a `reply_id` is provided, the message is sent as a structured reply to the referenced Meshtastic message; otherwise, it is sent as a regular message. When message storage is enabled, mapping information is attached for future interaction tracking. The function logs the outcome of the queuing operation.
     """
     meshtastic_interface = connect_meshtastic()
     from mmrelay.meshtastic_utils import logger as meshtastic_logger
-    from mmrelay.meshtastic_utils import sendTextReply
 
     meshtastic_channel = room_config["meshtastic_channel"]
 
     if config["meshtastic"]["broadcast_enabled"]:
         try:
+            # Create mapping info once if storage is enabled
+            mapping_info = None
+            if storage_enabled:
+                # Get message map configuration
+                msgs_to_keep = _get_msgs_to_keep_config()
+
+                mapping_info = _create_mapping_info(
+                    event.event_id, room.room_id, text, local_meshnet_name, msgs_to_keep
+                )
+
             if reply_id is not None:
                 # Send as a structured reply using our custom function
-                try:
-                    sent_packet = sendTextReply(
-                        meshtastic_interface,
-                        text=reply_message,
-                        reply_id=reply_id,
-                        channelIndex=meshtastic_channel,
-                    )
-                    meshtastic_logger.info(
-                        f"Relaying Matrix reply from {full_display_name} to radio broadcast as structured reply to message {reply_id}"
-                    )
-                    meshtastic_logger.debug(
-                        f"sendTextReply returned packet: {sent_packet}"
-                    )
-                except Exception as e:
+                # Queue the reply message
+                success = queue_message(
+                    sendTextReply,
+                    meshtastic_interface,
+                    text=reply_message,
+                    reply_id=reply_id,
+                    channelIndex=meshtastic_channel,
+                    description=f"Reply from {full_display_name} to message {reply_id}",
+                    mapping_info=mapping_info,
+                )
+
+                if success:
+                    # Get queue size to determine logging approach
+                    queue_size = get_message_queue().get_queue_size()
+
+                    if queue_size > 1:
+                        meshtastic_logger.info(
+                            f"Relaying Matrix reply from {full_display_name} to radio broadcast as structured reply (queued: {queue_size} messages)"
+                        )
+                    else:
+                        meshtastic_logger.info(
+                            f"Relaying Matrix reply from {full_display_name} to radio broadcast as structured reply"
+                        )
+                else:
                     meshtastic_logger.error(
-                        f"Error sending structured reply to Meshtastic: {e}"
+                        "Failed to relay structured reply to Meshtastic"
                     )
                     return
             else:
                 # Send as regular message (fallback for when no reply_id is available)
-                try:
-                    meshtastic_logger.debug(
-                        f"Attempting to send text to Meshtastic: '{reply_message}' on channel {meshtastic_channel}"
-                    )
-                    sent_packet = meshtastic_interface.sendText(
-                        text=reply_message, channelIndex=meshtastic_channel
-                    )
-                    meshtastic_logger.info(
-                        f"Relaying Matrix reply from {full_display_name} to radio broadcast as regular message"
-                    )
-                    meshtastic_logger.debug(f"sendText returned packet: {sent_packet}")
-                except Exception as e:
+                success = queue_message(
+                    meshtastic_interface.sendText,
+                    text=reply_message,
+                    channelIndex=meshtastic_channel,
+                    description=f"Reply from {full_display_name} (fallback to regular message)",
+                    mapping_info=mapping_info,
+                )
+
+                if success:
+                    # Get queue size to determine logging approach
+                    queue_size = get_message_queue().get_queue_size()
+
+                    if queue_size > 1:
+                        meshtastic_logger.info(
+                            f"Relaying Matrix reply from {full_display_name} to radio broadcast (queued: {queue_size} messages)"
+                        )
+                    else:
+                        meshtastic_logger.info(
+                            f"Relaying Matrix reply from {full_display_name} to radio broadcast"
+                        )
+                else:
                     meshtastic_logger.error(
-                        f"Error sending reply message to Meshtastic: {e}"
+                        "Failed to relay reply message to Meshtastic"
                     )
                     return
 
-            # Store the reply in message map if storage is enabled
-            if storage_enabled and sent_packet and hasattr(sent_packet, "id"):
-                # Strip quoted lines from text before storing to prevent issues with reactions to replies
-                cleaned_text = strip_quoted_lines(text)
-                store_message_map(
-                    sent_packet.id,
-                    event.event_id,
-                    room.room_id,
-                    cleaned_text,
-                    meshtastic_meshnet=local_meshnet_name,
-                )
-                # Prune old messages if configured
-                database_config = config.get("database", {})
-                msg_map_config = database_config.get("msg_map", {})
-                if not msg_map_config:
-                    db_config = config.get("db", {})
-                    legacy_msg_map_config = db_config.get("msg_map", {})
-                    if legacy_msg_map_config:
-                        msg_map_config = legacy_msg_map_config
-                msgs_to_keep = msg_map_config.get("msgs_to_keep", 500)
-                if msgs_to_keep > 0:
-                    prune_message_map(msgs_to_keep)
+            # Message mapping is now handled automatically by the queue system
 
         except Exception as e:
             meshtastic_logger.error(f"Error sending Matrix reply to Meshtastic: {e}")
@@ -582,6 +821,7 @@ async def handle_matrix_reply(
     room_config,
     storage_enabled,
     local_meshnet_name,
+    config,
 ):
     """
     Relays a Matrix reply to the corresponding Meshtastic message if a mapping exists.
@@ -607,7 +847,7 @@ async def handle_matrix_reply(
     full_display_name = await get_user_display_name(room, event)
 
     # Format the reply message
-    reply_message = format_reply_message(full_display_name, text)
+    reply_message = format_reply_message(config, full_display_name, text)
 
     logger.info(
         f"Relaying Matrix reply from {full_display_name} to Meshtastic as reply to message {original_meshtastic_id}"
@@ -635,12 +875,14 @@ async def on_room_message(
     event: Union[RoomMessageText, RoomMessageNotice, ReactionEvent, RoomMessageEmote],
 ) -> None:
     """
-    Handles incoming Matrix room messages, reactions, and replies, relaying them to Meshtastic as appropriate.
+    Handle incoming Matrix room messages, reactions, and replies, relaying them to Meshtastic as appropriate.
 
-    Processes events from Matrix rooms, including text messages, reactions, and replies. Relays supported messages to Meshtastic if broadcasting is enabled, applying message mapping for cross-referencing when reactions or replies are enabled. Prevents relaying of reactions to reactions and avoids processing messages from the bot itself or messages sent before the bot started. Integrates with plugins for command and message handling, and ensures that only supported messages are forwarded to Meshtastic.
+    This function processes Matrix events—including text messages, reactions, and replies—received in configured Matrix rooms. It relays supported messages to the Meshtastic mesh network if broadcasting is enabled, applying message mapping for cross-referencing when reactions or replies are enabled. The function prevents relaying of reactions to reactions, ignores messages from the bot itself or those sent before the bot started, and integrates with plugins for command and message handling. Only messages that are not commands or handled by plugins are forwarded to Meshtastic, with proper formatting and truncation as needed.
     """
     # Importing here to avoid circular imports and to keep logic consistent
     # Note: We do not call store_message_map directly here for inbound matrix->mesh messages.
+    from mmrelay.message_queue import get_message_queue
+
     # That logic occurs inside matrix_relay if needed.
     full_display_name = "Unknown user"
     message_timestamp = event.server_timestamp
@@ -785,15 +1027,19 @@ async def on_room_message(
                 logger.debug(
                     f"Sending reaction to Meshtastic with meshnet={local_meshnet_name}: {reaction_message}"
                 )
-                try:
-                    sent_packet = meshtastic_interface.sendText(
-                        text=reaction_message, channelIndex=meshtastic_channel
-                    )
+                success = queue_message(
+                    meshtastic_interface.sendText,
+                    text=reaction_message,
+                    channelIndex=meshtastic_channel,
+                    description=f"Remote reaction from {meshnet_name}",
+                )
+
+                if success:
                     logger.debug(
-                        f"Remote reaction sendText returned packet: {sent_packet}"
+                        f"Queued remote reaction to Meshtastic: {reaction_message}"
                     )
-                except Exception as e:
-                    logger.error(f"Error sending remote reaction to Meshtastic: {e}")
+                else:
+                    logger.error("Failed to relay remote reaction to Meshtastic")
                     return
             # We've relayed the remote reaction to our local mesh, so we're done.
             return
@@ -824,8 +1070,7 @@ async def on_room_message(
                 full_display_name = display_name_response.displayname or event.sender
 
             # If not from a remote meshnet, proceed as normal to relay back to the originating meshnet
-            short_display_name = full_display_name[:5]
-            prefix = f"{short_display_name}[M]: "
+            prefix = get_meshtastic_prefix(config, full_display_name)
 
             # Remove quoted lines so we don't bring in the original '>' lines from replies
             meshtastic_text_db = strip_quoted_lines(meshtastic_text_db)
@@ -855,15 +1100,19 @@ async def on_room_message(
                 logger.debug(
                     f"Sending reaction to Meshtastic with meshnet={local_meshnet_name}: {reaction_message}"
                 )
-                try:
-                    sent_packet = meshtastic_interface.sendText(
-                        text=reaction_message, channelIndex=meshtastic_channel
-                    )
+                success = queue_message(
+                    meshtastic_interface.sendText,
+                    text=reaction_message,
+                    channelIndex=meshtastic_channel,
+                    description=f"Local reaction from {full_display_name}",
+                )
+
+                if success:
                     logger.debug(
-                        f"Local reaction sendText returned packet: {sent_packet}"
+                        f"Queued local reaction to Meshtastic: {reaction_message}"
                     )
-                except Exception as e:
-                    logger.error(f"Error sending local reaction to Meshtastic: {e}")
+                else:
+                    logger.error("Failed to relay local reaction to Meshtastic")
                     return
             return
 
@@ -877,6 +1126,7 @@ async def on_room_message(
             room_config,
             storage_enabled,
             local_meshnet_name,
+            config,
         )
         if reply_handled:
             return
@@ -893,10 +1143,20 @@ async def on_room_message(
             # If shortname is not available, derive it from the longname
             if shortname is None:
                 shortname = longname[:3] if longname else "???"
-            # Remove the original prefix "[longname/meshnet]: " to avoid double-tagging
-            text = re.sub(rf"^\[{full_display_name}\]: ", "", text)
+            # Remove the original prefix to avoid double-tagging
+            # Get the prefix that would have been used for this message
+            original_prefix = get_matrix_prefix(
+                config, longname, shortname, meshnet_name
+            )
+            if original_prefix and text.startswith(original_prefix):
+                text = text[len(original_prefix) :]
+                logger.debug(
+                    f"Removed original prefix '{original_prefix}' from remote meshnet message"
+                )
             text = truncate_message(text)
-            full_message = f"{shortname}/{short_meshnet_name}: {text}"
+            # Use the configured prefix format for remote meshnet messages
+            prefix = get_matrix_prefix(config, longname, shortname, short_meshnet_name)
+            full_message = f"{prefix}{text}"
         else:
             # If this message is from our local meshnet (loopback), we ignore it
             return
@@ -910,8 +1170,7 @@ async def on_room_message(
             # Fallback to global display name if room-specific name is not available
             display_name_response = await matrix_client.get_displayname(event.sender)
             full_display_name = display_name_response.displayname or event.sender
-        short_display_name = full_display_name[:5]
-        prefix = f"{short_display_name}[M]: "
+        prefix = get_meshtastic_prefix(config, full_display_name, event.sender)
         logger.debug(f"Processing matrix message from [{full_display_name}]: {text}")
         full_message = f"{prefix}{text}"
         text = truncate_message(text)
@@ -971,23 +1230,31 @@ async def on_room_message(
             if portnum == "DETECTION_SENSOR_APP":
                 # If detection_sensor is enabled, forward this data as detection sensor data
                 if config["meshtastic"].get("detection_sensor", False):
-                    try:
-                        meshtastic_logger.debug(
-                            f"Attempting to send detection sensor data to Meshtastic: '{full_message}' on channel {meshtastic_channel}"
-                        )
-                        sent_packet = meshtastic_interface.sendData(
-                            data=full_message.encode("utf-8"),
-                            channelIndex=meshtastic_channel,
-                            portNum=meshtastic.protobuf.portnums_pb2.PortNum.DETECTION_SENSOR_APP,
-                        )
-                        meshtastic_logger.debug(
-                            f"sendData returned packet: {sent_packet}"
-                        )
+                    success = queue_message(
+                        meshtastic_interface.sendData,
+                        data=full_message.encode("utf-8"),
+                        channelIndex=meshtastic_channel,
+                        portNum=meshtastic.protobuf.portnums_pb2.PortNum.DETECTION_SENSOR_APP,
+                        description=f"Detection sensor data from {full_display_name}",
+                    )
+
+                    if success:
+                        # Get queue size to determine logging approach
+                        queue_size = get_message_queue().get_queue_size()
+
+                        if queue_size > 1:
+                            meshtastic_logger.info(
+                                f"Relaying detection sensor data from {full_display_name} to radio broadcast (queued: {queue_size} messages)"
+                            )
+                        else:
+                            meshtastic_logger.info(
+                                f"Relaying detection sensor data from {full_display_name} to radio broadcast"
+                            )
                         # Note: Detection sensor messages are not stored in message_map because they are never replied to
                         # Only TEXT_MESSAGE_APP messages need to be stored for reaction handling
-                    except Exception as e:
+                    else:
                         meshtastic_logger.error(
-                            f"Error sending detection sensor data to Meshtastic: {e}"
+                            "Failed to relay detection sensor data to Meshtastic"
                         )
                         return
                 else:
@@ -995,53 +1262,47 @@ async def on_room_message(
                         f"Detection sensor packet received from {full_display_name}, but detection sensor processing is disabled."
                     )
             else:
-                meshtastic_logger.info(
-                    f"Relaying message from {full_display_name} to radio broadcast"
-                )
+                # Regular text message - logging will be handled by queue success handler
+                pass
 
-                try:
-                    sent_packet = meshtastic_interface.sendText(
-                        text=full_message, channelIndex=meshtastic_channel
-                    )
-                    if not sent_packet:
-                        meshtastic_logger.warning(
-                            "sendText returned None - message may not have been sent"
-                        )
-                except Exception as e:
-                    meshtastic_logger.error(f"Error sending message to Meshtastic: {e}")
-                    import traceback
+                # Create mapping info if storage is enabled
+                mapping_info = None
+                if storage_enabled:
+                    # Check database config for message map settings (preferred format)
+                    msgs_to_keep = _get_msgs_to_keep_config()
 
-                    meshtastic_logger.error(f"Full traceback: {traceback.format_exc()}")
-                    return
-                # Store message_map only if storage is enabled and only for TEXT_MESSAGE_APP
-                # (these are the only messages that can be replied to and thus need reaction handling)
-                if storage_enabled and sent_packet and hasattr(sent_packet, "id"):
-                    # Strip quoted lines from text before storing to prevent issues with reactions to replies
-                    cleaned_text = strip_quoted_lines(text)
-                    store_message_map(
-                        sent_packet.id,
+                    mapping_info = _create_mapping_info(
                         event.event_id,
                         room.room_id,
-                        cleaned_text,
-                        meshtastic_meshnet=local_meshnet_name,
+                        text,
+                        local_meshnet_name,
+                        msgs_to_keep,
                     )
-                    # Check database config for message map settings (preferred format)
-                    database_config = config.get("database", {})
-                    msg_map_config = database_config.get("msg_map", {})
-
-                    # If not found in database config, check legacy db config
-                    if not msg_map_config:
-                        db_config = config.get("db", {})
-                        legacy_msg_map_config = db_config.get("msg_map", {})
-
-                        if legacy_msg_map_config:
-                            msg_map_config = legacy_msg_map_config
-                            logger.warning(
-                                "Using 'db.msg_map' configuration (legacy). 'database.msg_map' is now the preferred format and 'db.msg_map' will be deprecated in a future version."
-                            )
-                    msgs_to_keep = msg_map_config.get("msgs_to_keep", 500)
-                    if msgs_to_keep > 0:
-                        prune_message_map(msgs_to_keep)
+
+                success = queue_message(
+                    meshtastic_interface.sendText,
+                    text=full_message,
+                    channelIndex=meshtastic_channel,
+                    description=f"Message from {full_display_name}",
+                    mapping_info=mapping_info,
+                )
+
+                if success:
+                    # Get queue size to determine logging approach
+                    queue_size = get_message_queue().get_queue_size()
+
+                    if queue_size > 1:
+                        meshtastic_logger.info(
+                            f"Relaying message from {full_display_name} to radio broadcast (queued: {queue_size} messages)"
+                        )
+                    else:
+                        meshtastic_logger.info(
+                            f"Relaying message from {full_display_name} to radio broadcast"
+                        )
+                else:
+                    meshtastic_logger.error("Failed to relay message to Meshtastic")
+                    return
+                # Message mapping is now handled automatically by the queue system
         else:
             logger.debug(
                 f"Broadcast not supported: Message from {full_display_name} dropped."