mmrelay 1.2.0__py3-none-any.whl → 1.2.1__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.0"
+__version__ = "1.2.1"

mmrelay/cli.py

@@ -7,6 +7,7 @@ import importlib.resources
 import os
 import shutil
 import sys
+from collections.abc import Mapping
 
 # Import version from package
 from mmrelay import __version__
@@ -141,11 +142,24 @@ def parse_arguments():
     auth_subparsers = auth_parser.add_subparsers(
         dest="auth_command", help="Auth commands"
     )
-    auth_subparsers.add_parser(
+    login_parser = auth_subparsers.add_parser(
         "login",
         help="Authenticate with Matrix",
         description="Set up Matrix authentication for E2EE support",
     )
+    login_parser.add_argument(
+        "--homeserver",
+        help="Matrix homeserver URL (e.g., https://matrix.org). If provided, --username and --password are also required.",
+    )
+    login_parser.add_argument(
+        "--username",
+        help="Matrix username (with or without @ and :server). If provided, --homeserver and --password are also required.",
+    )
+    login_parser.add_argument(
+        "--password",
+        metavar="PWD",
+        help="Matrix password (can be empty). If provided, --homeserver and --username are also required. For security, prefer interactive mode.",
+    )
 
     auth_subparsers.add_parser(
         "status",
@@ -189,9 +203,10 @@ def parse_arguments():
 
     # Use parse_known_args to handle unknown arguments gracefully (e.g., pytest args)
     args, unknown = parser.parse_known_args()
-    # If there are unknown arguments and we're not in a test environment, warn about them
-    if unknown and not any("pytest" in arg or "test" in arg for arg in sys.argv):
-        print(f"Warning: Unknown arguments ignored: {unknown}")
+    # If there are unknown arguments and we're not in a test invocation, warn about them
+    # Heuristic: suppress warning when pytest appears in argv (unit tests may pass extra args)
+    if unknown and not any("pytest" in arg or "py.test" in arg for arg in sys.argv):
+        print(f"Warning: Unknown arguments ignored: {unknown}", file=sys.stderr)
 
     return args
 
@@ -246,35 +261,26 @@ def _validate_e2ee_dependencies():
 
 def _validate_credentials_json(config_path):
     """
-    Validate that a credentials.json file exists next to the given config and contains the required Matrix authentication fields.
+    Validate that a credentials.json file exists (adjacent to config_path or in the base directory) and contains the required Matrix session fields.
 
-    Searches for credentials.json in the same directory as config_path, then falls back to the application's base directory. If found, the file is parsed as JSON and must include non-empty values for: "homeserver", "access_token", "user_id", and "device_id".
+    Checks for a credentials.json via _find_credentials_json_path(config_path). If found, the file is parsed as JSON and must include non-empty string values for the keys "homeserver", "access_token", "user_id", and "device_id". On validation failure the function prints a brief error and guidance to run the auth login flow.
 
     Parameters:
         config_path (str): Path to the configuration file used to determine the primary search directory for credentials.json.
 
     Returns:
-        bool: True if a valid credentials.json was found and contains all required fields; False otherwise. When invalid or missing fields are detected the function prints a short error and guidance to run the auth login flow.
+        bool: True if a credentials.json was found and contains all required non-empty fields; False otherwise.
     """
     try:
         import json
 
-        # Look for credentials.json in the same directory as the config file
-        config_dir = os.path.dirname(config_path)
-        credentials_path = os.path.join(config_dir, "credentials.json")
-
-        if not os.path.exists(credentials_path):
-            # Also try the standard location
-            from mmrelay.config import get_base_dir
-
-            standard_credentials_path = os.path.join(get_base_dir(), "credentials.json")
-            if os.path.exists(standard_credentials_path):
-                credentials_path = standard_credentials_path
-            else:
-                return False
+        # Look for credentials.json using helper function
+        credentials_path = _find_credentials_json_path(config_path)
+        if not credentials_path:
+            return False
 
         # Load and validate credentials
-        with open(credentials_path, "r") as f:
+        with open(credentials_path, "r", encoding="utf-8") as f:
             credentials = json.load(f)
 
         # Check for required fields
@@ -282,7 +288,7 @@ def _validate_credentials_json(config_path):
         missing_fields = [
             field
             for field in required_fields
-            if field not in credentials or not credentials[field]
+            if not _is_valid_non_empty_string((credentials or {}).get(field))
         ]
 
         if missing_fields:
@@ -298,6 +304,52 @@ def _validate_credentials_json(config_path):
         return False
 
 
+def _is_valid_non_empty_string(value) -> bool:
+    """
+    Return True if value is a string containing non-whitespace characters.
+
+    Checks that the input is an instance of `str` and that stripping whitespace
+    does not produce an empty string.
+
+    Returns:
+        bool: True when value is a non-empty, non-whitespace-only string; otherwise False.
+    """
+    return isinstance(value, str) and value.strip() != ""
+
+
+def _has_valid_password_auth(matrix_section):
+    """
+    Return True if the given Matrix config section contains valid password-based authentication settings.
+
+    The function expects matrix_section to be a dict-like mapping from configuration keys to values.
+    It validates that:
+    - `homeserver` and `bot_user_id` are present and are non-empty strings (after trimming),
+    - `password` is present and is a string (it may be an empty string, which is accepted).
+
+    If matrix_section is not a dict, the function returns False.
+
+    Parameters:
+        matrix_section: dict-like Matrix configuration section (may be the parsed "matrix" config).
+
+    Returns:
+        bool: True when password-based authentication is correctly configured as described above; otherwise False.
+    """
+    if not isinstance(matrix_section, Mapping):
+        return False
+
+    pwd = matrix_section.get("password")
+    homeserver = matrix_section.get(CONFIG_KEY_HOMESERVER)
+    bot_user_id = matrix_section.get(CONFIG_KEY_BOT_USER_ID)
+
+    # Allow empty password strings (some environments legitimately use empty passwords).
+    # Homeserver and bot_user_id must still be valid non-empty strings.
+    return (
+        isinstance(pwd, str)
+        and _is_valid_non_empty_string(homeserver)
+        and _is_valid_non_empty_string(bot_user_id)
+    )
+
+
 def _validate_matrix_authentication(config_path, matrix_section):
     """
     Determine whether Matrix authentication is configured and usable.
@@ -323,7 +375,10 @@ def _validate_matrix_authentication(config_path, matrix_section):
           and whether E2EE support is available.
     """
     has_valid_credentials = _validate_credentials_json(config_path)
-    has_access_token = matrix_section and "access_token" in matrix_section
+    token = (matrix_section or {}).get(CONFIG_KEY_ACCESS_TOKEN)
+    has_access_token = _is_valid_non_empty_string(token)
+
+    has_password = _has_valid_password_auth(matrix_section)
 
     if has_valid_credentials:
         print("✅ Using credentials.json for Matrix authentication")
@@ -331,8 +386,16 @@ def _validate_matrix_authentication(config_path, matrix_section):
             print("   E2EE support available (if enabled)")
         return True
 
+    elif has_password:
+        print(
+            "✅ Using password in config for initial authentication (credentials.json will be created on first run)"
+        )
+        print(f"   {msg_for_e2ee_support()}")
+        return True
     elif has_access_token:
-        print("✅ Using access_token for Matrix authentication")
+        print(
+            "✅ Using access_token for Matrix authentication (deprecated — consider 'mmrelay auth login' to create credentials.json)"
+        )
         print(f"   {msg_for_e2ee_support()}")
         return True
 
@@ -388,7 +451,7 @@ def _validate_e2ee_config(config, matrix_section, config_path):
         )
         if store_path:
             expanded_path = os.path.expanduser(store_path)
-            if not os.path.exists(os.path.dirname(expanded_path)):
+            if not os.path.exists(expanded_path):
                 print(f"ℹ️  Note: E2EE store directory will be created: {expanded_path}")
 
         print("✅ E2EE configuration is valid")
@@ -470,19 +533,9 @@ def _analyze_e2ee_setup(config, config_path):
             "Enable E2EE in config.yaml under matrix section: e2ee: enabled: true"
         )
 
-    # Check credentials (same logic as _validate_credentials_json)
-    config_dir = os.path.dirname(config_path)
-    credentials_path = os.path.join(config_dir, "credentials.json")
-
-    if not os.path.exists(credentials_path):
-        # Also try the standard location
-        from mmrelay.config import get_base_dir
-
-        standard_credentials_path = os.path.join(get_base_dir(), "credentials.json")
-        if os.path.exists(standard_credentials_path):
-            credentials_path = standard_credentials_path
-
-    analysis["credentials_available"] = os.path.exists(credentials_path)
+    # Check credentials file existence
+    credentials_path = _find_credentials_json_path(config_path)
+    analysis["credentials_available"] = bool(credentials_path)
 
     if not analysis["credentials_available"]:
         analysis["recommendations"].append(
@@ -506,54 +559,89 @@ def _analyze_e2ee_setup(config, config_path):
     return analysis
 
 
+def _find_credentials_json_path(config_path: str | None) -> str | None:
+    """
+    Return the filesystem path to a credentials.json file if one can be found, otherwise None.
+
+    Search order:
+    1. A credentials.json file located in the same directory as the provided config_path.
+    2. A credentials.json file in the application's base directory (get_base_dir()).
+
+    Parameters:
+        config_path (str | None): Path to the configuration file used to derive the adjacent credentials.json location.
+
+    Returns:
+        str | None: Absolute path to the discovered credentials.json, or None if no file is found.
+    """
+    if not config_path:
+        from mmrelay.config import get_base_dir
+
+        standard = os.path.join(get_base_dir(), "credentials.json")
+        return standard if os.path.exists(standard) else None
+
+    config_dir = os.path.dirname(config_path)
+    candidate = os.path.join(config_dir, "credentials.json")
+    if os.path.exists(candidate):
+        return candidate
+    from mmrelay.config import get_base_dir
+
+    standard = os.path.join(get_base_dir(), "credentials.json")
+    return standard if os.path.exists(standard) else None
+
+
 def _print_unified_e2ee_analysis(e2ee_status):
     """
-    Print a concise, user-facing analysis of E2EE readiness from a centralized status object.
+    Print a concise, user-facing analysis of E2EE readiness.
 
-    This formats and prints the platform support, dependency availability, configuration enabled state,
-    authentication (credentials.json) presence, and the overall status. If the overall status is not
-    "ready", prints actionable fix instructions obtained from mmrelay.e2ee_utils.get_e2ee_fix_instructions.
+    Given a status dictionary produced by the E2EE analysis routines, prints platform support,
+    dependency availability, whether E2EE is enabled in configuration, whether credentials.json
+    is available, and the overall status. If the overall status is not "ready", prints actionable
+    fix instructions.
 
     Parameters:
-        e2ee_status (dict): Status dictionary as returned by get_e2ee_status(config, config_path).
-            Expected keys:
-                - platform_supported (bool)
-                - dependencies_installed (bool)
-                - enabled (bool)
-                - credentials_available (bool)
-                - overall_status (str)
+        e2ee_status (dict): Status dictionary with (at least) the following keys:
+            - platform_supported (bool): whether the current OS/platform supports E2EE.
+            - dependencies_installed or dependencies_available (bool): whether required E2EE
+              Python packages and runtime dependencies are present.
+            - enabled or config_enabled (bool): whether E2EE is enabled in the configuration.
+            - credentials_available (bool): whether a usable credentials.json is present.
+            - overall_status (str): high-level status ("ready", "disabled", "incomplete", etc.).
     """
     print("\n🔐 E2EE Configuration Analysis:")
 
     # Platform support
-    if e2ee_status["platform_supported"]:
+    if e2ee_status.get("platform_supported", True):
         print("✅ Platform: E2EE supported")
     else:
         print("❌ Platform: E2EE not supported on Windows")
 
     # Dependencies
-    if e2ee_status["dependencies_installed"]:
+    if e2ee_status.get(
+        "dependencies_installed", e2ee_status.get("dependencies_available", False)
+    ):
         print("✅ Dependencies: E2EE dependencies installed")
     else:
         print("❌ Dependencies: E2EE dependencies not fully installed")
 
     # Configuration
-    if e2ee_status["enabled"]:
+    if e2ee_status.get("enabled", e2ee_status.get("config_enabled", False)):
         print("✅ Configuration: E2EE enabled")
     else:
         print("❌ Configuration: E2EE disabled")
 
     # Authentication
-    if e2ee_status["credentials_available"]:
+    if e2ee_status.get("credentials_available", False):
         print("✅ Authentication: credentials.json found")
     else:
         print("❌ Authentication: credentials.json not found")
 
     # Overall status
-    print(f"\n📊 Overall Status: {e2ee_status['overall_status'].upper()}")
+    print(
+        f"\n📊 Overall Status: {e2ee_status.get('overall_status', 'unknown').upper()}"
+    )
 
     # Show fix instructions if needed
-    if e2ee_status["overall_status"] != "ready":
+    if e2ee_status.get("overall_status") != "ready":
         from mmrelay.e2ee_utils import get_e2ee_fix_instructions
 
         instructions = get_e2ee_fix_instructions(e2ee_status)
@@ -686,13 +774,13 @@ def check_config(args=None):
     - Locates the first existing config file from get_config_paths(args) (parses CLI args if args is None).
     - Verifies YAML syntax and reports syntax errors or style warnings.
     - Ensures the config is non-empty.
-    - Validates Matrix authentication: accepts credentials supplied via credentials.json or requires a matrix section with homeserver, access_token, and bot_user_id when credentials.json is absent.
+    - Validates Matrix authentication: accepts credentials supplied via credentials.json or requires a matrix section with homeserver and bot_user_id plus either access_token or password when credentials.json is absent.
     - Validates end-to-end-encryption (E2EE) configuration and dependencies.
     - Ensures matrix_rooms exists, is a non-empty list, and each room is a dict containing an id.
     - Validates the meshtastic section: requires connection_type and the connection-specific fields (serial_port for serial, host for tcp/network, ble_address for ble). Warns about deprecated connection types.
     - Validates optional meshtastic fields and types (broadcast_enabled, detection_sensor, message_delay >= 2.0, meshnet_name) and reports missing optional settings as guidance.
     - Warns if a deprecated db section is present.
-    - Prints a short environment summary on success.
+    - Prints a unified E2EE analysis summary on success.
 
     Side effects:
     - Prints errors, warnings, and status messages to stdout.
@@ -748,6 +836,9 @@ def check_config(args=None):
                         # Create empty matrix section if missing - no fields required
                         config[CONFIG_SECTION_MATRIX] = {}
                     matrix_section = config[CONFIG_SECTION_MATRIX]
+                    if not isinstance(matrix_section, dict):
+                        print("Error: 'matrix' section must be a mapping (YAML object)")
+                        return False
                     required_matrix_fields = (
                         []
                     )  # No fields required from config when using credentials.json
@@ -756,22 +847,37 @@ def check_config(args=None):
                     if CONFIG_SECTION_MATRIX not in config:
                         print("Error: Missing 'matrix' section in config")
                         print(
-                            "   Either add matrix section with access_token and bot_user_id,"
+                            "   Either add matrix section with access_token or password and bot_user_id,"
                         )
                         print(f"   {msg_or_run_auth_login()}")
                         return False
 
                     matrix_section = config[CONFIG_SECTION_MATRIX]
+                    if not isinstance(matrix_section, dict):
+                        print("Error: 'matrix' section must be a mapping (YAML object)")
+                        return False
+
                     required_matrix_fields = [
                         CONFIG_KEY_HOMESERVER,
-                        CONFIG_KEY_ACCESS_TOKEN,
                         CONFIG_KEY_BOT_USER_ID,
                     ]
+                    token = matrix_section.get(CONFIG_KEY_ACCESS_TOKEN)
+                    pwd = matrix_section.get("password")
+                    has_token = _is_valid_non_empty_string(token)
+                    # Allow explicitly empty password strings; require the value to be a string
+                    # (reject unquoted numeric types)
+                    has_password = isinstance(pwd, str)
+                    if not (has_token or has_password):
+                        print(
+                            "Error: Missing authentication in 'matrix' section: provide 'access_token' or 'password'"
+                        )
+                        print(f"   {msg_or_run_auth_login()}")
+                        return False
 
                 missing_matrix_fields = [
                     field
                     for field in required_matrix_fields
-                    if field not in matrix_section
+                    if not _is_valid_non_empty_string(matrix_section.get(field))
                 ]
 
                 if missing_matrix_fields:
@@ -1096,24 +1202,78 @@ def handle_auth_command(args):
 
 def handle_auth_login(args):
     """
-    Run the interactive Matrix bot login flow and return a CLI-style exit code.
+    Run the Matrix bot login flow and return a CLI-style exit code.
 
-    Runs the login_matrix_bot coroutine to perform authentication for the Matrix/E2EE bot and prints a short header. Returns 0 on successful authentication; returns 1 if the login fails, is cancelled by the user (KeyboardInterrupt), or an unexpected error occurs.
+    Performs Matrix bot authentication either interactively (prompts the user) or non-interactively
+    when all three parameters (--homeserver, --username, --password) are provided on the command line.
+    For non-interactive mode, --homeserver and --username must be non-empty strings; --password may be
+    an empty string (some flows will prompt). Supplying some but not all of the three parameters
+    is treated as an error and the function exits with a non-zero status.
+
+    Returns:
+        int: 0 on successful authentication, 1 on failure, cancellation (KeyboardInterrupt), or unexpected errors.
 
     Parameters:
-        args: Parsed command-line arguments (not used by this handler).
+        args: Parsed CLI namespace; may contain attributes `homeserver`, `username`, and `password`.
     """
     import asyncio
 
     from mmrelay.matrix_utils import login_matrix_bot
 
-    # Show header
-    print("Matrix Bot Authentication for E2EE")
-    print("===================================")
+    # Extract arguments
+    homeserver = getattr(args, "homeserver", None)
+    username = getattr(args, "username", None)
+    password = getattr(args, "password", None)
+
+    # Count provided parameters (empty strings count as provided)
+    provided_params = [p for p in [homeserver, username, password] if p is not None]
+
+    # Determine mode based on parameters provided
+    if len(provided_params) == 3:
+        # All parameters provided - validate required non-empty fields
+        if not _is_valid_non_empty_string(homeserver) or not _is_valid_non_empty_string(
+            username
+        ):
+            print(
+                "❌ Error: --homeserver and --username must be non-empty for non-interactive login."
+            )
+            return 1
+        # Password may be empty (flows may prompt)
+    elif len(provided_params) > 0:
+        # Some but not all parameters provided - show error
+        missing_params = []
+        if homeserver is None:
+            missing_params.append("--homeserver")
+        if username is None:
+            missing_params.append("--username")
+        if password is None:
+            missing_params.append("--password")
+
+        error_message = f"""❌ Error: All authentication parameters are required when using command-line options.
+   Missing: {', '.join(missing_params)}
+
+💡 Options:
+   • For secure interactive authentication: mmrelay auth login
+   • For automated authentication: provide all three parameters
+
+⚠️  Security Note: Command-line passwords may be visible in process lists and shell history.
+   Interactive mode is recommended for manual use."""
+        print(error_message)
+        return 1
+    else:
+        # No parameters provided - run in interactive mode
+        print("Matrix Bot Authentication for E2EE")
+        print("===================================")
 
     try:
-        # For now, use the existing login function
-        result = asyncio.run(login_matrix_bot())
+        result = asyncio.run(
+            login_matrix_bot(
+                homeserver=homeserver,
+                username=username,
+                password=password,
+                logout_others=False,
+            )
+        )
         return 0 if result else 1
     except KeyboardInterrupt:
         print("\nAuthentication cancelled by user.")
@@ -1125,38 +1285,66 @@ def handle_auth_login(args):
 
 def handle_auth_status(args):
     """
-    Show Matrix authentication status by locating and reading a credentials.json file.
+    Print the Matrix authentication status by locating and reading a credentials.json file.
 
-    Searches candidate config directories derived from the provided parsed-arguments namespace for a credentials.json file. If found and readable, prints the file path and the homeserver, user_id, and device_id values. If the file is unreadable or not found, prints guidance to run the authentication flow.
+    Searches for credentials.json next to each discovered config file (in preference order),
+    then falls back to the application's base directory. If a readable credentials.json is
+    found, prints its path and the homeserver, user_id, and device_id values.
 
     Parameters:
-        args (argparse.Namespace): Parsed CLI arguments used to determine the list of config paths to search.
+        args: argparse.Namespace
+            Parsed CLI arguments (used to locate config file paths).
 
     Returns:
-        int: Exit code — 0 if a readable credentials.json was found, 1 otherwise.
+        int: Exit code — 0 if a valid credentials.json was found and read, 1 otherwise.
+
+    Side effects:
+        Writes human-readable status messages to stdout.
     """
     import json
-    import os
 
-    from mmrelay.config import get_config_paths
+    from mmrelay.config import get_base_dir, get_config_paths
 
     print("Matrix Authentication Status")
     print("============================")
 
-    # Check for credentials.json
     config_paths = get_config_paths(args)
-    for config_path in config_paths:
-        config_dir = os.path.dirname(config_path)
-        credentials_path = os.path.join(config_dir, "credentials.json")
+
+    # Developer note: Build a de-duplicated sequence of candidate locations,
+    # preserving preference order: each config-adjacent credentials.json first,
+    # then the standard base-dir fallback.
+    seen = set()
+    candidate_paths = []
+    for p in (
+        os.path.join(os.path.dirname(cp), "credentials.json") for cp in config_paths
+    ):
+        if p not in seen:
+            candidate_paths.append(p)
+            seen.add(p)
+    base_candidate = os.path.join(get_base_dir(), "credentials.json")
+    if base_candidate not in seen:
+        candidate_paths.append(base_candidate)
+
+    for credentials_path in candidate_paths:
         if os.path.exists(credentials_path):
             try:
-                with open(credentials_path, "r") as f:
+                with open(credentials_path, "r", encoding="utf-8") as f:
                     credentials = json.load(f)
 
+                required = ("homeserver", "access_token", "user_id", "device_id")
+                if not all(
+                    isinstance(credentials.get(k), str) and credentials.get(k).strip()
+                    for k in required
+                ):
+                    print(
+                        f"❌ Error: credentials.json at {credentials_path} is missing required fields"
+                    )
+                    print(f"Run '{get_command('auth_login')}' to authenticate")
+                    return 1
                 print(f"✅ Found credentials.json at: {credentials_path}")
-                print(f"   Homeserver: {credentials.get('homeserver', 'Unknown')}")
-                print(f"   User ID: {credentials.get('user_id', 'Unknown')}")
-                print(f"   Device ID: {credentials.get('device_id', 'Unknown')}")
+                print(f"   Homeserver: {credentials.get('homeserver')}")
+                print(f"   User ID: {credentials.get('user_id')}")
+                print(f"   Device ID: {credentials.get('device_id')}")
                 return 0
             except Exception as e:
                 print(f"❌ Error reading credentials.json: {e}")
@@ -1169,15 +1357,21 @@ def handle_auth_status(args):
 
 def handle_auth_logout(args):
     """
-    Log out the bot from Matrix and remove local session artifacts.
+    Log out the Matrix bot and remove local session artifacts.
 
-    Prompts for a verification password (unless provided via args.password), warns if the password was supplied on the command line, asks for confirmation unless args.yes is True, and then performs the logout by calling the logout_matrix_bot routine. On success the function returns 0; on failure or cancellation it returns 1. KeyboardInterrupt is treated as a cancellation and returns 1.
+    Prompts for a verification password (unless a non-empty password is provided via args.password),
+    optionally asks for interactive confirmation (skipped if args.yes is True), and attempts to clear
+    local session data (credentials, E2EE store) and invalidate the bot's access token.
 
     Parameters:
-        args (argparse.Namespace): CLI arguments. Relevant attributes:
-            password (str | None): If provided and non-empty, used as the verification password.
-                If provided as an empty string or omitted, the function will prompt securely.
-            yes (bool): If True, skip the interactive confirmation prompt.
+        args (argparse.Namespace): CLI arguments with the following relevant attributes:
+            password (str | None): If a non-empty string is provided, it will be used as the
+                verification password. If None or an empty string, the function prompts securely.
+            yes (bool): If True, skip the confirmation prompt.
+
+    Returns:
+        int: 0 on successful logout, 1 on failure or if the operation is cancelled (including
+             KeyboardInterrupt).
     """
     import asyncio
 
@@ -1197,7 +1391,11 @@ def handle_auth_logout(args):
         # Handle password input
         password = getattr(args, "password", None)
 
-        if password is None or password == "":
+        if (
+            password is None
+            or password
+            == ""  # nosec B105 (user-entered secret; prompting securely via getpass)
+        ):
             # No --password flag or --password with no value, prompt securely
             import getpass
 

mmrelay/message_queue.py

@@ -7,10 +7,13 @@ rate, respecting connection state and firmware constraints.
 """
 
 import asyncio
+import contextlib
 import threading
 import time
+from concurrent.futures import ThreadPoolExecutor
 from dataclasses import dataclass
-from queue import Empty, Queue
+from functools import partial
+from queue import Empty, Full, Queue
 from typing import Callable, Optional
 
 from mmrelay.constants.database import DEFAULT_MSGS_TO_KEEP
@@ -50,20 +53,40 @@ class MessageQueue:
 
     def __init__(self):
         """
-        Initialize the MessageQueue with an empty queue, state variables, and a thread lock for safe operation.
+        Create a new MessageQueue, initializing its internal queue, timing and state variables, and a thread lock.
+
+        Attributes:
+            _queue (Queue): Bounded FIFO holding queued messages (maxsize=MAX_QUEUE_SIZE).
+            _processor_task (Optional[asyncio.Task]): Async task that processes the queue, created when started.
+            _running (bool): Whether the processor is active.
+            _lock (threading.Lock): Protects start/stop and other state transitions.
+            _last_send_time (float): Wall-clock timestamp of the last successful send.
+            _last_send_mono (float): Monotonic timestamp of the last successful send (used for rate limiting).
+            _message_delay (float): Minimum delay between sends; starts at DEFAULT_MESSAGE_DELAY and may be adjusted.
+            _executor (Optional[concurrent.futures.ThreadPoolExecutor]): Dedicated single-worker executor for blocking send operations (created on start).
+            _in_flight (bool): True while a message send is actively running in the executor.
+            _has_current (bool): True when there is a current message being processed (even if not yet dispatched to the executor).
         """
-        self._queue = Queue()
+        self._queue = Queue(maxsize=MAX_QUEUE_SIZE)
         self._processor_task = None
         self._running = False
         self._lock = threading.Lock()
         self._last_send_time = 0.0
+        self._last_send_mono = 0.0
         self._message_delay = DEFAULT_MESSAGE_DELAY
+        self._executor = None  # Dedicated ThreadPoolExecutor for this MessageQueue
+        self._in_flight = False
+        self._has_current = False
+        self._dropped_messages = 0
 
     def start(self, message_delay: float = DEFAULT_MESSAGE_DELAY):
         """
-        Start the message queue processor with a specified minimum delay between messages.
+        Activate the message queue processor with a minimum inter-message delay.
 
-        If the provided delay is below the firmware-enforced minimum, the minimum is used instead. The processor task is started immediately if the asyncio event loop is running; otherwise, startup is deferred until the event loop becomes available.
+        Enables processing, sets the configured message delay (raised to MINIMUM_MESSAGE_DELAY if a smaller value is provided), creates a dedicated ThreadPoolExecutor for send operations if one does not exist, and starts the asyncio processor task immediately when a running event loop is available; if no running loop is available startup is deferred until a loop is present.
+
+        Parameters:
+            message_delay (float): Requested minimum delay between sends, in seconds. Values below MINIMUM_MESSAGE_DELAY are replaced with MINIMUM_MESSAGE_DELAY.
         """
         with self._lock:
             if self._running:
@@ -79,10 +102,19 @@ class MessageQueue:
                 self._message_delay = message_delay
             self._running = True
 
+            # Create dedicated executor for this MessageQueue
+            if self._executor is None:
+                self._executor = ThreadPoolExecutor(
+                    max_workers=1, thread_name_prefix=f"MessageQueue-{id(self)}"
+                )
+
             # Start the processor in the event loop
             try:
-                loop = asyncio.get_event_loop()
-                if loop.is_running():
+                try:
+                    loop = asyncio.get_running_loop()
+                except RuntimeError:
+                    loop = None
+                if loop and loop.is_running():
                     self._processor_task = loop.create_task(self._process_queue())
                     logger.info(
                         f"Message queue started with {self._message_delay}s message delay"
@@ -100,7 +132,14 @@ class MessageQueue:
 
     def stop(self):
         """
-        Stops the message queue processor and cancels the processing task if active.
+        Stop the message queue processor and clean up internal resources.
+
+        Cancels the background processor task (if running) and attempts to wait for it to finish on the task's owning event loop without blocking the caller's event loop. Shuts down the dedicated ThreadPoolExecutor used for blocking I/O; when called from an asyncio event loop the executor shutdown is performed on a background thread to avoid blocking. Clears internal state flags and resources so the queue can be restarted later.
+
+        Notes:
+        - This method is thread-safe.
+        - It may block briefly (the implementation waits up to ~1 second when awaiting task completion) but will avoid blocking the current asyncio event loop when possible.
+        - No exceptions are propagated for normal cancellation/shutdown paths; internal exceptions during shutdown are suppressed.
         """
         with self._lock:
             if not self._running:
@@ -110,8 +149,64 @@ class MessageQueue:
 
             if self._processor_task:
                 self._processor_task.cancel()
+
+                # Wait for the task to complete on its owning loop
+                task_loop = self._processor_task.get_loop()
+                current_loop = None
+                with contextlib.suppress(RuntimeError):
+                    current_loop = asyncio.get_running_loop()
+                if task_loop.is_closed():
+                    # Owning loop is closed; nothing we can do to await it
+                    pass
+                elif current_loop is task_loop:
+                    # Avoid blocking the event loop thread; cancellation will finish naturally
+                    pass
+                elif task_loop.is_running():
+                    from asyncio import run_coroutine_threadsafe, shield
+
+                    with contextlib.suppress(Exception):
+                        fut = run_coroutine_threadsafe(
+                            shield(self._processor_task), task_loop
+                        )
+                        # Wait for completion; ignore exceptions raised due to cancellation
+                        fut.result(timeout=1.0)
+                else:
+                    with contextlib.suppress(
+                        asyncio.CancelledError, RuntimeError, Exception
+                    ):
+                        task_loop.run_until_complete(self._processor_task)
+
                 self._processor_task = None
 
+            # Shut down our dedicated executor without blocking the event loop
+            if self._executor:
+                on_loop_thread = False
+                with contextlib.suppress(RuntimeError):
+                    loop_chk = asyncio.get_running_loop()
+                    on_loop_thread = loop_chk.is_running()
+
+                def _shutdown(exec_ref):
+                    """
+                    Shut down an executor, waiting for running tasks to finish; falls back for executors that don't support `cancel_futures`.
+
+                    Attempts to call executor.shutdown(wait=True, cancel_futures=True) and, if that raises a TypeError (older Python versions or executors without the `cancel_futures` parameter), retries with executor.shutdown(wait=True). This call blocks until shutdown completes.
+                    """
+                    try:
+                        exec_ref.shutdown(wait=True, cancel_futures=True)
+                    except TypeError:
+                        exec_ref.shutdown(wait=True)
+
+                if on_loop_thread:
+                    threading.Thread(
+                        target=_shutdown,
+                        args=(self._executor,),
+                        name="MessageQueueExecutorShutdown",
+                        daemon=True,
+                    ).start()
+                else:
+                    _shutdown(self._executor)
+                self._executor = None
+
             logger.info("Message queue stopped")
 
     def enqueue(
@@ -119,18 +214,20 @@ class MessageQueue:
         send_function: Callable,
         *args,
         description: str = "",
-        mapping_info: dict = None,
+        mapping_info: Optional[dict] = None,
         **kwargs,
     ) -> bool:
         """
-        Adds a message to the queue for rate-limited, ordered sending.
+        Enqueue a message for ordered, rate-limited sending.
+
+        Ensures the queue processor is started (if an event loop is available) and attempts to add a QueuedMessage (containing the provided send function and its arguments) to the bounded in-memory queue. If the queue is not running or has reached capacity the message is not added and the method returns False. Optionally attach mapping_info metadata (used later to correlate sent messages with external IDs).
 
         Parameters:
-            send_function (Callable): The function to call to send the message.
-            *args: Positional arguments for the send function.
-            description (str, optional): Human-readable description for logging purposes.
-            mapping_info (dict, optional): Optional metadata for message mapping (e.g., replies or reactions).
-            **kwargs: Keyword arguments for the send function.
+            send_function (Callable): Callable to execute when the message is sent.
+            *args: Positional arguments to pass to send_function.
+            description (str, optional): Human-readable description used for logging.
+            mapping_info (dict | None, optional): Optional metadata to record after a successful send.
+            **kwargs: Keyword arguments to pass to send_function.
 
         Returns:
             bool: True if the message was successfully enqueued; False if the queue is not running or is full.
@@ -142,16 +239,9 @@ class MessageQueue:
         with self._lock:
             if not self._running:
                 # Refuse to send to prevent blocking the event loop
-                logger.error(f"Queue not running, cannot send message: {description}")
                 logger.error(
-                    "Application is in invalid state - message queue should be started before sending messages"
-                )
-                return False
-
-            # Check queue size to prevent memory issues
-            if self._queue.qsize() >= MAX_QUEUE_SIZE:
-                logger.warning(
-                    f"Message queue full ({self._queue.qsize()}/{MAX_QUEUE_SIZE}), dropping message: {description}"
+                    "Queue not running; cannot send message: %s. Start the message queue before sending.",
+                    description,
                 )
                 return False
 
@@ -163,8 +253,15 @@ class MessageQueue:
                 description=description,
                 mapping_info=mapping_info,
             )
-
-            self._queue.put(message)
+            # Enforce capacity via bounded queue
+            try:
+                self._queue.put_nowait(message)
+            except Full:
+                logger.warning(
+                    f"Message queue full ({self._queue.qsize()}/{MAX_QUEUE_SIZE}), dropping message: {description}"
+                )
+                self._dropped_messages += 1
+                return False
             # Only log queue status when there are multiple messages
             queue_size = self._queue.qsize()
             if queue_size >= 2:
@@ -190,10 +287,21 @@ class MessageQueue:
 
     def get_status(self) -> dict:
         """
-        Return a dictionary with the current status of the message queue, including running state, queue size, message delay, processor activity, last send time, and time since last send.
+        Return current status of the message queue.
+
+        Provides a snapshot useful for monitoring and debugging.
 
         Returns:
-            dict: Status information about the message queue for debugging and monitoring.
+            dict: Mapping with the following keys:
+                - running (bool): Whether the queue processor is active.
+                - queue_size (int): Number of messages currently queued.
+                - message_delay (float): Configured minimum delay (seconds) between sends.
+                - processor_task_active (bool): True if the internal processor task exists and is not finished.
+                - last_send_time (float or None): Wall-clock time (seconds since the epoch) of the last successful send, or None if no send has occurred.
+                - time_since_last_send (float or None): Seconds elapsed since last_send_time, or None if no send has occurred.
+                - in_flight (bool): True when a message is currently being sent.
+                - dropped_messages (int): Number of messages dropped due to queue being full.
+                - default_msgs_to_keep (int): Default retention setting for message mappings.
         """
         return {
             "running": self._running,
@@ -203,10 +311,30 @@ class MessageQueue:
             and not self._processor_task.done(),
             "last_send_time": self._last_send_time,
             "time_since_last_send": (
-                time.time() - self._last_send_time if self._last_send_time > 0 else None
+                time.monotonic() - self._last_send_mono
+                if self._last_send_mono > 0
+                else None
             ),
+            "in_flight": self._in_flight,
+            "dropped_messages": getattr(self, "_dropped_messages", 0),
+            "default_msgs_to_keep": DEFAULT_MSGS_TO_KEEP,
         }
 
+    async def drain(self, timeout: Optional[float] = None) -> bool:
+        """
+        Asynchronously wait until the queue has fully drained (no queued messages and no in-flight or current message) or until an optional timeout elapses.
+
+        If `timeout` is provided, it is interpreted in seconds. Returns True when the queue is empty and there are no messages being processed; returns False if the queue was stopped before draining or the timeout was reached.
+        """
+        deadline = (time.monotonic() + timeout) if timeout is not None else None
+        while (not self._queue.empty()) or self._in_flight or self._has_current:
+            if not self._running:
+                return False
+            if deadline is not None and time.monotonic() > deadline:
+                return False
+            await asyncio.sleep(0.1)
+        return True
+
     def ensure_processor_started(self):
         """
         Start the queue processor task if the queue is running and no processor task exists.
@@ -216,15 +344,14 @@ class MessageQueue:
         with self._lock:
             if self._running and self._processor_task is None:
                 try:
-                    loop = asyncio.get_event_loop()
-                    if loop.is_running():
-                        self._processor_task = loop.create_task(self._process_queue())
-                        logger.info(
-                            f"Message queue processor started with {self._message_delay}s message delay"
-                        )
+                    loop = asyncio.get_running_loop()
                 except RuntimeError:
-                    # Still no event loop available
-                    pass
+                    loop = None
+                if loop and loop.is_running():
+                    self._processor_task = loop.create_task(self._process_queue())
+                    logger.info(
+                        f"Message queue processor started with {self._message_delay}s message delay"
+                    )
 
     async def _process_queue(self):
         """
@@ -253,6 +380,7 @@ class MessageQueue:
                     # Get next message (non-blocking)
                     try:
                         current_message = self._queue.get_nowait()
+                        self._has_current = True
                     except Empty:
                         # No messages, wait a bit and continue
                         await asyncio.sleep(0.1)
@@ -268,8 +396,8 @@ class MessageQueue:
                     continue
 
                 # Check if we need to wait for message delay (only if we've sent before)
-                if self._last_send_time > 0:
-                    time_since_last = time.time() - self._last_send_time
+                if self._last_send_mono > 0:
+                    time_since_last = time.monotonic() - self._last_send_mono
                     if time_since_last < self._message_delay:
                         wait_time = self._message_delay - time_since_last
                         logger.debug(
@@ -280,20 +408,27 @@ class MessageQueue:
 
                 # Send the message
                 try:
+                    self._in_flight = True
                     logger.debug(
                         f"Sending queued message: {current_message.description}"
                     )
                     # Run synchronous Meshtastic I/O operations in executor to prevent blocking event loop
-                    # Use lambda with default arguments to properly capture loop variables
-                    result = await asyncio.get_running_loop().run_in_executor(
-                        None,
-                        lambda msg=current_message: msg.send_function(
-                            *msg.args, **msg.kwargs
+                    loop = asyncio.get_running_loop()
+                    exec_ref = self._executor
+                    if exec_ref is None:
+                        raise RuntimeError("MessageQueue executor is not initialized")
+                    result = await loop.run_in_executor(
+                        exec_ref,
+                        partial(
+                            current_message.send_function,
+                            *current_message.args,
+                            **current_message.kwargs,
                         ),
                     )
 
                     # Update last send time
                     self._last_send_time = time.time()
+                    self._last_send_mono = time.monotonic()
 
                     if result is None:
                         logger.warning(
@@ -318,6 +453,8 @@ class MessageQueue:
                 # Mark task as done and clear current message
                 self._queue.task_done()
                 current_message = None
+                self._in_flight = False
+                self._has_current = False
 
             except asyncio.CancelledError:
                 logger.debug("Message queue processor cancelled")
@@ -325,6 +462,10 @@ class MessageQueue:
                     logger.warning(
                         f"Message in flight was dropped during shutdown: {current_message.description}"
                     )
+                    with contextlib.suppress(Exception):
+                        self._queue.task_done()
+                self._in_flight = False
+                self._has_current = False
                 break
             except Exception as e:
                 logger.error(f"Error in message queue processor: {e}")
@@ -332,10 +473,12 @@ class MessageQueue:
 
     def _should_send_message(self) -> bool:
         """
-        Determine whether it is currently safe to send a message based on Meshtastic client connection and reconnection state.
+        Return True if it's currently safe to send a message over Meshtastic.
 
-        Returns:
-            bool: True if the client is connected and not reconnecting; False otherwise.
+        Checks that the Meshtastic client exists, is connected (supports callable or boolean
+        `is_connected`), and that a global reconnection flag is not set. Returns False otherwise.
+        If importing meshtastic utilities raises ImportError, logs a critical error, starts a
+        background thread to stop this MessageQueue, and returns False.
         """
         # Import here to avoid circular imports
         try:
@@ -367,18 +510,26 @@ class MessageQueue:
             logger.critical(
                 f"Cannot import meshtastic_utils - serious application error: {e}. Stopping message queue."
             )
-            self.stop()
+            # Stop asynchronously to avoid blocking the event loop thread.
+            threading.Thread(
+                target=self.stop, name="MessageQueueStopper", daemon=True
+            ).start()
             return False
 
     def _handle_message_mapping(self, result, mapping_info):
         """
-        Update the message mapping database with information about a sent message and prune old mappings if configured.
+        Store a sent message's mapping (mesh ID → Matrix event) and prune old mappings according to retention settings.
 
-        Parameters:
-            result: The result object from the send function, expected to have an `id` attribute.
-            mapping_info (dict): Contains mapping details such as `matrix_event_id`, `room_id`, `text`, and optionally `meshnet` and `msgs_to_keep`.
+        If `mapping_info` contains the required keys (`matrix_event_id`, `room_id`, `text`), this will call the DB helpers to persist a mapping for `result.id` and then prune older mappings using `mapping_info["msgs_to_keep"]` if present (falls back to DEFAULT_MSGS_TO_KEEP).
 
-        If required mapping fields are present, stores the mapping and prunes old entries based on the specified or default retention count.
+        Parameters:
+            result: The send function's result object; must expose an `id` attribute (the mesh message id).
+            mapping_info: Dict supplying mapping fields:
+                - matrix_event_id (str): Matrix event id to associate with the mesh message.
+                - room_id (str): Matrix room id for the event.
+                - text (str): The message text to store in the mapping.
+                - meshnet (optional): Mesh network identifier passed to the store function.
+                - msgs_to_keep (optional, int): Number of mappings to retain; if > 0, prune older entries.
         """
         try:
             # Import here to avoid circular imports
@@ -442,7 +593,7 @@ def queue_message(
     send_function: Callable,
     *args,
     description: str = "",
-    mapping_info: dict = None,
+    mapping_info: Optional[dict] = None,
     **kwargs,
 ) -> bool:
     """

mmrelay/tools/sample_config.yaml

@@ -1,22 +1,23 @@
 matrix:
   homeserver: https://example.matrix.org
-  access_token: reaalllllyloooooongsecretttttcodeeeeeeforrrrbot # See: https://t2bot.io/docs/access_tokens/
+  # Modern authentication using password (recommended)
+  # MMRelay will automatically create secure credentials.json on startup
+  password: your_matrix_password_here  # Set your Matrix account password
+  # Security: After first successful start, remove this password from the file.
+  #           Linux/macOS: chmod 600 ~/.mmrelay/config.yaml
+  #           Windows: restrict file access to your user (e.g., via file Properties → Security)
+  #           Never commit this file with a password to version control.
   bot_user_id: "@botuser:example.matrix.org"
 
-  # Alternative: Automatic credentials creation (Docker-friendly)
-  # If you provide password instead of access_token, MMRelay will automatically
-  # create credentials.json on startup. Useful for Docker deployments.
-  #password: your_matrix_password_here  # Uncomment and set your Matrix password
-
   # End-to-End Encryption (E2EE) configuration
-  # NOTE: E2EE requires credentials.json instead of access_token for new sessions
+  # E2EE is automatically enabled when using password-based authentication AND E2EE dependencies are installed (Linux/macOS only)
+  # NOTE: E2EE is not available on Windows due to dependency limitations
   #
   # SETUP INSTRUCTIONS:
-  # 1. Install E2EE dependencies: pipx install 'mmrelay[e2e]'
-  # 2. Enable E2EE in config: uncomment and set enabled: true below
-  # 3. Create credentials: mmrelay auth login
-  # 4. The auth login command will create credentials.json with your Matrix login
-  # 5. Restart mmrelay - it will use credentials.json and enable E2EE automatically
+  # 1. Install E2EE dependencies: pipx install 'mmrelay[e2e]' (Linux/macOS only)
+  # 2. Set your password above and run MMRelay
+  # 3. MMRelay will automatically create credentials.json with E2EE support
+  # 4. For interactive setup, use: mmrelay auth login
   #
   #e2ee:
   #  # Optional: When credentials.json is present, MMRelay auto-enables E2EE.

{mmrelay-1.2.0.dist-info → mmrelay-1.2.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: mmrelay
-Version: 1.2.0
+Version: 1.2.1
 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
@@ -22,7 +22,7 @@ Requires-Dist: meshtastic>=2.6.4
 Requires-Dist: Pillow==11.3.0
 Requires-Dist: matrix-nio==0.25.2
 Requires-Dist: matplotlib==3.10.1
-Requires-Dist: requests==2.32.4
+Requires-Dist: requests==2.32.5
 Requires-Dist: markdown==3.8.2
 Requires-Dist: bleach==6.2.0
 Requires-Dist: haversine==2.9.0
@@ -69,16 +69,16 @@ A powerful and easy-to-use relay between Meshtastic devices and Matrix chat room
 - ✨️ _Native Docker support_ ✨️
 - 🔐 **Matrix End-to-End Encryption (E2EE) support** 🔐 **NEW in v1.2!**
 
-**MMRelay v1.2** introduces full **Matrix End-to-End Encryption** support for secure communication in encrypted rooms. Messages are automatically encrypted/decrypted when communicating with encrypted Matrix rooms, with simple setup using `mmrelay auth login` or automatic credentials creation from config.yaml.
+**MMRelay v1.2** introduces **Matrix End-to-End Encryption** support for secure communication in encrypted rooms. Messages are automatically encrypted/decrypted when communicating with encrypted Matrix rooms, with simple setup using `mmrelay auth login` or automatic credentials creation from config.yaml.
 
 ## Documentation
 
-Visit our [Wiki](https://github.com/jeremiah-k/meshtastic-matrix-relay/wiki) for comprehensive guides and information.
-
 MMRelay supports multiple deployment methods including Docker, pip installation, and standalone executables. For complete setup instructions and all deployment options, see:
 
 - [Installation Instructions](docs/INSTRUCTIONS.md) - Setup and configuration guide
 - [Docker Guide](docs/DOCKER.md) - Docker deployment methods
+- [What's New in v1.2](docs/WHATS_NEW_1.2.md) - New features and improvements
+- [E2EE Setup Guide](docs/E2EE.md) - Matrix End-to-End Encryption configuration
 
 ---
 

{mmrelay-1.2.0.dist-info → mmrelay-1.2.1.dist-info}/RECORD

@@ -1,5 +1,5 @@
-mmrelay/__init__.py,sha256=CcCX3oC0CS1MiZg2aWA5KXA2UXqYLXBT4GP3M07R-cs,120
-mmrelay/cli.py,sha256=LT_DVvhXFPCpGxU5RD4SxNNqtIJyVVD8bwMm9YSz2q8,55711
+mmrelay/__init__.py,sha256=U6f4invRZI32-C9f6TasN4-6DMO0rRUEryNFO1iO20Y,120
+mmrelay/cli.py,sha256=jfoUbvvRZ7q_axZN4y_SqIna1lVzlLz_7JNnvhCBuMk,63862
 mmrelay/cli_utils.py,sha256=z1TfgHM82NdTtO0toGyQrNdeB7F8khtzuLJYjvDG1j8,26380
 mmrelay/config.py,sha256=qajoYz_KCRWCw6ULAND0ysmHqw4Nbv_PjewNrW22O8o,32640
 mmrelay/db_utils.py,sha256=b_cuw4zOwGlvk4CljFh3SguqOi-TRCHW_s9RCt9gUsU,19920
@@ -8,7 +8,7 @@ mmrelay/log_utils.py,sha256=6O-dvt9K5uT89XkA74gcYYQJ5lADAk5U9IVL4mj1XwM,8764
 mmrelay/main.py,sha256=QwOLY6uLvFQZhHRlJrbp_D_-xDuEHQIgEsQ6ME_g1EI,16360
 mmrelay/matrix_utils.py,sha256=at0mME8nWwN-yxGGIlH4GblwGmrJd6DrjlNhM794scU,99146
 mmrelay/meshtastic_utils.py,sha256=86U8vQuWW7xR4E-_n-d7vlQhQ40gO-tJGZcVjzoeFhc,43027
-mmrelay/message_queue.py,sha256=tHKziIPwQ9Xm7qpITyR1r2e-ftdn4ZivdZhek9SmMcQ,18703
+mmrelay/message_queue.py,sha256=HvD4oH_X4K3f4mjpWgWrxO_KkYykuqpOpEeO37ZeQOw,27961
 mmrelay/plugin_loader.py,sha256=6SD7eoO0VHnsEPI_YrrnrbeHAjC7okmyUpaA4Eu5AHo,41718
 mmrelay/setup_utils.py,sha256=EAVPmKHQmlXnxMcrkhlU27fBPjJCiwTVSLZdbEFsWLQ,22095
 mmrelay/constants/__init__.py,sha256=M8AXeIcS1JuS8OwmfTmhcCOkAz5XmWlNQ53GBxYOx94,1494
@@ -36,10 +36,10 @@ mmrelay/tools/mmrelay.service,sha256=3vqK1VbfXvVftkTrTEOan77aTHeOT36hIAL7HqJsmTg
 mmrelay/tools/sample-docker-compose-prebuilt.yaml,sha256=NWV-g3RwiFlYfjgGL5t9DtInoJJDUSaTBy4w1ICk81A,3136
 mmrelay/tools/sample-docker-compose.yaml,sha256=PHt0MGrzUAzxBovtf1TZyrvJ9YK-ZpdSyyp5Tmp8zIY,2543
 mmrelay/tools/sample.env,sha256=RP-o3rX3jnEIrVG2rqCZq31O1yRXou4HcGrXWLVbKKw,311
-mmrelay/tools/sample_config.yaml,sha256=wQnEhL5St7Xqeb--ClJQVcbVXu_n69fPHuF2zSB0Zu4,6250
-mmrelay-1.2.0.dist-info/licenses/LICENSE,sha256=aB_07MhnK-bL5WLI1ucXLUSdW_yBVoepPRYB0kaAOl8,35204
-mmrelay-1.2.0.dist-info/METADATA,sha256=RvrjFahRkYXAokF54_gLy24oD2pgjjvQEYjcm0oi9BM,6143
-mmrelay-1.2.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-mmrelay-1.2.0.dist-info/entry_points.txt,sha256=SJZwGUOEpQ-qx4H8UL4xKFnKeInGUaZNW1I0ddjK7Ws,45
-mmrelay-1.2.0.dist-info/top_level.txt,sha256=B_ZLCRm7NYAmI3PipRUyHGymP-C-q16LSeMGzmqJfo4,8
-mmrelay-1.2.0.dist-info/RECORD,,
+mmrelay/tools/sample_config.yaml,sha256=UWHAUdnPNjKlEugcOntb2Dqr94zxZ7j5l3dOw9vt5L4,6393
+mmrelay-1.2.1.dist-info/licenses/LICENSE,sha256=aB_07MhnK-bL5WLI1ucXLUSdW_yBVoepPRYB0kaAOl8,35204
+mmrelay-1.2.1.dist-info/METADATA,sha256=BbRn_RHc-xSBPwrVld9Xkpp2BZVnXpYVd7aljt1dzhA,6176
+mmrelay-1.2.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+mmrelay-1.2.1.dist-info/entry_points.txt,sha256=SJZwGUOEpQ-qx4H8UL4xKFnKeInGUaZNW1I0ddjK7Ws,45
+mmrelay-1.2.1.dist-info/top_level.txt,sha256=B_ZLCRm7NYAmI3PipRUyHGymP-C-q16LSeMGzmqJfo4,8
+mmrelay-1.2.1.dist-info/RECORD,,