mmrelay 1.1.2__py3-none-any.whl → 1.1.4__py3-none-any.whl

mmrelay/matrix_utils.py

@@ -21,6 +21,18 @@ from nio import (
 from nio.events.room_events import RoomMemberEvent
 from PIL import Image
 
+from mmrelay.constants.config import (
+    CONFIG_KEY_ACCESS_TOKEN,
+    CONFIG_KEY_HOMESERVER,
+    CONFIG_SECTION_MATRIX,
+)
+from mmrelay.constants.database import DEFAULT_MSGS_TO_KEEP
+from mmrelay.constants.formats import (
+    DEFAULT_MATRIX_PREFIX,
+    DEFAULT_MESHTASTIC_PREFIX,
+    DETECTION_SENSOR_APP,
+)
+from mmrelay.constants.network import MILLISECONDS_PER_SECOND
 from mmrelay.db_utils import (
     get_message_map_by_matrix_event_id,
     prune_message_map,
@@ -29,14 +41,69 @@ 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():
+    """
+    Returns the configured number of messages to retain for message mapping, supporting both current and legacy configuration sections.
+
+    Returns:
+        int: Number of messages to keep for message mapping; defaults to the predefined constant if not set.
+    """
+    global config
+    if not config:
+        return DEFAULT_MSGS_TO_KEEP
+
+    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", DEFAULT_MSGS_TO_KEEP)
+
+
+def _create_mapping_info(
+    matrix_event_id, room_id, text, meshnet=None, msgs_to_keep=None
+):
+    """
+    Create a metadata dictionary linking a Matrix event to a Meshtastic message for message mapping.
+
+    Removes quoted lines from the message text and includes identifiers and message retention settings. Returns `None` if any required parameter is missing.
+
+    Returns:
+        dict: Mapping information for 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,
+    }
 
 
 def get_interaction_settings(config):
     """
-    Returns a dictionary indicating whether message reactions and replies are enabled based on the provided configuration.
+    Determine if message reactions and replies are enabled in the configuration.
 
-    Supports both the new `message_interactions` structure and the legacy `relay_reactions` flag for backward compatibility. Defaults to disabling both features if not specified.
+    Checks for both the new `message_interactions` structure and the legacy `relay_reactions` flag for backward compatibility. Returns a dictionary with boolean values for `reactions` and `replies`, defaulting to both disabled if not specified.
     """
     if config is None:
         return {"reactions": False, "replies": False}
@@ -70,15 +137,175 @@ 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):
+    """
+    Generates a formatted prefix string for Meshtastic messages relayed to Matrix, based on configuration settings and sender/mesh network names.
+
+    The prefix format supports variable-length truncation for the sender and mesh network names using template variables (e.g., `{long4}` for the first 4 characters of the sender name). Returns an empty string if prefixing is disabled in the configuration.
 
     Parameters:
-        interactions (dict): Dictionary with 'reactions' and 'replies' boolean flags.
+        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, or an empty string if prefixing is disabled.
     """
-    return interactions["reactions"] or interactions["replies"]
+    matrix_config = config.get(CONFIG_SECTION_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
@@ -91,7 +318,7 @@ matrix_access_token = None
 bot_user_id = None
 bot_user_name = None  # Detected upon logon
 bot_start_time = int(
-    time.time() * 1000
+    time.time() * MILLISECONDS_PER_SECOND
 )  # Timestamp when the bot starts, used to filter out old messages
 
 logger = get_logger(name="Matrix")
@@ -136,11 +363,9 @@ def bot_command(command, event):
 
 async def connect_matrix(passed_config=None):
     """
-    Establish a connection to the Matrix homeserver.
-    Sets global matrix_client and detects the bot's display name.
+    Asynchronously connects to the Matrix homeserver, initializes the Matrix client, and retrieves the bot's device ID and display name.
 
-    Args:
-        passed_config: The configuration dictionary to use (will update global config)
+    If a configuration dictionary is provided, it updates the global configuration before connecting. Returns the initialized Matrix AsyncClient instance, or `None` if configuration is missing. Raises `ConnectionError` if SSL context creation fails.
     """
     global matrix_client, bot_user_name, matrix_homeserver, matrix_rooms, matrix_access_token, bot_user_id, config
 
@@ -154,9 +379,9 @@ async def connect_matrix(passed_config=None):
         return None
 
     # Extract Matrix configuration
-    matrix_homeserver = config["matrix"]["homeserver"]
+    matrix_homeserver = config[CONFIG_SECTION_MATRIX][CONFIG_KEY_HOMESERVER]
     matrix_rooms = config["matrix_rooms"]
-    matrix_access_token = config["matrix"]["access_token"]
+    matrix_access_token = config[CONFIG_SECTION_MATRIX][CONFIG_KEY_ACCESS_TOKEN]
     bot_user_id = config["matrix"]["bot_user_id"]
 
     # Check if client already exists
@@ -164,7 +389,11 @@ async def connect_matrix(passed_config=None):
         return matrix_client
 
     # Create SSL context using certifi's certificates
-    ssl_context = ssl.create_default_context(cafile=certifi.where())
+    try:
+        ssl_context = ssl.create_default_context(cafile=certifi.where())
+    except Exception as e:
+        logger.error(f"Failed to create SSL context: {e}")
+        raise ConnectionError(f"SSL context creation failed: {e}") from e
 
     # Initialize the Matrix client with custom SSL context
     client_config = AsyncClientConfig(encryption_enabled=False)
@@ -251,9 +480,9 @@ async def matrix_relay(
     reply_to_event_id=None,
 ):
     """
-    Relays a message from Meshtastic to a Matrix room, supporting replies and message mapping for interactions.
+    Relay a message from the Meshtastic network to a Matrix room, supporting replies, emotes, emoji reactions, and message mapping for future interactions.
 
-    If `reply_to_event_id` is provided, sends the message as a Matrix reply, formatting the content to include quoted original text and appropriate Matrix reply relations. When message interactions (reactions or replies) are enabled in the configuration, stores a mapping between the Meshtastic message ID and the resulting Matrix event ID to enable cross-referencing for future interactions. Prunes old message mappings based on configuration to limit storage.
+    If a reply target is specified, formats the message as a Matrix reply with quoted original content. When message interactions (reactions or replies) are enabled, stores a mapping between the Meshtastic message ID and the resulting Matrix event ID to support cross-network interactions. Prunes old message mappings according to configuration to limit storage.
 
     Parameters:
         room_id (str): The Matrix room ID to send the message to.
@@ -268,9 +497,6 @@ async def matrix_relay(
         emote (bool, optional): Whether to send the message as an emote.
         emoji (bool, optional): Whether the message is an emoji reaction.
         reply_to_event_id (str, optional): The Matrix event ID being replied to, if sending a reply.
-
-    Returns:
-        None
     """
     global config
 
@@ -304,8 +530,8 @@ async def matrix_relay(
                 "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
-    )  # Default is 500 if not specified
+        "msgs_to_keep", DEFAULT_MSGS_TO_KEEP
+    )  # Default from constants
 
     try:
         # Always use our own local meshnet_name for outgoing events
@@ -459,7 +685,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 +698,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 +718,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 +811,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 +837,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 +865,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.
+    Asynchronously handles 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.
+    Processes Matrix events—including text messages, reactions, and replies—in configured rooms. Relays supported messages to the Meshtastic mesh network if broadcasting is enabled, applying message mapping for cross-referencing when reactions or replies are enabled. Ignores messages from the bot itself, messages sent before the bot started, and reactions to reactions. Integrates with plugins for command and message handling; only messages not handled by plugins or identified as commands are forwarded to Meshtastic, with appropriate formatting and truncation. Handles special cases for relaying messages and reactions from remote mesh networks and detection sensor data.
     """
     # 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 +1017,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 +1060,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 +1090,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 +1116,7 @@ async def on_room_message(
             room_config,
             storage_enabled,
             local_meshnet_name,
+            config,
         )
         if reply_handled:
             return
@@ -893,10 +1133,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 +1160,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)
@@ -968,26 +1217,34 @@ async def on_room_message(
     if not found_matching_plugin:
         if config["meshtastic"]["broadcast_enabled"]:
             portnum = event.source["content"].get("meshtastic_portnum")
-            if portnum == "DETECTION_SENSOR_APP":
+            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 +1252,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."