fix always showing down arrow in settings

* working changes

* working changes

* working changes

* not working changes

* working changes

* cleanup

.vscode/launch.json

@@ -6,8 +6,8 @@
             "type": "debugpy",
             "request": "launch",
             "cwd": "${workspaceFolder}",
-            "module": "contact.main",
+            "module": "contact.__main__",
             "args": []
         }
     ]
-}
+}

.vscode/settings.json

@@ -0,0 +1,6 @@
+{
+  "[python]": {
+      "editor.defaultFormatter": "ms-python.black-formatter",
+      "editor.formatOnSave": true
+    }
+}

README.md

@@ -1,17 +1,21 @@
 ## Contact - A Console UI for Meshtastic
-### (Formerly Curses Client for Meshtastic)
 
 #### Powered by Meshtastic.org
 
+### Install with:
+```bash
+pip install contact
+```
+
 This Python curses client for Meshtastic is a terminal-based client designed to manage device settings, enable mesh chat communication, and handle configuration backups and restores.
 
 
 <img width="846" alt="Contact - Main UI Screenshot" src="https://github.com/user-attachments/assets/d2996bfb-2c6d-46a8-b820-92a9143375f4">
 
 <br><br>
-The settings dialogue can be accessed within the client or may be run standalone to configure your node by launching `settings.py`
+The settings dialogue can be accessed within the client or may be run standalone to configure your node by launching `contact --settings` or `contact -c`
 
-<img width="441" alt="Contact - Settings Dialogue" src="https://github.com/user-attachments/assets/dd47f52a-d4d8-4e40-8001-9ea53d87f816" />
+<img width="696" alt="Screenshot 2025-04-08 at 6 10 06 PM" src="https://github.com/user-attachments/assets/3d5e3964-f009-4772-bd6e-91b907c65a3b" />
 
 ## Message Persistence 
 
@@ -48,6 +52,7 @@ Optional arguments to specify a device to connect to and how.
 - `--port`, `--serial`, `-s`: The port to connect to via serial, e.g. `/dev/ttyUSB0`.
 - `--host`, `--tcp`, `-t`: The hostname or IP address to connect to using TCP, will default to localhost if no host is passed.
 - `--ble`, `-b`: The BLE device MAC address or name to connect to.
+- `--settings`, `--set`, `--control`, `-c`: Launch directly into the settings.
 
 If no connection arguments are specified, the client will attempt a serial connection and then a TCP connection to localhost.
 

contact/__main__.py

@@ -0,0 +1,137 @@
+#!/usr/bin/env python3
+
+"""
+Contact - A Console UI for Meshtastic by http://github.com/pdxlocations
+Powered by Meshtastic.org
+
+Meshtastic® is a registered trademark of Meshtastic LLC.
+Meshtastic software components are released under various licenses—see GitHub for details.
+No warranty is provided. Use at your own risk.
+"""
+
+# Standard library
+import contextlib
+import curses
+import io
+import logging
+import os
+import subprocess
+import sys
+import threading
+import traceback
+
+# Third-party
+from pubsub import pub
+
+# Local application
+import contact.globals as globals
+import contact.ui.default_config as config
+from contact.message_handlers.rx_handler import on_receive
+from contact.settings import set_region
+from contact.ui.colors import setup_colors
+from contact.ui.contact_ui import main_ui
+from contact.ui.splash import draw_splash
+from contact.utilities.arg_parser import setup_parser
+from contact.utilities.db_handler import init_nodedb, load_messages_from_db
+from contact.utilities.input_handlers import get_list_input
+from contact.utilities.interfaces import initialize_interface
+from contact.utilities.utils import get_channels, get_nodeNum, get_node_list
+
+
+# ------------------------------------------------------------------------------
+# Environment & Logging Setup
+# ------------------------------------------------------------------------------
+
+os.environ["NCURSES_NO_UTF8_ACS"] = "1"
+os.environ["LANG"] = "C.UTF-8"
+os.environ.setdefault("TERM", "xterm-256color")
+if os.environ.get("COLORTERM") == "gnome-terminal":
+    os.environ["TERM"] = "xterm-256color"
+
+logging.basicConfig(
+    filename=config.log_file_path, level=logging.INFO, format="%(asctime)s - %(levelname)s - %(message)s"
+)
+
+globals.lock = threading.Lock()
+
+# ------------------------------------------------------------------------------
+# Main Program Logic
+# ------------------------------------------------------------------------------
+
+
+def initialize_globals(args) -> None:
+    """Initializes interface and shared globals."""
+    globals.interface = initialize_interface(args)
+
+    # Prompt for region if unset
+    if globals.interface.localNode.localConfig.lora.region == 0:
+        confirmation = get_list_input("Your region is UNSET. Set it now?", "Yes", ["Yes", "No"])
+        if confirmation == "Yes":
+            set_region(globals.interface)
+            globals.interface.close()
+            globals.interface = initialize_interface(args)
+
+    globals.myNodeNum = get_nodeNum()
+    globals.channel_list = get_channels()
+    globals.node_list = get_node_list()
+    pub.subscribe(on_receive, "meshtastic.receive")
+
+    init_nodedb()
+    load_messages_from_db()
+
+
+def main(stdscr: curses.window) -> None:
+    """Main entry point for the curses UI."""
+    output_capture = io.StringIO()
+
+    try:
+        with contextlib.redirect_stdout(output_capture), contextlib.redirect_stderr(output_capture):
+            setup_colors()
+            draw_splash(stdscr)
+
+            args = setup_parser().parse_args()
+
+            if getattr(args, "settings", False):
+                subprocess.run([sys.executable, "-m", "contact.settings"], check=True)
+                return
+
+            logging.info("Initializing interface...")
+            with globals.lock:
+                initialize_globals(args)
+                logging.info("Starting main UI")
+
+            main_ui(stdscr)
+
+    except Exception as e:
+        console_output = output_capture.getvalue()
+        logging.error("Uncaught exception: %s", e)
+        logging.error("Traceback: %s", traceback.format_exc())
+        logging.error("Console output:\n%s", console_output)
+        raise
+
+
+def start() -> None:
+    """Launch curses wrapper and redirect logs to file."""
+
+    if "--help" in sys.argv or "-h" in sys.argv:
+        setup_parser().print_help()
+        sys.exit(0)
+
+    with open(config.log_file_path, "a", buffering=1) as log_f:
+        sys.stdout = log_f
+        sys.stderr = log_f
+
+        with contextlib.redirect_stdout(log_f), contextlib.redirect_stderr(log_f):
+            try:
+                curses.wrapper(main)
+            except KeyboardInterrupt:
+                logging.info("User exited with Ctrl+C")
+                sys.exit(0)
+            except Exception as e:
+                logging.error("Fatal error: %s", e)
+                logging.error("Traceback: %s", traceback.format_exc())
+                sys.exit(1)
+
+
+if __name__ == "__main__":
+    start()

contact/globals.py

@@ -10,4 +10,4 @@ myNodeNum = 0
 selected_channel = 0
 selected_message = 0
 selected_node = 0
-current_window = 0
+current_window = 0

contact/localisations/en.ini

@@ -78,6 +78,13 @@ dns, "IPv4 DNS server", ""
 rsyslog_server, "RSyslog server", ""
 enabled_protocols, "Enabled protocols", ""
 
+[config.network.ipv4_config]
+title, "IPv4 Config", ""
+ip, "IP", ""
+gateway, "Gateway", ""
+subnet, "Subnet", ""
+dns, "DNS", ""
+
 [config.display]
 title, "Display"
 screen_on_secs, "Screen on duration", "How long the screen remains on in seconds after the user button is pressed or messages are received."
@@ -105,6 +112,35 @@ theme, "Theme", ""
 alert_enabled, "Alert enabled", ""
 banner_enabled, "Banner enabled", ""
 ring_tone_id, "Ring tone ID", ""
+language, "Language", ""
+node_filter, "Node Filter", ""
+node_highlight, "Node Highlight", ""
+calibration_data, "Calibration Data", ""
+map_data, "Map Data", ""
+
+[config.device_ui.node_filter]
+title, "Node Filter"
+unknown_switch, "Unknown Switch", ""
+offline_switch, "Offline Switch", ""
+public_key_switch, "Public Key Switch", ""
+hops_away, "Hops Away", ""
+position_switch, "Position Switch", ""
+node_name, "Node Name", ""
+channel, "Channel", ""
+
+[config.device_ui.node_highlight]
+title, "Node Highlight"
+chat_switch, "Chat Switch", ""
+position_switch, "Position Switch", ""
+telemetry_switch, "Telemetry Switch", ""
+iaq_switch, "IAQ Switch", ""
+node_name, "Node Name", ""
+
+[config.device_ui.map_data]
+title, "Map Data"
+home, "Home", ""
+style, "Style", ""
+follow_gps, "Follow GPS", ""
 
 [config.lora]
 title, "LoRa"

contact/main.py

@@ -1,109 +0,0 @@
-#!/usr/bin/env python3
-
-'''
-Contact - A Console UI for Meshtastic by http://github.com/pdxlocations
-Powered by Meshtastic.org
-V 1.2.2
-
-Meshtastic® is a registered trademark of Meshtastic LLC. Meshtastic software components are released under various licenses, see GitHub for details. No warranty is provided - use at your own risk.
-'''
-
-import contextlib
-import curses
-import os
-from pubsub import pub
-import sys
-import io
-import logging
-import traceback
-import threading
-
-from contact.utilities.db_handler import init_nodedb, load_messages_from_db
-from contact.message_handlers.rx_handler import on_receive
-from contact.settings import set_region
-from contact.ui.curses_ui import main_ui
-from contact.ui.colors import setup_colors
-from contact.ui.splash import draw_splash
-import contact.ui.default_config as config
-from contact.utilities.arg_parser import setup_parser
-from contact.utilities.interfaces import initialize_interface
-from contact.utilities.input_handlers import get_list_input
-from contact.utilities.utils import get_channels, get_node_list, get_nodeNum
-import contact.globals as globals
-
-# Set ncurses compatibility settings
-os.environ["NCURSES_NO_UTF8_ACS"] = "1"
-os.environ["LANG"] = "C.UTF-8"
-os.environ.setdefault("TERM", "xterm-256color")
-if os.environ.get("COLORTERM") == "gnome-terminal":
-    os.environ["TERM"] = "xterm-256color"
-
-# Configure logging
-# Run `tail -f client.log` in another terminal to view live
-logging.basicConfig(
-    filename=config.log_file_path,
-    level=logging.INFO,  # DEBUG, INFO, WARNING, ERROR, CRITICAL)
-    format="%(asctime)s - %(levelname)s - %(message)s"
-)
-
-globals.lock = threading.Lock()
-
-def main(stdscr):
-    output_capture = io.StringIO()
-    try:
-        with contextlib.redirect_stdout(output_capture), contextlib.redirect_stderr(output_capture):
-
-            setup_colors()
-            draw_splash(stdscr)
-            parser = setup_parser()
-            args = parser.parse_args()
-
-            logging.info("Initializing interface %s", args)
-            with globals.lock:
-                globals.interface = initialize_interface(args)
-
-                if globals.interface.localNode.localConfig.lora.region == 0:
-                    confirmation = get_list_input("Your region is UNSET. Set it now?", "Yes", ["Yes", "No"])
-                    if confirmation == "Yes":
-                        set_region(globals.interface)
-                        globals.interface.close()
-                        globals.interface = initialize_interface(args)
-
-                logging.info("Interface initialized")
-                globals.myNodeNum = get_nodeNum()
-                globals.channel_list = get_channels()
-                globals.node_list = get_node_list()
-                pub.subscribe(on_receive, 'meshtastic.receive')
-                init_nodedb()
-                load_messages_from_db()
-                logging.info("Starting main UI")
-
-            main_ui(stdscr)
-
-    except Exception as e:
-        console_output = output_capture.getvalue()
-        logging.error("An error occurred: %s", e)
-        logging.error("Traceback: %s", traceback.format_exc())
-        logging.error("Console output before crash:\n%s", console_output)
-        raise  # Re-raise only unexpected errors
-
-def start():
-    log_file = config.log_file_path
-    log_f = open(log_file, "a", buffering=1)  # Enable line-buffering for immediate log writes
-
-    sys.stdout = log_f
-    sys.stderr = log_f
-
-    with contextlib.redirect_stderr(log_f), contextlib.redirect_stdout(log_f):
-        try:
-            curses.wrapper(main)
-        except KeyboardInterrupt:
-            logging.info("User exited with Ctrl+C or Ctrl+X")  # Clean exit logging
-            sys.exit(0)  # Ensure a clean exit
-        except Exception as e:
-            logging.error("Fatal error in curses wrapper: %s", e)
-            logging.error("Traceback: %s", traceback.format_exc())
-            sys.exit(1)  # Exit with an error code
-
-if __name__ == "__main__":
-    start()

contact/message_handlers/rx_handler.py

@@ -1,62 +1,79 @@
 import logging
 import time
-from contact.utilities.utils import refresh_node_list
 from datetime import datetime
-from contact.ui.curses_ui import draw_packetlog_win, draw_node_list, draw_messages_window, draw_channel_list, add_notification
-from contact.utilities.db_handler import save_message_to_db, maybe_store_nodeinfo_in_db, get_name_from_database, update_node_info_in_db
+from typing import Any, Dict
+
+from contact.utilities.utils import refresh_node_list
+from contact.ui.contact_ui import (
+    draw_packetlog_win,
+    draw_node_list,
+    draw_messages_window,
+    draw_channel_list,
+    add_notification,
+)
+from contact.utilities.db_handler import (
+    save_message_to_db,
+    maybe_store_nodeinfo_in_db,
+    get_name_from_database,
+    update_node_info_in_db,
+)
 import contact.ui.default_config as config
 import contact.globals as globals
 
 
-from datetime import datetime
-
-def on_receive(packet, interface):
+def on_receive(packet: Dict[str, Any], interface: Any) -> None:
+    """
+    Handles an incoming packet from a Meshtastic interface.
 
+    Args:
+        packet: The received Meshtastic packet as a dictionary.
+        interface: The Meshtastic interface instance that received the packet.
+    """
     with globals.lock:
         # Update packet log
         globals.packet_buffer.append(packet)
         if len(globals.packet_buffer) > 20:
             # Trim buffer to 20 packets
             globals.packet_buffer = globals.packet_buffer[-20:]
-            
+
         if globals.display_log:
             draw_packetlog_win()
         try:
-            if 'decoded' not in packet:
+            if "decoded" not in packet:
                 return
 
             # Assume any incoming packet could update the last seen time for a node
             changed = refresh_node_list()
-            if(changed):
+            if changed:
                 draw_node_list()
 
-            if packet['decoded']['portnum'] == 'NODEINFO_APP':
-                if "user" in packet['decoded'] and "longName" in packet['decoded']["user"]: 
+            if packet["decoded"]["portnum"] == "NODEINFO_APP":
+                if "user" in packet["decoded"] and "longName" in packet["decoded"]["user"]:
                     maybe_store_nodeinfo_in_db(packet)
 
-            elif packet['decoded']['portnum'] == 'TEXT_MESSAGE_APP':
-                message_bytes = packet['decoded']['payload']
-                message_string = message_bytes.decode('utf-8')
+            elif packet["decoded"]["portnum"] == "TEXT_MESSAGE_APP":
+                message_bytes = packet["decoded"]["payload"]
+                message_string = message_bytes.decode("utf-8")
 
                 refresh_channels = False
                 refresh_messages = False
 
-                if packet.get('channel'):
-                    channel_number = packet['channel']
+                if packet.get("channel"):
+                    channel_number = packet["channel"]
                 else:
                     channel_number = 0
 
-                if packet['to'] == globals.myNodeNum:
-                    if packet['from'] in globals.channel_list:
+                if packet["to"] == globals.myNodeNum:
+                    if packet["from"] in globals.channel_list:
                         pass
                     else:
-                        globals.channel_list.append(packet['from'])
-                        if(packet['from'] not in globals.all_messages):
-                            globals.all_messages[packet['from']] = []
-                        update_node_info_in_db(packet['from'], chat_archived=False)
+                        globals.channel_list.append(packet["from"])
+                        if packet["from"] not in globals.all_messages:
+                            globals.all_messages[packet["from"]] = []
+                        update_node_info_in_db(packet["from"], chat_archived=False)
                         refresh_channels = True
 
-                    channel_number = globals.channel_list.index(packet['from'])
+                    channel_number = globals.channel_list.index(packet["from"])
 
                 if globals.channel_list[channel_number] != globals.channel_list[globals.selected_channel]:
                     add_notification(channel_number)
@@ -65,15 +82,15 @@ def on_receive(packet, interface):
                     refresh_messages = True
 
                 # Add received message to the messages list
-                message_from_id = packet['from']
-                message_from_string = get_name_from_database(message_from_id, type='short') + ":"
+                message_from_id = packet["from"]
+                message_from_string = get_name_from_database(message_from_id, type="short") + ":"
 
                 if globals.channel_list[channel_number] not in globals.all_messages:
                     globals.all_messages[globals.channel_list[channel_number]] = []
 
                 # Timestamp handling
-                current_timestamp = time.time() 
-                current_hour = datetime.fromtimestamp(current_timestamp).strftime('%Y-%m-%d %H:00')
+                current_timestamp = time.time()
+                current_hour = datetime.fromtimestamp(current_timestamp).strftime("%Y-%m-%d %H:00")
 
                 # Retrieve the last timestamp if available
                 channel_messages = globals.all_messages[globals.channel_list[channel_number]]
@@ -92,7 +109,9 @@ def on_receive(packet, interface):
                 if last_hour != current_hour:
                     globals.all_messages[globals.channel_list[channel_number]].append((f"-- {current_hour} --", ""))
 
-                globals.all_messages[globals.channel_list[channel_number]].append((f"{config.message_prefix} {message_from_string} ", message_string))
+                globals.all_messages[globals.channel_list[channel_number]].append(
+                    (f"{config.message_prefix} {message_from_string} ", message_string)
+                )
 
                 if refresh_channels:
                     draw_channel_list()

contact/message_handlers/tx_handler.py

@@ -1,29 +1,42 @@
 from datetime import datetime
+from typing import Any, Dict
+
 import google.protobuf.json_format
 from meshtastic import BROADCAST_NUM
 from meshtastic.protobuf import mesh_pb2, portnums_pb2
 
-from contact.utilities.db_handler import save_message_to_db, update_ack_nak, get_name_from_database, is_chat_archived, update_node_info_in_db
+from contact.utilities.db_handler import (
+    save_message_to_db,
+    update_ack_nak,
+    get_name_from_database,
+    is_chat_archived,
+    update_node_info_in_db,
+)
 import contact.ui.default_config as config
 import contact.globals as globals
 
-ack_naks = {}
+ack_naks: Dict[str, Dict[str, Any]] = {}  # requestId -> {channel, messageIndex, timestamp}
+
 
 # Note "onAckNak" has special meaning to the API, thus the nonstandard naming convention
 # See https://github.com/meshtastic/python/blob/master/meshtastic/mesh_interface.py#L462
-def onAckNak(packet):
-    from contact.ui.curses_ui import draw_messages_window
-    request = packet['decoded']['requestId']
-    if(request not in ack_naks):
+def onAckNak(packet: Dict[str, Any]) -> None:
+    """
+    Handles incoming ACK/NAK response packets.
+    """
+    from contact.ui.contact_ui import draw_messages_window
+
+    request = packet["decoded"]["requestId"]
+    if request not in ack_naks:
         return
 
     acknak = ack_naks.pop(request)
-    message = globals.all_messages[acknak['channel']][acknak['messageIndex']][1]
+    message = globals.all_messages[acknak["channel"]][acknak["messageIndex"]][1]
 
     confirm_string = " "
     ack_type = None
-    if(packet['decoded']['routing']['errorReason'] == "NONE"):
-        if(packet['from'] == globals.myNodeNum): # Ack "from" ourself means implicit ACK
+    if packet["decoded"]["routing"]["errorReason"] == "NONE":
+        if packet["from"] == globals.myNodeNum:  # Ack "from" ourself means implicit ACK
             confirm_string = config.ack_implicit_str
             ack_type = "Implicit"
         else:
@@ -33,22 +46,28 @@ def onAckNak(packet):
         confirm_string = config.nak_str
         ack_type = "Nak"
 
-    globals.all_messages[acknak['channel']][acknak['messageIndex']] = (config.sent_message_prefix + confirm_string + ": ", message)
+    globals.all_messages[acknak["channel"]][acknak["messageIndex"]] = (
+        config.sent_message_prefix + confirm_string + ": ",
+        message,
+    )
 
-    update_ack_nak(acknak['channel'], acknak['timestamp'], message, ack_type)
+    update_ack_nak(acknak["channel"], acknak["timestamp"], message, ack_type)
 
-    channel_number = globals.channel_list.index(acknak['channel'])
+    channel_number = globals.channel_list.index(acknak["channel"])
     if globals.channel_list[channel_number] == globals.channel_list[globals.selected_channel]:
         draw_messages_window()
 
-def on_response_traceroute(packet):
-    """on response for trace route"""
-    from contact.ui.curses_ui import draw_channel_list, draw_messages_window, add_notification
+
+def on_response_traceroute(packet: Dict[str, Any]) -> None:
+    """
+    Handle traceroute response packets and render the route visually in the UI.
+    """
+    from contact.ui.contact_ui import draw_channel_list, draw_messages_window, add_notification
 
     refresh_channels = False
     refresh_messages = False
 
-    UNK_SNR = -128 # Value representing unknown SNR
+    UNK_SNR = -128  # Value representing unknown SNR
 
     route_discovery = mesh_pb2.RouteDiscovery()
     route_discovery.ParseFromString(packet["decoded"]["payload"])
@@ -56,48 +75,76 @@ def on_response_traceroute(packet):
 
     msg_str = "Traceroute to:\n"
 
-    route_str = get_name_from_database(packet["to"], 'short') or f"{packet['to']:08x}" # Start with destination of response
+    route_str = (
+        get_name_from_database(packet["to"], "short") or f"{packet['to']:08x}"
+    )  # Start with destination of response
 
     # SNR list should have one more entry than the route, as the final destination adds its SNR also
     lenTowards = 0 if "route" not in msg_dict else len(msg_dict["route"])
     snrTowardsValid = "snrTowards" in msg_dict and len(msg_dict["snrTowards"]) == lenTowards + 1
-    if lenTowards > 0: # Loop through hops in route and add SNR if available
+    if lenTowards > 0:  # Loop through hops in route and add SNR if available
         for idx, node_num in enumerate(msg_dict["route"]):
-            route_str += " --> " + (get_name_from_database(node_num, 'short') or f"{node_num:08x}") \
-                     + " (" + (str(msg_dict["snrTowards"][idx] / 4) if snrTowardsValid and msg_dict["snrTowards"][idx] != UNK_SNR else "?") + "dB)"
+            route_str += (
+                " --> "
+                + (get_name_from_database(node_num, "short") or f"{node_num:08x}")
+                + " ("
+                + (
+                    str(msg_dict["snrTowards"][idx] / 4)
+                    if snrTowardsValid and msg_dict["snrTowards"][idx] != UNK_SNR
+                    else "?"
+                )
+                + "dB)"
+            )
 
     # End with origin of response
-    route_str += " --> " + (get_name_from_database(packet["from"], 'short') or f"{packet['from']:08x}") \
-             + " (" + (str(msg_dict["snrTowards"][-1] / 4) if snrTowardsValid and msg_dict["snrTowards"][-1] != UNK_SNR else "?") + "dB)"
+    route_str += (
+        " --> "
+        + (get_name_from_database(packet["from"], "short") or f"{packet['from']:08x}")
+        + " ("
+        + (str(msg_dict["snrTowards"][-1] / 4) if snrTowardsValid and msg_dict["snrTowards"][-1] != UNK_SNR else "?")
+        + "dB)"
+    )
 
-    msg_str += route_str + "\n" # Print the route towards destination
+    msg_str += route_str + "\n"  # Print the route towards destination
 
     # Only if hopStart is set and there is an SNR entry (for the origin) it's valid, even though route might be empty (direct connection)
     lenBack = 0 if "routeBack" not in msg_dict else len(msg_dict["routeBack"])
     backValid = "hopStart" in packet and "snrBack" in msg_dict and len(msg_dict["snrBack"]) == lenBack + 1
     if backValid:
         msg_str += "Back:\n"
-        route_str = get_name_from_database(packet["from"], 'short') or f"{packet['from']:08x}" # Start with origin of response
+        route_str = (
+            get_name_from_database(packet["from"], "short") or f"{packet['from']:08x}"
+        )  # Start with origin of response
 
-        if lenBack > 0: # Loop through hops in routeBack and add SNR if available
+        if lenBack > 0:  # Loop through hops in routeBack and add SNR if available
             for idx, node_num in enumerate(msg_dict["routeBack"]):
-                route_str += " --> " + (get_name_from_database(node_num, 'short') or f"{node_num:08x}") \
-                         + " (" + (str(msg_dict["snrBack"][idx] / 4) if msg_dict["snrBack"][idx] != UNK_SNR else "?") + "dB)"
+                route_str += (
+                    " --> "
+                    + (get_name_from_database(node_num, "short") or f"{node_num:08x}")
+                    + " ("
+                    + (str(msg_dict["snrBack"][idx] / 4) if msg_dict["snrBack"][idx] != UNK_SNR else "?")
+                    + "dB)"
+                )
 
         # End with destination of response (us)
-        route_str += " --> " + (get_name_from_database(packet["to"], 'short') or f"{packet['to']:08x}") \
-                 + " (" + (str(msg_dict["snrBack"][-1] / 4) if msg_dict["snrBack"][-1] != UNK_SNR else "?") + "dB)"
+        route_str += (
+            " --> "
+            + (get_name_from_database(packet["to"], "short") or f"{packet['to']:08x}")
+            + " ("
+            + (str(msg_dict["snrBack"][-1] / 4) if msg_dict["snrBack"][-1] != UNK_SNR else "?")
+            + "dB)"
+        )
 
-        msg_str += route_str + "\n" # Print the route back to us
+        msg_str += route_str + "\n"  # Print the route back to us
 
-    if(packet['from'] not in globals.channel_list):
-        globals.channel_list.append(packet['from'])
+    if packet["from"] not in globals.channel_list:
+        globals.channel_list.append(packet["from"])
         refresh_channels = True
 
-    if(is_chat_archived(packet['from'])):
-        update_node_info_in_db(packet['from'], chat_archived=False)
+    if is_chat_archived(packet["from"]):
+        update_node_info_in_db(packet["from"], chat_archived=False)
 
-    channel_number = globals.channel_list.index(packet['from'])
+    channel_number = globals.channel_list.index(packet["from"])
 
     if globals.channel_list[channel_number] == globals.channel_list[globals.selected_channel]:
         refresh_messages = True
@@ -105,20 +152,25 @@ def on_response_traceroute(packet):
         add_notification(channel_number)
         refresh_channels = True
 
-    message_from_string = get_name_from_database(packet['from'], type='short') + ":\n"
+    message_from_string = get_name_from_database(packet["from"], type="short") + ":\n"
 
     if globals.channel_list[channel_number] not in globals.all_messages:
         globals.all_messages[globals.channel_list[channel_number]] = []
-    globals.all_messages[globals.channel_list[channel_number]].append((f"{config.message_prefix} {message_from_string}", msg_str))
+    globals.all_messages[globals.channel_list[channel_number]].append(
+        (f"{config.message_prefix} {message_from_string}", msg_str)
+    )
 
     if refresh_channels:
         draw_channel_list()
     if refresh_messages:
         draw_messages_window(True)
-    save_message_to_db(globals.channel_list[channel_number], packet['from'], msg_str)
+    save_message_to_db(globals.channel_list[channel_number], packet["from"], msg_str)
 
 
-def send_message(message, destination=BROADCAST_NUM, channel=0):
+def send_message(message: str, destination: int = BROADCAST_NUM, channel: int = 0) -> None:
+    """
+    Sends a chat message using the selected channel.
+    """
     myid = globals.myNodeNum
     send_on_channel = 0
     channel_id = globals.channel_list[channel]
@@ -143,7 +195,7 @@ def send_message(message, destination=BROADCAST_NUM, channel=0):
 
     # Handle timestamp logic
     current_timestamp = int(datetime.now().timestamp())  # Get current timestamp
-    current_hour = datetime.fromtimestamp(current_timestamp).strftime('%Y-%m-%d %H:00')
+    current_hour = datetime.fromtimestamp(current_timestamp).strftime("%Y-%m-%d %H:00")
 
     # Retrieve the last timestamp if available
     channel_messages = globals.all_messages[channel_id]
@@ -166,9 +218,17 @@ def send_message(message, destination=BROADCAST_NUM, channel=0):
 
     timestamp = save_message_to_db(channel_id, myid, message)
 
-    ack_naks[sent_message_data.id] = {'channel': channel_id, 'messageIndex': len(globals.all_messages[channel_id]) - 1, 'timestamp': timestamp}
+    ack_naks[sent_message_data.id] = {
+        "channel": channel_id,
+        "messageIndex": len(globals.all_messages[channel_id]) - 1,
+        "timestamp": timestamp,
+    }
 
-def send_traceroute():
+
+def send_traceroute() -> None:
+    """
+    Sends a RouteDiscovery protobuf to the selected node.
+    """
     r = mesh_pb2.RouteDiscovery()
     globals.interface.sendData(
         r,

contact/settings.py

@@ -14,10 +14,10 @@ from contact.utilities.arg_parser import setup_parser
 from contact.utilities.interfaces import initialize_interface
 
 
-def main(stdscr):
+def main(stdscr: curses.window) -> None:
     output_capture = io.StringIO()
     try:
-        with contextlib.redirect_stdout(output_capture), contextlib.redirect_stderr(output_capture):   
+        with contextlib.redirect_stdout(output_capture), contextlib.redirect_stderr(output_capture):
             setup_colors()
             draw_splash(stdscr)
             curses.curs_set(0)
@@ -28,7 +28,7 @@ def main(stdscr):
             interface = initialize_interface(args)
 
             if interface.localNode.localConfig.lora.region == 0:
-                confirmation = get_list_input("Your region is UNSET.  Set it now?", "Yes",  ["Yes", "No"])
+                confirmation = get_list_input("Your region is UNSET.  Set it now?", "Yes", ["Yes", "No"])
                 if confirmation == "Yes":
                     set_region(interface)
                     interface.close()
@@ -45,10 +45,10 @@ def main(stdscr):
         raise
 
 
-logging.basicConfig( # Run `tail -f client.log` in another terminal to view live
+logging.basicConfig(  # Run `tail -f client.log` in another terminal to view live
     filename=config.log_file_path,
     level=logging.WARNING,  # DEBUG, INFO, WARNING, ERROR, CRITICAL)
-    format="%(asctime)s - %(levelname)s - %(message)s"
+    format="%(asctime)s - %(levelname)s - %(message)s",
 )
 
 if __name__ == "__main__":
@@ -67,4 +67,4 @@ if __name__ == "__main__":
         except Exception as e:
             logging.error("Fatal error in curses wrapper: %s", e)
             logging.error("Traceback: %s", traceback.format_exc())
-            sys.exit(1)  # Exit with an error code
+            sys.exit(1)  # Exit with an error code

contact/ui/colors.py

@@ -9,10 +9,11 @@ COLOR_MAP = {
     "blue": curses.COLOR_BLUE,
     "magenta": curses.COLOR_MAGENTA,
     "cyan": curses.COLOR_CYAN,
-    "white": curses.COLOR_WHITE
+    "white": curses.COLOR_WHITE,
 }
 
-def setup_colors(reinit=False):
+
+def setup_colors(reinit: bool = False) -> None:
     """
     Initialize curses color pairs based on the COLOR_CONFIG.
     """
@@ -29,7 +30,7 @@ def setup_colors(reinit=False):
     print()
 
 
-def get_color(category, bold=False, reverse=False, underline=False):
+def get_color(category: str, bold: bool = False, reverse: bool = False, underline: bool = False) -> int:
     """
     Retrieve a curses color pair with optional attributes.
     """
@@ -40,4 +41,4 @@ def get_color(category, bold=False, reverse=False, underline=False):
         color |= curses.A_REVERSE
     if underline:
         color |= curses.A_UNDERLINE
-    return color
+    return color

contact/ui/contact_ui.py

@@ -2,16 +2,20 @@ import curses
 import textwrap
 import logging
 import traceback
+from typing import Union
+
 from contact.utilities.utils import get_channels, get_readable_duration, get_time_ago, refresh_node_list
 from contact.settings import settings_menu
 from contact.message_handlers.tx_handler import send_message, send_traceroute
-from contact.ui.colors import setup_colors, get_color
+from contact.ui.colors import get_color
 from contact.utilities.db_handler import get_name_from_database, update_node_info_in_db, is_chat_archived
+from contact.utilities.input_handlers import get_list_input
 import contact.ui.default_config as config
 import contact.ui.dialog
 import contact.globals as globals
 
-def handle_resize(stdscr, firstrun):
+
+def handle_resize(stdscr: curses.window, firstrun: bool) -> None:
     global messages_pad, messages_win, nodes_pad, nodes_win, channel_pad, channel_win, function_win, packetlog_win, entry_win
 
     # Calculate window max dimensions
@@ -31,9 +35,9 @@ def handle_resize(stdscr, firstrun):
         packetlog_win = curses.newwin(int(height / 3), messages_width, height - int(height / 3) - 3, channel_width)
 
         # Will be resized to what we need when drawn
-        messages_pad = curses.newpad(1,1)
-        nodes_pad = curses.newpad(1,1)
-        channel_pad = curses.newpad(1,1)
+        messages_pad = curses.newpad(1, 1)
+        nodes_pad = curses.newpad(1, 1)
+        channel_pad = curses.newpad(1, 1)
 
         # Set background colors for windows
         for win in [entry_win, channel_win, messages_win, nodes_win, function_win, packetlog_win]:
@@ -47,7 +51,6 @@ def handle_resize(stdscr, firstrun):
         for win in [channel_win, entry_win, nodes_win, messages_win, function_win]:
             win.attrset(get_color("window_frame"))
 
-
     else:
         for win in [entry_win, channel_win, messages_win, nodes_win, function_win, packetlog_win]:
             win.erase()
@@ -68,7 +71,6 @@ def handle_resize(stdscr, firstrun):
         packetlog_win.resize(int(height / 3), messages_width)
         packetlog_win.mvwin(height - int(height / 3) - 3, channel_width)
 
-
     # Draw window borders
     for win in [channel_win, entry_win, nodes_win, messages_win, function_win]:
         win.box()
@@ -88,7 +90,7 @@ def handle_resize(stdscr, firstrun):
         pass
 
 
-def main_ui(stdscr):
+def main_ui(stdscr: curses.window) -> None:
     global input_text
     input_text = ""
     stdscr.keypad(True)
@@ -140,22 +142,32 @@ def main_ui(stdscr):
 
         elif char == curses.KEY_PPAGE:
             if globals.current_window == 0:
-                select_channel(globals.selected_channel - (channel_win.getmaxyx()[0] - 2)) # select_channel will bounds check for us
+                select_channel(
+                    globals.selected_channel - (channel_win.getmaxyx()[0] - 2)
+                )  # select_channel will bounds check for us
             elif globals.current_window == 1:
                 globals.selected_message = max(globals.selected_message - get_msg_window_lines(), 0)
                 refresh_pad(1)
             elif globals.current_window == 2:
-                select_node(globals.selected_node - (nodes_win.getmaxyx()[0] - 2)) # select_node will bounds check for us
+                select_node(
+                    globals.selected_node - (nodes_win.getmaxyx()[0] - 2)
+                )  # select_node will bounds check for us
 
         elif char == curses.KEY_NPAGE:
             if globals.current_window == 0:
-                select_channel(globals.selected_channel + (channel_win.getmaxyx()[0] - 2)) # select_channel will bounds check for us
+                select_channel(
+                    globals.selected_channel + (channel_win.getmaxyx()[0] - 2)
+                )  # select_channel will bounds check for us
             elif globals.current_window == 1:
                 msg_line_count = messages_pad.getmaxyx()[0]
-                globals.selected_message = min(globals.selected_message + get_msg_window_lines(), msg_line_count - get_msg_window_lines())
+                globals.selected_message = min(
+                    globals.selected_message + get_msg_window_lines(), msg_line_count - get_msg_window_lines()
+                )
                 refresh_pad(1)
             elif globals.current_window == 2:
-                select_node(globals.selected_node + (nodes_win.getmaxyx()[0] - 2)) # select_node will bounds check for us
+                select_node(
+                    globals.selected_node + (nodes_win.getmaxyx()[0] - 2)
+                )  # select_node will bounds check for us
 
         elif char == curses.KEY_LEFT or char == curses.KEY_RIGHT:
             delta = -1 if char == curses.KEY_LEFT else 1
@@ -212,7 +224,11 @@ def main_ui(stdscr):
         elif char == chr(20):
             send_traceroute()
             curses.curs_set(0)  # Hide cursor
-            contact.ui.dialog.dialog(stdscr, "Traceroute Sent", "Results will appear in messages window.\nNote: Traceroute is limited to once every 30 seconds.")
+            contact.ui.dialog.dialog(
+                stdscr,
+                "Traceroute Sent",
+                "Results will appear in messages window.\nNote: Traceroute is limited to once every 30 seconds.",
+            )
             curses.curs_set(1)  # Show cursor again
             handle_resize(stdscr, False)
 
@@ -221,13 +237,12 @@ def main_ui(stdscr):
                 node_list = globals.node_list
                 if node_list[globals.selected_node] not in globals.channel_list:
                     globals.channel_list.append(node_list[globals.selected_node])
-                if(node_list[globals.selected_node] not in globals.all_messages):
+                if node_list[globals.selected_node] not in globals.all_messages:
                     globals.all_messages[node_list[globals.selected_node]] = []
 
-
                 globals.selected_channel = globals.channel_list.index(node_list[globals.selected_node])
 
-                if(is_chat_archived(globals.channel_list[globals.selected_channel])):
+                if is_chat_archived(globals.channel_list[globals.selected_channel]):
                     update_node_info_in_db(globals.channel_list[globals.selected_channel], chat_archived=False)
 
                 globals.selected_node = 0
@@ -251,17 +266,17 @@ def main_ui(stdscr):
                 input_text = input_text[:-1]
                 y, x = entry_win.getyx()
                 entry_win.move(y, x - 1)
-                entry_win.addch(' ')  #
+                entry_win.addch(" ")  #
                 entry_win.move(y, x - 1)
             entry_win.refresh()
-            
-        elif char == "`": # ` Launch the settings interface
+
+        elif char == "`":  # ` Launch the settings interface
             curses.curs_set(0)
             settings_menu(stdscr, globals.interface)
             curses.curs_set(1)
             refresh_node_list()
             handle_resize(stdscr, False)
-        
+
         elif char == chr(16):
             # Display packet log
             if globals.display_log is False:
@@ -278,8 +293,8 @@ def main_ui(stdscr):
 
         # ^D
         elif char == chr(4):
-            if(globals.current_window == 0):
-                if(isinstance(globals.channel_list[globals.selected_channel], int)):
+            if globals.current_window == 0:
+                if isinstance(globals.channel_list[globals.selected_channel], int):
                     update_node_info_in_db(globals.channel_list[globals.selected_channel], chat_archived=True)
 
                     # Shift notifications up to account for deleted item
@@ -293,20 +308,108 @@ def main_ui(stdscr):
                     draw_channel_list()
                     draw_messages_window()
 
+            if globals.current_window == 2:
+                curses.curs_set(0)
+                confirmation = get_list_input(
+                    f"Remove {get_name_from_database(globals.node_list[globals.selected_node])} from nodedb?",
+                    "No",
+                    ["Yes", "No"],
+                )
+                if confirmation == "Yes":
+                    globals.interface.localNode.removeNode(globals.node_list[globals.selected_node])
+
+                    # Directly modifying the interface from client code - good? Bad? If it's stupid but it works, it's not supid?
+                    del globals.interface.nodesByNum[globals.node_list[globals.selected_node]]
+
+                    # Convert to "!hex" representation that interface.nodes uses
+                    hexid = f"!{hex(globals.node_list[globals.selected_node])[2:]}"
+                    del globals.interface.nodes[hexid]
+
+                    globals.node_list.pop(globals.selected_node)
+
+                    draw_messages_window()
+                    draw_node_list()
+                else:
+                    draw_messages_window()
+                curses.curs_set(1)
+                continue
+
+        # ^/
         elif char == chr(31):
-            if(globals.current_window == 2 or globals.current_window == 0):
+            if globals.current_window == 2 or globals.current_window == 0:
                 search(globals.current_window)
 
+        # ^F
+        elif char == chr(6):
+            if globals.current_window == 2:
+                selectedNode = globals.interface.nodesByNum[globals.node_list[globals.selected_node]]
+
+                curses.curs_set(0)
+
+                if "isFavorite" not in selectedNode or selectedNode["isFavorite"] == False:
+                    confirmation = get_list_input(
+                        f"Set {get_name_from_database(globals.node_list[globals.selected_node])} as Favorite?",
+                        None,
+                        ["Yes", "No"],
+                    )
+                    if confirmation == "Yes":
+                        globals.interface.localNode.setFavorite(globals.node_list[globals.selected_node])
+                        # Maybe we shouldn't be modifying the nodedb, but maybe it should update itself
+                        globals.interface.nodesByNum[globals.node_list[globals.selected_node]]["isFavorite"] = True
+
+                        refresh_node_list()
+
+                else:
+                    confirmation = get_list_input(
+                        f"Remove {get_name_from_database(globals.node_list[globals.selected_node])} from Favorites?",
+                        None,
+                        ["Yes", "No"],
+                    )
+                    if confirmation == "Yes":
+                        globals.interface.localNode.removeFavorite(globals.node_list[globals.selected_node])
+                        # Maybe we shouldn't be modifying the nodedb, but maybe it should update itself
+                        globals.interface.nodesByNum[globals.node_list[globals.selected_node]]["isFavorite"] = False
+
+                        refresh_node_list()
+
+                handle_resize(stdscr, False)
+
+        elif char == chr(7):
+            if globals.current_window == 2:
+                selectedNode = globals.interface.nodesByNum[globals.node_list[globals.selected_node]]
+
+                curses.curs_set(0)
+
+                if "isIgnored" not in selectedNode or selectedNode["isIgnored"] == False:
+                    confirmation = get_list_input(
+                        f"Set {get_name_from_database(globals.node_list[globals.selected_node])} as Ignored?",
+                        "No",
+                        ["Yes", "No"],
+                    )
+                    if confirmation == "Yes":
+                        globals.interface.localNode.setIgnored(globals.node_list[globals.selected_node])
+                        globals.interface.nodesByNum[globals.node_list[globals.selected_node]]["isIgnored"] = True
+                else:
+                    confirmation = get_list_input(
+                        f"Remove {get_name_from_database(globals.node_list[globals.selected_node])} from Ignored?",
+                        "No",
+                        ["Yes", "No"],
+                    )
+                    if confirmation == "Yes":
+                        globals.interface.localNode.removeIgnored(globals.node_list[globals.selected_node])
+                        globals.interface.nodesByNum[globals.node_list[globals.selected_node]]["isIgnored"] = False
+
+                handle_resize(stdscr, False)
+
         else:
             # Append typed character to input text
-            if(isinstance(char, str)):
+            if isinstance(char, str):
                 input_text += char
             else:
                 input_text += chr(char)
 
 
-
-def draw_channel_list():
+def draw_channel_list() -> None:
     channel_pad.erase()
     win_height, win_width = channel_win.getmaxyx()
     start_index = max(0, globals.selected_channel - (win_height - 3))  # Leave room for borders
@@ -319,7 +422,7 @@ def draw_channel_list():
         if isinstance(channel, int):
             if is_chat_archived(channel):
                 continue
-            channel_name = get_name_from_database(channel, type='long')
+            channel_name = get_name_from_database(channel, type="long")
             if channel_name is None:
                 continue
             channel = channel_name
@@ -328,7 +431,9 @@ def draw_channel_list():
         notification = " " + config.notification_symbol if idx in globals.notifications else ""
 
         # Truncate the channel name if it's too long to fit in the window
-        truncated_channel = ((channel[:win_width - 5] + '-' if len(channel) > win_width - 5 else channel) + notification).ljust(win_width - 3)
+        truncated_channel = (
+            (channel[: win_width - 5] + "-" if len(channel) > win_width - 5 else channel) + notification
+        ).ljust(win_width - 3)
 
         color = get_color("channel_list")
         if idx == globals.selected_channel:
@@ -340,14 +445,17 @@ def draw_channel_list():
         channel_pad.addstr(idx, 1, truncated_channel, color)
         idx += 1
 
-    channel_win.attrset(get_color("window_frame_selected") if globals.current_window == 0 else get_color("window_frame"))
+    channel_win.attrset(
+        get_color("window_frame_selected") if globals.current_window == 0 else get_color("window_frame")
+    )
     channel_win.box()
     channel_win.attrset((get_color("window_frame")))
     channel_win.refresh()
 
     refresh_pad(0)
 
-def draw_messages_window(scroll_to_bottom = False):
+
+def draw_messages_window(scroll_to_bottom: bool = False) -> None:
     """Update the messages window based on the selected channel and scroll position."""
     messages_pad.erase()
 
@@ -359,7 +467,7 @@ def draw_messages_window(scroll_to_bottom = False):
         msg_line_count = 0
 
         row = 0
-        for (prefix, message) in messages:
+        for prefix, message in messages:
             full_message = f"{prefix}{message}"
             wrapped_lines = textwrap.wrap(full_message, messages_win.getmaxyx()[1] - 2)
             msg_line_count += len(wrapped_lines)
@@ -369,19 +477,21 @@ def draw_messages_window(scroll_to_bottom = False):
                 if prefix.startswith("--"):
                     color = get_color("timestamps")
                 elif prefix.startswith(config.sent_message_prefix):
-                    color = get_color("tx_messages") 
+                    color = get_color("tx_messages")
                 else:
-                    color = get_color("rx_messages") 
-                    
+                    color = get_color("rx_messages")
+
                 messages_pad.addstr(row, 1, line, color)
                 row += 1
 
-    messages_win.attrset(get_color("window_frame_selected") if globals.current_window == 1 else get_color("window_frame"))
+    messages_win.attrset(
+        get_color("window_frame_selected") if globals.current_window == 1 else get_color("window_frame")
+    )
     messages_win.box()
     messages_win.attrset(get_color("window_frame"))
     messages_win.refresh()
 
-    if(scroll_to_bottom):
+    if scroll_to_bottom:
         globals.selected_message = max(msg_line_count - get_msg_window_lines(), 0)
     else:
         globals.selected_message = max(min(globals.selected_message, msg_line_count - get_msg_window_lines()), 0)
@@ -390,28 +500,37 @@ def draw_messages_window(scroll_to_bottom = False):
 
     draw_packetlog_win()
 
-def draw_node_list():
+
+def draw_node_list() -> None:
     global nodes_pad
 
     # This didn't work, for some reason an error is thown on startup, so we just create the pad every time
     # if nodes_pad is None:
-        # nodes_pad = curses.newpad(1, 1)
+    # nodes_pad = curses.newpad(1, 1)
     nodes_pad = curses.newpad(1, 1)
 
-
     try:
         nodes_pad.erase()
         box_width = nodes_win.getmaxyx()[1]
         nodes_pad.resize(len(globals.node_list) + 1, box_width)
-    except Exception as e: 
+    except Exception as e:
         logging.error(f"Error Drawing Nodes List: {e}")
         logging.error("Traceback: %s", traceback.format_exc())
 
     for i, node_num in enumerate(globals.node_list):
         node = globals.interface.nodesByNum[node_num]
-        secure = 'user' in node and 'publicKey' in node['user'] and node['user']['publicKey']
-        node_str = f"{'🔐' if secure else '🔓'} {get_name_from_database(node_num, 'long')}".ljust(box_width - 2)[:box_width - 2]
-        nodes_pad.addstr(i, 1, node_str, get_color("node_list", reverse=globals.selected_node == i and globals.current_window == 2))
+        secure = "user" in node and "publicKey" in node["user"] and node["user"]["publicKey"]
+        node_str = f"{'🔐' if secure else '🔓'} {get_name_from_database(node_num, 'long')}".ljust(box_width - 2)[
+            : box_width - 2
+        ]
+        color = "node_list"
+        if "isFavorite" in node and node["isFavorite"]:
+            color = "node_favorite"
+        if "isIgnored" in node and node["isIgnored"]:
+            color = "node_ignored"
+        nodes_pad.addstr(
+            i, 1, node_str, get_color(color, reverse=globals.selected_node == i and globals.current_window == 2)
+        )
 
     nodes_win.attrset(get_color("window_frame_selected") if globals.current_window == 2 else get_color("window_frame"))
     nodes_win.box()
@@ -425,7 +544,8 @@ def draw_node_list():
     curses.curs_set(1)
     entry_win.refresh()
 
-def select_channel(idx):
+
+def select_channel(idx: int) -> None:
     old_selected_channel = globals.selected_channel
     globals.selected_channel = max(0, min(idx, len(globals.channel_list) - 1))
     draw_messages_window(True)
@@ -439,7 +559,8 @@ def select_channel(idx):
     highlight_line(True, 0, globals.selected_channel)
     refresh_pad(0)
 
-def scroll_channels(direction):
+
+def scroll_channels(direction: int) -> None:
     new_selected_channel = globals.selected_channel + direction
 
     if new_selected_channel < 0:
@@ -449,7 +570,8 @@ def scroll_channels(direction):
 
     select_channel(new_selected_channel)
 
-def scroll_messages(direction):
+
+def scroll_messages(direction: int) -> None:
     globals.selected_message += direction
 
     msg_line_count = messages_pad.getmaxyx()[0]
@@ -457,7 +579,8 @@ def scroll_messages(direction):
 
     refresh_pad(1)
 
-def select_node(idx):
+
+def select_node(idx: int) -> None:
     old_selected_node = globals.selected_node
     globals.selected_node = max(0, min(idx, len(globals.node_list) - 1))
 
@@ -467,7 +590,8 @@ def select_node(idx):
 
     draw_function_win()
 
-def scroll_nodes(direction):
+
+def scroll_nodes(direction: int) -> None:
     new_selected_node = globals.selected_node + direction
 
     if new_selected_node < 0:
@@ -477,46 +601,50 @@ def scroll_nodes(direction):
 
     select_node(new_selected_node)
 
-def draw_packetlog_win():
 
-    columns = [10,10,15,30]
+def draw_packetlog_win() -> None:
+
+    columns = [10, 10, 15, 30]
     span = 0
 
     if globals.display_log:
         packetlog_win.erase()
         height, width = packetlog_win.getmaxyx()
-        
+
         for column in columns[:-1]:
             span += column
 
         # Add headers
         headers = f"{'From':<{columns[0]}} {'To':<{columns[1]}} {'Port':<{columns[2]}} {'Payload':<{width-span}}"
-        packetlog_win.addstr(1, 1, headers[:width - 2],get_color("log_header", underline=True))  # Truncate headers if they exceed window width
+        packetlog_win.addstr(
+            1, 1, headers[: width - 2], get_color("log_header", underline=True)
+        )  # Truncate headers if they exceed window width
 
         for i, packet in enumerate(reversed(globals.packet_buffer)):
             if i >= height - 3:  # Skip if exceeds the window height
                 break
-            
+
             # Format each field
-            from_id = get_name_from_database(packet['from'], 'short').ljust(columns[0])
+            from_id = get_name_from_database(packet["from"], "short").ljust(columns[0])
             to_id = (
-                "BROADCAST".ljust(columns[1]) if str(packet['to']) == "4294967295"
-                else get_name_from_database(packet['to'], 'short').ljust(columns[1])
+                "BROADCAST".ljust(columns[1])
+                if str(packet["to"]) == "4294967295"
+                else get_name_from_database(packet["to"], "short").ljust(columns[1])
             )
-            if 'decoded' in packet:
-                port = packet['decoded']['portnum'].ljust(columns[2])
-                payload = (packet['decoded']['payload']).ljust(columns[3])
+            if "decoded" in packet:
+                port = packet["decoded"]["portnum"].ljust(columns[2])
+                payload = (packet["decoded"]["payload"]).ljust(columns[3])
             else:
                 port = "NO KEY".ljust(columns[2])
                 payload = "NO KEY".ljust(columns[3])
 
             # Combine and truncate if necessary
             logString = f"{from_id} {to_id} {port} {payload}"
-            logString = logString[:width - 3]
+            logString = logString[: width - 3]
 
             # Add to the window
             packetlog_win.addstr(i + 2, 1, logString, get_color("log"))
-            
+
         packetlog_win.attrset(get_color("window_frame"))
         packetlog_win.box()
         packetlog_win.refresh()
@@ -526,7 +654,8 @@ def draw_packetlog_win():
     curses.curs_set(1)
     entry_win.refresh()
 
-def search(win):
+
+def search(win: int) -> None:
     start_idx = globals.selected_node
     select_func = select_node
 
@@ -550,7 +679,7 @@ def search(win):
                 search_text = search_text[:-1]
                 y, x = entry_win.getyx()
                 entry_win.move(y, x - 1)
-                entry_win.addch(' ')  #
+                entry_win.addch(" ")  #
                 entry_win.move(y, x - 1)
                 entry_win.erase()
                 entry_win.refresh()
@@ -561,15 +690,20 @@ def search(win):
 
         l = globals.node_list if win == 2 else globals.channel_list
         for i, n in enumerate(l[start_idx:] + l[:start_idx]):
-            if isinstance(n, int) and search_text_caseless in get_name_from_database(n, 'long').casefold() \
-              or isinstance(n, int) and search_text_caseless in get_name_from_database(n, 'short').casefold() \
-              or search_text_caseless in str(n).casefold():
+            if (
+                isinstance(n, int)
+                and search_text_caseless in get_name_from_database(n, "long").casefold()
+                or isinstance(n, int)
+                and search_text_caseless in get_name_from_database(n, "short").casefold()
+                or search_text_caseless in str(n).casefold()
+            ):
                 select_func((i + start_idx) % len(l))
                 break
 
     entry_win.erase()
 
-def draw_node_details():
+
+def draw_node_details() -> None:
     node = None
     try:
         node = globals.interface.nodesByNum[globals.node_list[globals.selected_node]]
@@ -582,34 +716,48 @@ def draw_node_details():
     nodestr = ""
     width = function_win.getmaxyx()[1]
 
-    node_details_list = [f"{node['user']['longName']} "
-                           if 'user' in node and 'longName' in node['user'] else "",
-                         f"({node['user']['shortName']})"
-                           if 'user' in node and 'shortName' in node['user'] else "",
-                         f" | {node['user']['hwModel']}"
-                           if 'user' in node and 'hwModel' in node['user'] else "",
-                         f" | {node['user']['role']}"
-                           if 'user' in node and 'role' in node['user'] else ""]
+    node_details_list = [
+        f"{node['user']['longName']} " if "user" in node and "longName" in node["user"] else "",
+        f"({node['user']['shortName']})" if "user" in node and "shortName" in node["user"] else "",
+        f" | {node['user']['hwModel']}" if "user" in node and "hwModel" in node["user"] else "",
+        f" | {node['user']['role']}" if "user" in node and "role" in node["user"] else "",
+    ]
 
     if globals.node_list[globals.selected_node] == globals.myNodeNum:
-        node_details_list.extend([f" | Bat: {node['deviceMetrics']['batteryLevel']}% ({node['deviceMetrics']['voltage']}v)"
-                                    if 'deviceMetrics' in node
-                                        and 'batteryLevel' in node['deviceMetrics']
-                                        and 'voltage' in node['deviceMetrics'] else "",
-                                  f" | Up: {get_readable_duration(node['deviceMetrics']['uptimeSeconds'])}" if 'deviceMetrics' in node
-                                        and 'uptimeSeconds' in node['deviceMetrics'] else "",
-                                  f" | ChUtil: {node['deviceMetrics']['channelUtilization']:.2f}%" if 'deviceMetrics' in node
-                                        and 'channelUtilization' in node['deviceMetrics'] else "",
-                                  f" | AirUtilTX: {node['deviceMetrics']['airUtilTx']:.2f}%" if 'deviceMetrics' in node
-                                        and 'airUtilTx' in node['deviceMetrics'] else "",
-                                  ])
+        node_details_list.extend(
+            [
+                (
+                    f" | Bat: {node['deviceMetrics']['batteryLevel']}% ({node['deviceMetrics']['voltage']}v)"
+                    if "deviceMetrics" in node
+                    and "batteryLevel" in node["deviceMetrics"]
+                    and "voltage" in node["deviceMetrics"]
+                    else ""
+                ),
+                (
+                    f" | Up: {get_readable_duration(node['deviceMetrics']['uptimeSeconds'])}"
+                    if "deviceMetrics" in node and "uptimeSeconds" in node["deviceMetrics"]
+                    else ""
+                ),
+                (
+                    f" | ChUtil: {node['deviceMetrics']['channelUtilization']:.2f}%"
+                    if "deviceMetrics" in node and "channelUtilization" in node["deviceMetrics"]
+                    else ""
+                ),
+                (
+                    f" | AirUtilTX: {node['deviceMetrics']['airUtilTx']:.2f}%"
+                    if "deviceMetrics" in node and "airUtilTx" in node["deviceMetrics"]
+                    else ""
+                ),
+            ]
+        )
     else:
-        node_details_list.extend([f" | {get_time_ago(node['lastHeard'])}" if ('lastHeard' in node and node['lastHeard']) else "",
-                                 f" | Hops: {node['hopsAway']}" if 'hopsAway' in node else "",
-                                 f" | SNR: {node['snr']}dB"
-                                   if ('snr' in node and 'hopsAway' in node and node['hopsAway'] == 0)
-                                   else "",
-                                 ])
+        node_details_list.extend(
+            [
+                f" | {get_time_ago(node['lastHeard'])}" if ("lastHeard" in node and node["lastHeard"]) else "",
+                f" | Hops: {node['hopsAway']}" if "hopsAway" in node else "",
+                f" | SNR: {node['snr']}dB" if ("snr" in node and "hopsAway" in node and node["hopsAway"] == 0) else "",
+            ]
+        )
 
     for s in node_details_list:
         if len(nodestr) + len(s) < width - 2:
@@ -617,31 +765,44 @@ def draw_node_details():
 
     draw_centered_text_field(function_win, nodestr, 0, get_color("commands"))
 
-def draw_help():
-    cmds = ["↑→↓← = Select", "    ENTER = Send", "    ` = Settings", "    ^P = Packet Log", "    ESC = Quit", "    ^t = Traceroute", "    ^d = Archive Chat"]
+
+def draw_help() -> None:
+    cmds = [
+        "↑→↓← = Select",
+        "    ENTER = Send",
+        "    ` = Settings",
+        "    ^P = Packet Log",
+        "    ESC = Quit",
+        "    ^t = Traceroute",
+        "    ^d = Archive Chat",
+        "    ^f = Favorite",
+        "    ^g = Ignore",
+    ]
     function_str = ""
     for s in cmds:
-        if(len(function_str) + len(s) < function_win.getmaxyx()[1] - 2):
+        if len(function_str) + len(s) < function_win.getmaxyx()[1] - 2:
             function_str += s
 
     draw_centered_text_field(function_win, function_str, 0, get_color("commands"))
 
-def draw_function_win():
-    if(globals.current_window == 2):
+
+def draw_function_win() -> None:
+    if globals.current_window == 2:
         draw_node_details()
     else:
         draw_help()
 
-def get_msg_window_lines():
+
+def get_msg_window_lines() -> None:
     packetlog_height = packetlog_win.getmaxyx()[0] - 1 if globals.display_log else 0
     return messages_win.getmaxyx()[0] - 2 - packetlog_height
 
-def refresh_pad(window):
-    # global messages_pad, nodes_pad, channel_pad 
-    
+
+def refresh_pad(window: int) -> None:
+
     win_height = channel_win.getmaxyx()[0]
 
-    if(window == 1):
+    if window == 1:
         pad = messages_pad
         box = messages_win
         lines = get_msg_window_lines()
@@ -652,7 +813,7 @@ def refresh_pad(window):
             packetlog_win.box()
             packetlog_win.refresh()
 
-    elif(window == 2):
+    elif window == 2:
         pad = nodes_pad
         box = nodes_win
         lines = box.getmaxyx()[0] - 2
@@ -666,41 +827,63 @@ def refresh_pad(window):
         selected_item = globals.selected_channel
         start_index = max(0, selected_item - (win_height - 3))  # Leave room for borders
 
-    pad.refresh(start_index, 0,
-                        box.getbegyx()[0] + 1, box.getbegyx()[1] + 1,
-                        box.getbegyx()[0] + lines, box.getbegyx()[1] + box.getmaxyx()[1] - 2)
+    pad.refresh(
+        start_index,
+        0,
+        box.getbegyx()[0] + 1,
+        box.getbegyx()[1] + 1,
+        box.getbegyx()[0] + lines,
+        box.getbegyx()[1] + box.getmaxyx()[1] - 2,
+    )
 
-def highlight_line(highlight, window, line):
+
+def highlight_line(highlight: bool, window: int, line: int) -> None:
     pad = nodes_pad
+
     color = get_color("node_list")
     select_len = nodes_win.getmaxyx()[1] - 2
 
-    if(window == 0):
+    if window == 2:
+        node_num = globals.node_list[line]
+        node = globals.interface.nodesByNum[node_num]
+        if "isFavorite" in node and node["isFavorite"]:
+            color = get_color("node_favorite")
+        if "isIgnored" in node and node["isIgnored"]:
+            color = get_color("node_ignored")
+
+    if window == 0:
         pad = channel_pad
-        color = get_color("channel_selected" if (line == globals.selected_channel and highlight == False) else "channel_list")
+        color = get_color(
+            "channel_selected" if (line == globals.selected_channel and highlight == False) else "channel_list"
+        )
         select_len = channel_win.getmaxyx()[1] - 2
 
     pad.chgat(line, 1, select_len, color | curses.A_REVERSE if highlight else color)
 
-def add_notification(channel_number):
+
+def add_notification(channel_number: int) -> None:
     if channel_number not in globals.notifications:
         globals.notifications.append(channel_number)
 
-def remove_notification(channel_number):
+
+def remove_notification(channel_number: int) -> None:
     if channel_number in globals.notifications:
         globals.notifications.remove(channel_number)
 
-def draw_text_field(win, text, color):
+
+def draw_text_field(win: curses.window, text: str, color: int) -> None:
     win.border()
     win.addstr(1, 1, text, color)
 
-def draw_centered_text_field(win, text, y_offset, color):
+
+def draw_centered_text_field(win: curses.window, text: str, y_offset: int, color: int) -> None:
     height, width = win.getmaxyx()
     x = (width - len(text)) // 2
     y = (height // 2) + y_offset
     win.addstr(y, x, text, color)
     win.refresh()
 
-def draw_debug(value):
+
+def draw_debug(value: Union[str, int]) -> None:
     function_win.addstr(1, 1, f"debug: {value}    ")
-    function_win.refresh()
+    function_win.refresh()

contact/ui/control_ui.py

@@ -2,19 +2,27 @@ import base64
 import curses
 import logging
 import os
-import re
 import sys
+from typing import List
 
 from contact.utilities.save_to_radio import save_changes
 from contact.utilities.config_io import config_export, config_import
-from contact.utilities.input_handlers import get_repeated_input, get_text_input, get_fixed32_input, get_list_input, get_admin_key_input
-from contact.ui.menus import generate_menu_from_protobuf
+from contact.utilities.control_utils import parse_ini_file, transform_menu_path
+from contact.utilities.input_handlers import (
+    get_repeated_input,
+    get_text_input,
+    get_fixed32_input,
+    get_list_input,
+    get_admin_key_input,
+)
 from contact.ui.colors import get_color
 from contact.ui.dialog import dialog
-from contact.utilities.control_utils import parse_ini_file, transform_menu_path
+from contact.ui.menus import generate_menu_from_protobuf
+from contact.ui.nav_utils import move_highlight, draw_arrows, update_help_window
 from contact.ui.user_config import json_editor
+from contact.ui.ui_state import MenuState
 
-import contact.localisations
+menu_state = MenuState()
 
 # Constants
 width = 80
@@ -37,17 +45,14 @@ config_folder = os.path.join(locals_dir, "node-configs")
 field_mapping, help_text = parse_ini_file(translation_file)
 
 
-def display_menu(current_menu, menu_path, selected_index, show_save_option, help_text):
+def display_menu(menu_state: MenuState) -> tuple[object, object]:  # curses.window or pad types
+
     min_help_window_height = 6
-    num_items = len(current_menu) + (1 if show_save_option else 0)
-        # Track visible range
-    global start_index
-    if 'start_index' not in globals():
-        start_index = [0]  # Initialize if not set
+    num_items = len(menu_state.current_menu) + (1 if menu_state.show_save_option else 0)
 
     # Determine the available height for the menu
-    max_menu_height = curses.LINES 
-    menu_height = min(max_menu_height - min_help_window_height, num_items + 5)  
+    max_menu_height = curses.LINES
+    menu_height = min(max_menu_height - min_help_window_height, num_items + 5)
     start_y = (curses.LINES - menu_height) // 2 - (min_help_window_height // 2)
     start_x = (curses.COLS - width) // 2
 
@@ -63,305 +68,151 @@ def display_menu(current_menu, menu_path, selected_index, show_save_option, help
     menu_win.border()
     menu_win.keypad(True)
 
-    menu_pad = curses.newpad(len(current_menu) + 1, width - 8)
+    menu_pad = curses.newpad(len(menu_state.current_menu) + 1, width - 8)
     menu_pad.bkgd(get_color("background"))
 
-    header = " > ".join(word.title() for word in menu_path)
+    header = " > ".join(word.title() for word in menu_state.menu_path)
     if len(header) > width - 4:
-        header = header[:width - 7] + "..."
+        header = header[: width - 7] + "..."
     menu_win.addstr(1, 2, header, get_color("settings_breadcrumbs", bold=True))
 
-    transformed_path = transform_menu_path(menu_path)
+    transformed_path = transform_menu_path(menu_state.menu_path)
 
-    for idx, option in enumerate(current_menu):
-        field_info = current_menu[option]
+    for idx, option in enumerate(menu_state.current_menu):
+        field_info = menu_state.current_menu[option]
         current_value = field_info[1] if isinstance(field_info, tuple) else ""
-        full_key = '.'.join(transformed_path + [option])
+        full_key = ".".join(transformed_path + [option])
         display_name = field_mapping.get(full_key, option)
 
-        display_option = f"{display_name}"[:width // 2 - 2]
-        display_value = f"{current_value}"[:width // 2 - 4]
+        display_option = f"{display_name}"[: width // 2 - 2]
+        display_value = f"{current_value}"[: width // 2 - 4]
 
         try:
-            color = get_color("settings_sensitive" if option in sensitive_settings else "settings_default", reverse=(idx == selected_index))
+            color = get_color(
+                "settings_sensitive" if option in sensitive_settings else "settings_default",
+                reverse=(idx == menu_state.selected_index),
+            )
             menu_pad.addstr(idx, 0, f"{display_option:<{width // 2 - 2}} {display_value}".ljust(width - 8), color)
         except curses.error:
             pass
 
-    if show_save_option:
+    if menu_state.show_save_option:
         save_position = menu_height - 2
-        menu_win.addstr(save_position, (width - len(save_option)) // 2, save_option, get_color("settings_save", reverse=(selected_index == len(current_menu))))
+        menu_win.addstr(
+            save_position,
+            (width - len(save_option)) // 2,
+            save_option,
+            get_color("settings_save", reverse=(menu_state.selected_index == len(menu_state.current_menu))),
+        )
 
     # Draw help window with dynamically updated max_help_lines
-    draw_help_window(start_y, start_x, menu_height, max_help_lines, current_menu, selected_index, transformed_path)
+    draw_help_window(start_y, start_x, menu_height, max_help_lines, transformed_path, menu_state)
 
     menu_win.refresh()
     menu_pad.refresh(
-        start_index[-1], 0,
-        menu_win.getbegyx()[0] + 3, menu_win.getbegyx()[1] + 4,
-        menu_win.getbegyx()[0] + 3 + menu_win.getmaxyx()[0] - 5 - (2 if show_save_option else 0),
-        menu_win.getbegyx()[1] + menu_win.getmaxyx()[1] - 8
+        menu_state.start_index[-1],
+        0,
+        menu_win.getbegyx()[0] + 3,
+        menu_win.getbegyx()[1] + 4,
+        menu_win.getbegyx()[0] + 3 + menu_win.getmaxyx()[0] - 5 - (2 if menu_state.show_save_option else 0),
+        menu_win.getbegyx()[1] + menu_win.getmaxyx()[1] - 4,
     )
 
-    max_index = num_items + (1 if show_save_option else 0) - 1
-    visible_height = menu_win.getmaxyx()[0] - 5 - (2 if show_save_option else 0)
+    max_index = num_items + (1 if menu_state.show_save_option else 0) - 1
+    visible_height = menu_win.getmaxyx()[0] - 5 - (2 if menu_state.show_save_option else 0)
 
-    draw_arrows(menu_win, visible_height, max_index, start_index, show_save_option)
+    draw_arrows(menu_win, visible_height, max_index, menu_state.start_index, menu_state.show_save_option)
 
     return menu_win, menu_pad
 
 
-def draw_help_window(menu_start_y, menu_start_x, menu_height, max_help_lines, current_menu, selected_index, transformed_path):
+def draw_help_window(
+    menu_start_y: int,
+    menu_start_x: int,
+    menu_height: int,
+    max_help_lines: int,
+    transformed_path: List[str],
+    menu_state: MenuState,
+) -> None:
+
     global help_win
 
-    if 'help_win' not in globals():
+    if "help_win" not in globals():
         help_win = None  # Initialize if it does not exist
 
-    selected_option = list(current_menu.keys())[selected_index] if current_menu else None
+    selected_option = (
+        list(menu_state.current_menu.keys())[menu_state.selected_index] if menu_state.current_menu else None
+    )
     help_y = menu_start_y + menu_height
 
-    help_win = update_help_window(help_win, help_text, transformed_path, selected_option, max_help_lines, width, help_y, menu_start_x)
-
-def update_help_window(help_win, help_text, transformed_path, selected_option, max_help_lines, width, help_y, help_x):
-    """Handles rendering the help window consistently."""
-    wrapped_help = get_wrapped_help_text(help_text, transformed_path, selected_option, width, max_help_lines)
-
-    help_height = min(len(wrapped_help) + 2, max_help_lines + 2)  # +2 for border
-    help_height = max(help_height, 3)  # Ensure at least 3 rows (1 text + border)
-
-    # Ensure help window does not exceed screen size
-    if help_y + help_height > curses.LINES:
-        help_y = curses.LINES - help_height
-
-    # Create or update the help window
-    if help_win is None:
-        help_win = curses.newwin(help_height, width, help_y, help_x)
-    else:
-        help_win.erase()
-        help_win.refresh()
-        help_win.resize(help_height, width)
-        help_win.mvwin(help_y, help_x)
-
-    help_win.bkgd(get_color("background"))
-    help_win.attrset(get_color("window_frame"))
-    help_win.border()
-
-    for idx, line_segments in enumerate(wrapped_help):
-        x_pos = 2  # Start after border
-        for text, color, bold, underline in line_segments:
-            try:
-                attr = get_color(color, bold=bold, underline=underline)
-                help_win.addstr(1 + idx, x_pos, text, attr)
-                x_pos += len(text)
-            except curses.error:
-                pass  # Prevent crashes
-
-    help_win.refresh()
-    return help_win
+    help_win = update_help_window(
+        help_win, help_text, transformed_path, selected_option, max_help_lines, width, help_y, menu_start_x
+    )
 
 
-def get_wrapped_help_text(help_text, transformed_path, selected_option, width, max_lines):
-    """Fetches and formats help text for display, ensuring it fits within the allowed lines."""
-    
-    full_help_key = '.'.join(transformed_path + [selected_option]) if selected_option else None
-    help_content = help_text.get(full_help_key, "No help available.")
-
-    wrap_width = max(width - 6, 10)  # Ensure a valid wrapping width
-
-    # Color replacements
-    color_mappings = {
-        r'\[warning\](.*?)\[/warning\]': ('settings_warning', True, False),  # Red for warnings
-        r'\[note\](.*?)\[/note\]': ('settings_note', True, False),  # Green for notes
-        r'\[underline\](.*?)\[/underline\]': ('settings_default', False, True),  # Underline
-
-        r'\\033\[31m(.*?)\\033\[0m': ('settings_warning', True, False),  # Red text
-        r'\\033\[32m(.*?)\\033\[0m': ('settings_note', True, False),  # Green text
-        r'\\033\[4m(.*?)\\033\[0m': ('settings_default', False, True)  # Underline
-    }
-
-    def extract_ansi_segments(text):
-        """Extracts and replaces ANSI color codes, ensuring spaces are preserved."""
-        matches = []
-        last_pos = 0
-        pattern_matches = []
-
-        # Find all matches and store their positions
-        for pattern, (color, bold, underline) in color_mappings.items():
-            for match in re.finditer(pattern, text):
-                pattern_matches.append((match.start(), match.end(), match.group(1), color, bold, underline))
-
-        # Sort matches by start position to process sequentially
-        pattern_matches.sort(key=lambda x: x[0])
-
-        for start, end, content, color, bold, underline in pattern_matches:
-            # Preserve non-matching text including spaces
-            if last_pos < start:
-                segment = text[last_pos:start]
-                matches.append((segment, "settings_default", False, False))
-            
-            # Append the colored segment
-            matches.append((content, color, bold, underline))
-            last_pos = end
-
-        # Preserve any trailing text
-        if last_pos < len(text):
-            matches.append((text[last_pos:], "settings_default", False, False))
-
-        return matches
-
-    def wrap_ansi_text(segments, wrap_width):
-        """Wraps text while preserving ANSI formatting and spaces."""
-        wrapped_lines = []
-        line_buffer = []
-        line_length = 0
-
-        for text, color, bold, underline in segments:
-            words = re.findall(r'\S+|\s+', text)  # Capture words and spaces separately
-
-            for word in words:
-                word_length = len(word)
-
-                if line_length + word_length > wrap_width and word.strip():
-                    # If the word (ignoring spaces) exceeds width, wrap the line
-                    wrapped_lines.append(line_buffer)
-                    line_buffer = []
-                    line_length = 0
-
-                line_buffer.append((word, color, bold, underline))
-                line_length += word_length
-
-        if line_buffer:
-            wrapped_lines.append(line_buffer)
-
-        return wrapped_lines
-
-    raw_lines = help_content.split("\\n")  # Preserve new lines
-    wrapped_help = []
-
-    for raw_line in raw_lines:
-        color_segments = extract_ansi_segments(raw_line)
-        wrapped_segments = wrap_ansi_text(color_segments, wrap_width)
-        wrapped_help.extend(wrapped_segments)
-        pass
-
-    # Trim and add ellipsis if needed
-    if len(wrapped_help) > max_lines:
-        wrapped_help = wrapped_help[:max_lines]  
-        wrapped_help[-1].append(("...", "settings_default", False, False))  
-
-    return wrapped_help
-
-
-def move_highlight(old_idx, new_idx, options, show_save_option, menu_win, menu_pad, help_win, help_text, menu_path, max_help_lines):
-    if old_idx == new_idx:  # No-op
-        return
-
-    max_index = len(options) + (1 if show_save_option else 0) - 1
-    visible_height = menu_win.getmaxyx()[0] - 5 - (2 if show_save_option else 0)
-
-    # Adjust start_index only when moving out of visible range
-    if new_idx == max_index and show_save_option:
-        pass
-    elif new_idx < start_index[-1]:  # Moving above the visible area
-        start_index[-1] = new_idx
-    elif new_idx >= start_index[-1] + visible_height:  # Moving below the visible area
-        start_index[-1] = new_idx - visible_height
-    pass
-
-    # Ensure start_index is within bounds
-    start_index[-1] = max(0, min(start_index[-1], max_index - visible_height + 1))
-
-    # Clear old selection
-    if show_save_option and old_idx == max_index:
-        menu_win.chgat(menu_win.getmaxyx()[0] - 2, (width - len(save_option)) // 2, len(save_option), get_color("settings_save"))
-    else:
-        menu_pad.chgat(old_idx, 0, menu_pad.getmaxyx()[1], get_color("settings_sensitive") if options[old_idx] in sensitive_settings else get_color("settings_default"))
-
-    # Highlight new selection
-    if show_save_option and new_idx == max_index:
-        menu_win.chgat(menu_win.getmaxyx()[0] - 2, (width - len(save_option)) // 2, len(save_option), get_color("settings_save", reverse=True))
-    else:
-        menu_pad.chgat(new_idx, 0, menu_pad.getmaxyx()[1], get_color("settings_sensitive", reverse=True) if options[new_idx] in sensitive_settings else get_color("settings_default", reverse=True))
-
-    menu_win.refresh()
-    
-    # Refresh pad only if scrolling is needed
-    menu_pad.refresh(start_index[-1], 0,
-                     menu_win.getbegyx()[0] + 3, menu_win.getbegyx()[1] + 4,
-                     menu_win.getbegyx()[0] + 3 + visible_height, 
-                     menu_win.getbegyx()[1] + menu_win.getmaxyx()[1] - 4)
-
-    # Update help window
-    transformed_path = transform_menu_path(menu_path)
-    selected_option = options[new_idx] if new_idx < len(options) else None
-    help_y = menu_win.getbegyx()[0] + menu_win.getmaxyx()[0]
-    help_win = update_help_window(help_win, help_text, transformed_path, selected_option, max_help_lines, width, help_y, menu_win.getbegyx()[1])
-
-    draw_arrows(menu_win, visible_height, max_index, start_index, show_save_option)
-
-
-def draw_arrows(win, visible_height, max_index, start_index, show_save_option):
-
-    # vh = visible_height + (1 if show_save_option else 0)
-    mi = max_index - (2 if show_save_option else 0) 
-
-    if visible_height < mi:
-        if start_index[-1] > 0:
-            win.addstr(3, 2, "▲", get_color("settings_default"))
-        else:
-            win.addstr(3, 2, " ", get_color("settings_default"))
-
-        if mi - start_index[-1] >= visible_height + (0 if show_save_option else 1) :
-            win.addstr(visible_height + 3, 2, "▼", get_color("settings_default"))
-        else:
-            win.addstr(visible_height + 3, 2, " ", get_color("settings_default"))
-        
-
-def settings_menu(stdscr, interface):
+def settings_menu(stdscr: object, interface: object) -> None:
     curses.update_lines_cols()
 
     menu = generate_menu_from_protobuf(interface)
-    current_menu = menu["Main Menu"]
-    menu_path = ["Main Menu"]
-    menu_index = []
-    selected_index = 0
+    menu_state.current_menu = menu["Main Menu"]
+    menu_state.menu_path = ["Main Menu"]
+
     modified_settings = {}
-    
+
     need_redraw = True
-    show_save_option = False
+    menu_state.show_save_option = False
 
     while True:
-        if(need_redraw):
-            options = list(current_menu.keys())
+        if need_redraw:
+            options = list(menu_state.current_menu.keys())
 
-            show_save_option = (
-                len(menu_path) > 2 and ("Radio Settings" in menu_path or "Module Settings" in menu_path)
-            ) or (
-                len(menu_path) == 2 and "User Settings" in menu_path 
-            ) or (
-                len(menu_path) == 3 and "Channels" in menu_path
+            menu_state.show_save_option = (
+                (
+                    len(menu_state.menu_path) > 2
+                    and ("Radio Settings" in menu_state.menu_path or "Module Settings" in menu_state.menu_path)
+                )
+                or (len(menu_state.menu_path) == 2 and "User Settings" in menu_state.menu_path)
+                or (len(menu_state.menu_path) == 3 and "Channels" in menu_state.menu_path)
             )
 
             # Display the menu
-            menu_win, menu_pad = display_menu(current_menu, menu_path, selected_index, show_save_option, help_text)
+            menu_win, menu_pad = display_menu(menu_state)
 
             need_redraw = False
 
         # Capture user input
         key = menu_win.getch()
 
-        max_index = len(options) + (1 if show_save_option else 0) - 1
+        max_index = len(options) + (1 if menu_state.show_save_option else 0) - 1
         # max_help_lines = 4
 
         if key == curses.KEY_UP:
-            old_selected_index = selected_index
-            selected_index = max_index if selected_index == 0 else selected_index - 1
-            move_highlight(old_selected_index, selected_index, options, show_save_option, menu_win, menu_pad, help_win, help_text, menu_path,max_help_lines)
-            
+            old_selected_index = menu_state.selected_index
+            menu_state.selected_index = max_index if menu_state.selected_index == 0 else menu_state.selected_index - 1
+            move_highlight(
+                old_selected_index,
+                options,
+                menu_win,
+                menu_pad,
+                menu_state=menu_state,
+                help_win=help_win,
+                help_text=help_text,
+                max_help_lines=max_help_lines,
+            )
+
         elif key == curses.KEY_DOWN:
-            old_selected_index = selected_index
-            selected_index = 0 if selected_index == max_index else selected_index + 1
-            move_highlight(old_selected_index, selected_index, options, show_save_option, menu_win, menu_pad, help_win, help_text, menu_path, max_help_lines)
+            old_selected_index = menu_state.selected_index
+            menu_state.selected_index = 0 if menu_state.selected_index == max_index else menu_state.selected_index + 1
+            move_highlight(
+                old_selected_index,
+                options,
+                menu_win,
+                menu_pad,
+                menu_state=menu_state,
+                help_win=help_win,
+                help_text=help_text,
+                max_help_lines=max_help_lines,
+            )
 
         elif key == curses.KEY_RESIZE:
             need_redraw = True
@@ -373,36 +224,45 @@ def settings_menu(stdscr, interface):
             menu_win.refresh()
             help_win.refresh()
 
-        elif key == ord("\t") and show_save_option:
-            old_selected_index = selected_index
-            selected_index = max_index
-            move_highlight(old_selected_index, selected_index, options, show_save_option, menu_win, menu_pad, help_win, help_text, menu_path, max_help_lines)
+        elif key == ord("\t") and menu_state.show_save_option:
+            old_selected_index = menu_state.selected_index
+            menu_state.selected_index = max_index
+            move_highlight(
+                old_selected_index,
+                options,
+                menu_win,
+                menu_pad,
+                menu_state=menu_state,
+                help_win=help_win,
+                help_text=help_text,
+                max_help_lines=max_help_lines,
+            )
 
-        elif key == curses.KEY_RIGHT or key == ord('\n'):
+        elif key == curses.KEY_RIGHT or key == ord("\n"):
             need_redraw = True
-            start_index.append(0)
+            menu_state.start_index.append(0)
             menu_win.erase()
             help_win.erase()
 
-            # draw_help_window(menu_win.getbegyx()[0], menu_win.getbegyx()[1], menu_win.getmaxyx()[0], max_help_lines, current_menu, selected_index, transform_menu_path(menu_path))
+            # draw_help_window(menu_win.getbegyx()[0], menu_win.getbegyx()[1], menu_win.getmaxyx()[0], max_help_lines, menu_state.current_menu, selected_index, transform_menu_path(menu_state.menu_path))
 
             menu_win.refresh()
             help_win.refresh()
 
-            if show_save_option and selected_index == len(options):
-                save_changes(interface, menu_path, modified_settings)
+            if menu_state.show_save_option and menu_state.selected_index == len(options):
+                save_changes(interface, modified_settings, menu_state)
                 modified_settings.clear()
                 logging.info("Changes Saved")
 
-                if len(menu_path) > 1:
-                    menu_path.pop()
-                    current_menu = menu["Main Menu"]
-                    for step in menu_path[1:]:
-                        current_menu = current_menu.get(step, {})
-                    selected_index = 0
+                if len(menu_state.menu_path) > 1:
+                    menu_state.menu_path.pop()
+                    menu_state.current_menu = menu["Main Menu"]
+                    for step in menu_state.menu_path[1:]:
+                        menu_state.current_menu = menu_state.current_menu.get(step, {})
+                    menu_state.selected_index = 0
                 continue
 
-            selected_option = options[selected_index]
+            selected_option = options[menu_state.selected_index]
 
             if selected_option == "Exit":
                 break
@@ -411,7 +271,7 @@ def settings_menu(stdscr, interface):
                 filename = get_text_input("Enter a filename for the config file")
                 if not filename:
                     logging.info("Export aborted: No filename provided.")
-                    start_index.pop()
+                    menu_state.start_index.pop()
                     continue  # Go back to the menu
                 if not filename.lower().endswith(".yaml"):
                     filename += ".yaml"
@@ -424,14 +284,14 @@ def settings_menu(stdscr, interface):
                         overwrite = get_list_input(f"{filename} already exists. Overwrite?", None, ["Yes", "No"])
                         if overwrite == "No":
                             logging.info("Export cancelled: User chose not to overwrite.")
-                            start_index.pop()
+                            menu_state.start_index.pop()
                             continue  # Return to menu
                     os.makedirs(os.path.dirname(yaml_file_path), exist_ok=True)
                     with open(yaml_file_path, "w", encoding="utf-8") as file:
                         file.write(config_text)
                     logging.info(f"Config file saved to {yaml_file_path}")
                     dialog(stdscr, "Config File Saved:", yaml_file_path)
-                    start_index.pop()
+                    menu_state.start_index.pop()
                     continue
                 except PermissionError:
                     logging.error(f"Permission denied: Unable to write to {yaml_file_path}")
@@ -439,9 +299,9 @@ def settings_menu(stdscr, interface):
                     logging.error(f"OS error while saving config: {e}")
                 except Exception as e:
                     logging.error(f"Unexpected error: {e}")
-                start_index.pop()
+                menu_state.start_index.pop()
                 continue
-                
+
             elif selected_option == "Load Config File":
 
                 # Check if folder exists and is not empty
@@ -462,7 +322,7 @@ def settings_menu(stdscr, interface):
                     overwrite = get_list_input(f"Are you sure you want to load {filename}?", None, ["Yes", "No"])
                     if overwrite == "Yes":
                         config_import(interface, file_path)
-                start_index.pop()
+                menu_state.start_index.pop()
                 continue
 
             elif selected_option == "Config URL":
@@ -474,23 +334,23 @@ def settings_menu(stdscr, interface):
                     if overwrite == "Yes":
                         interface.localNode.setURL(new_value)
                         logging.info(f"New Config URL sent to node")
-                start_index.pop()
+                menu_state.start_index.pop()
                 continue
 
             elif selected_option == "Reboot":
-                confirmation = get_list_input("Are you sure you want to Reboot?", None,  ["Yes", "No"])
+                confirmation = get_list_input("Are you sure you want to Reboot?", None, ["Yes", "No"])
                 if confirmation == "Yes":
                     interface.localNode.reboot()
                     logging.info(f"Node Reboot Requested by menu")
-                start_index.pop()
+                menu_state.start_index.pop()
                 continue
 
             elif selected_option == "Reset Node DB":
-                confirmation = get_list_input("Are you sure you want to Reset Node DB?", None,  ["Yes", "No"])
+                confirmation = get_list_input("Are you sure you want to Reset Node DB?", None, ["Yes", "No"])
                 if confirmation == "Yes":
                     interface.localNode.resetNodeDb()
                     logging.info(f"Node DB Reset Requested by menu")
-                start_index.pop()
+                menu_state.start_index.pop()
                 continue
 
             elif selected_option == "Shutdown":
@@ -498,103 +358,116 @@ def settings_menu(stdscr, interface):
                 if confirmation == "Yes":
                     interface.localNode.shutdown()
                     logging.info(f"Node Shutdown Requested by menu")
-                start_index.pop()
+                menu_state.start_index.pop()
                 continue
 
             elif selected_option == "Factory Reset":
-                confirmation = get_list_input("Are you sure you want to Factory Reset?", None,  ["Yes", "No"])
+                confirmation = get_list_input("Are you sure you want to Factory Reset?", None, ["Yes", "No"])
                 if confirmation == "Yes":
                     interface.localNode.factoryReset()
                     logging.info(f"Factory Reset Requested by menu")
-                start_index.pop()
+                menu_state.start_index.pop()
                 continue
 
             elif selected_option == "App Settings":
                 menu_win.clear()
                 menu_win.refresh()
-                json_editor(stdscr)  # Open the App Settings menu
+                menu_state.menu_path.append("App Settings")
+                menu_state.menu_index.append(menu_state.selected_index)
+                json_editor(stdscr, menu_state)  # Open the App Settings menu
+                menu_state.current_menu = menu["Main Menu"]
+                menu_state.menu_path = ["Main Menu"]
+                menu_state.start_index.pop()
+                menu_state.selected_index = 4
                 continue
                 # need_redraw = True
-                
-            field_info = current_menu.get(selected_option)
+
+            field_info = menu_state.current_menu.get(selected_option)
             if isinstance(field_info, tuple):
                 field, current_value = field_info
 
                 # Transform the menu path to get the full key
-                transformed_path = transform_menu_path(menu_path)
-                full_key = '.'.join(transformed_path + [selected_option])
+                transformed_path = transform_menu_path(menu_state.menu_path)
+                full_key = ".".join(transformed_path + [selected_option])
 
                 # Fetch human-readable name from field_mapping
                 human_readable_name = field_mapping.get(full_key, selected_option)
 
-                if selected_option in ['longName', 'shortName', 'isLicensed']:
-                    if selected_option in ['longName', 'shortName']:
+                if selected_option in ["longName", "shortName", "isLicensed"]:
+                    if selected_option in ["longName", "shortName"]:
                         new_value = get_text_input(f"{human_readable_name} is currently: {current_value}")
                         new_value = current_value if new_value is None else new_value
-                        current_menu[selected_option] = (field, new_value)
+                        menu_state.current_menu[selected_option] = (field, new_value)
 
-                    elif selected_option == 'isLicensed':
-                        new_value = get_list_input(f"{human_readable_name} is currently: {current_value}", str(current_value),  ["True", "False"])
+                    elif selected_option == "isLicensed":
+                        new_value = get_list_input(
+                            f"{human_readable_name} is currently: {current_value}",
+                            str(current_value),
+                            ["True", "False"],
+                        )
                         new_value = new_value == "True"
-                        current_menu[selected_option] = (field, new_value)
+                        menu_state.current_menu[selected_option] = (field, new_value)
 
-                    for option, (field, value) in current_menu.items():
+                    for option, (field, value) in menu_state.current_menu.items():
                         modified_settings[option] = value
 
-                    start_index.pop()
+                    menu_state.start_index.pop()
 
-                elif selected_option in ['latitude', 'longitude', 'altitude']:
+                elif selected_option in ["latitude", "longitude", "altitude"]:
                     new_value = get_text_input(f"{human_readable_name} is currently: {current_value}")
                     new_value = current_value if new_value is None else new_value
-                    current_menu[selected_option] = (field, new_value)
+                    menu_state.current_menu[selected_option] = (field, new_value)
 
-                    for option in ['latitude', 'longitude', 'altitude']:
-                        if option in current_menu:
-                            modified_settings[option] = current_menu[option][1]
+                    for option in ["latitude", "longitude", "altitude"]:
+                        if option in menu_state.current_menu:
+                            modified_settings[option] = menu_state.current_menu[option][1]
 
-                    start_index.pop()
+                    menu_state.start_index.pop()
 
                 elif selected_option == "admin_key":
                     new_values = get_admin_key_input(current_value)
                     new_value = current_value if new_values is None else [base64.b64decode(key) for key in new_values]
-                    start_index.pop()
+                    menu_state.start_index.pop()
 
                 elif field.type == 8:  # Handle boolean type
-                    new_value = get_list_input(human_readable_name, str(current_value),  ["True", "False"])
-                    new_value = new_value == "True" or new_value is True
-                    start_index.pop()
+                    new_value = get_list_input(human_readable_name, str(current_value), ["True", "False"])
+                    if new_value == "Not Set":
+                        pass  # Leave it as-is
+                    else:
+                        new_value = new_value == "True" or new_value is True
+                    menu_state.start_index.pop()
 
                 elif field.label == field.LABEL_REPEATED:  # Handle repeated field - Not currently used
                     new_value = get_repeated_input(current_value)
                     new_value = current_value if new_value is None else new_value.split(", ")
-                    start_index.pop()
+                    menu_state.start_index.pop()
 
                 elif field.enum_type:  # Enum field
                     enum_options = {v.name: v.number for v in field.enum_type.values}
                     new_value_name = get_list_input(human_readable_name, current_value, list(enum_options.keys()))
                     new_value = enum_options.get(new_value_name, current_value)
-                    start_index.pop()
+                    menu_state.start_index.pop()
 
-                elif field.type == 7: # Field type 7 corresponds to FIXED32
+                elif field.type == 7:  # Field type 7 corresponds to FIXED32
                     new_value = get_fixed32_input(current_value)
-                    start_index.pop()
+                    menu_state.start_index.pop()
 
-                elif field.type == 13: # Field type 13 corresponds to UINT32
+                elif field.type == 13:  # Field type 13 corresponds to UINT32
                     new_value = get_text_input(f"{human_readable_name} is currently: {current_value}")
                     new_value = current_value if new_value is None else int(new_value)
-                    start_index.pop()
+                    menu_state.start_index.pop()
 
-                elif field.type == 2: # Field type 13 corresponds to INT64
+                elif field.type == 2:  # Field type 13 corresponds to INT64
                     new_value = get_text_input(f"{human_readable_name} is currently: {current_value}")
                     new_value = current_value if new_value is None else float(new_value)
-                    start_index.pop()
+                    menu_state.start_index.pop()
 
                 else:  # Handle other field types
                     new_value = get_text_input(f"{human_readable_name} is currently: {current_value}")
                     new_value = current_value if new_value is None else new_value
-                    start_index.pop()
-                
-                for key in menu_path[3:]:  # Skip "Main Menu"
+                    menu_state.start_index.pop()
+
+                for key in menu_state.menu_path[3:]:  # Skip "Main Menu"
                     modified_settings = modified_settings.setdefault(key, {})
 
                 # Add the new value to the appropriate level
@@ -605,13 +478,12 @@ def settings_menu(stdscr, interface):
                     enum_value_descriptor = field.enum_type.values_by_number.get(new_value)
                     new_value = enum_value_descriptor.name if enum_value_descriptor else new_value
 
-                current_menu[selected_option] = (field, new_value)
+                menu_state.current_menu[selected_option] = (field, new_value)
             else:
-                current_menu = current_menu[selected_option]
-                menu_path.append(selected_option)
-                menu_index.append(selected_index)
-                selected_index = 0
-
+                menu_state.current_menu = menu_state.current_menu[selected_option]
+                menu_state.menu_path.append(selected_option)
+                menu_state.menu_index.append(menu_state.selected_index)
+                menu_state.selected_index = 0
 
         elif key == curses.KEY_LEFT:
             need_redraw = True
@@ -620,30 +492,31 @@ def settings_menu(stdscr, interface):
             help_win.erase()
 
             # max_help_lines = 4
-            # draw_help_window(menu_win.getbegyx()[0], menu_win.getbegyx()[1], menu_win.getmaxyx()[0], max_help_lines, current_menu, selected_index, transform_menu_path(menu_path))
+            # draw_help_window(menu_win.getbegyx()[0], menu_win.getbegyx()[1], menu_win.getmaxyx()[0], max_help_lines, menu_state.current_menu, selected_index, transform_menu_path(menu_state.menu_path))
 
             menu_win.refresh()
             help_win.refresh()
 
-            if len(menu_path) < 2:
+            if len(menu_state.menu_path) < 2:
                 modified_settings.clear()
 
             # Navigate back to the previous menu
-            if len(menu_path) > 1:
-                menu_path.pop()
-                current_menu = menu["Main Menu"]
-                for step in menu_path[1:]:
-                    current_menu = current_menu.get(step, {})
-                selected_index = menu_index.pop()
-                start_index.pop()
-                
+            if len(menu_state.menu_path) > 1:
+                menu_state.menu_path.pop()
+                menu_state.current_menu = menu["Main Menu"]
+                for step in menu_state.menu_path[1:]:
+                    menu_state.current_menu = menu_state.current_menu.get(step, {})
+                menu_state.selected_index = menu_state.menu_index.pop()
+                menu_state.start_index.pop()
+
         elif key == 27:  # Escape key
             menu_win.erase()
             menu_win.refresh()
             break
 
-def set_region(interface):
-    node = interface.getNode('^local')
+
+def set_region(interface: object) -> None:
+    node = interface.getNode("^local")
     device_config = node.localConfig
     lora_descriptor = device_config.lora.DESCRIPTOR
 
@@ -653,10 +526,10 @@ def set_region(interface):
 
     regions = list(region_name_to_number.keys())
 
-    new_region_name = get_list_input('Select your region:', 'UNSET', regions)
+    new_region_name = get_list_input("Select your region:", "UNSET", regions)
 
     # Convert region name to corresponding enum number
     new_region_number = region_name_to_number.get(new_region_name, 0)  # Default to 0 if not found
 
     node.localConfig.lora.region = new_region_number
-    node.writeConfig("lora")
+    node.writeConfig("lora")

contact/ui/default_config.py

@@ -1,6 +1,7 @@
-import logging
 import json
+import logging
 import os
+from typing import Dict
 
 # Get the parent directory of the script
 script_dir = os.path.dirname(os.path.abspath(__file__))
@@ -11,17 +12,17 @@ json_file_path = os.path.join(parent_dir, "config.json")
 log_file_path = os.path.join(parent_dir, "client.log")
 db_file_path = os.path.join(parent_dir, "client.db")
 
-def format_json_single_line_arrays(data, indent=4):
+
+def format_json_single_line_arrays(data: Dict[str, object], indent: int = 4) -> str:
     """
     Formats JSON with arrays on a single line while keeping other elements properly indented.
     """
-    def format_value(value, current_indent):
+
+    def format_value(value: object, current_indent: int) -> str:
         if isinstance(value, dict):
             items = []
             for key, val in value.items():
-                items.append(
-                    f'{" " * current_indent}"{key}": {format_value(val, current_indent + indent)}'
-                )
+                items.append(f'{" " * current_indent}"{key}": {format_value(val, current_indent + indent)}')
             return "{\n" + ",\n".join(items) + f"\n{' ' * (current_indent - indent)}}}"
         elif isinstance(value, list):
             return f"[{', '.join(json.dumps(el, ensure_ascii=False) for el in value)}]"
@@ -30,8 +31,9 @@ def format_json_single_line_arrays(data, indent=4):
 
     return format_value(data, indent)
 
+
 # Recursive function to check and update nested dictionaries
-def update_dict(default, actual):
+def update_dict(default: Dict[str, object], actual: Dict[str, object]) -> bool:
     updated = False
     for key, value in default.items():
         if key not in actual:
@@ -42,7 +44,8 @@ def update_dict(default, actual):
             updated = update_dict(value, actual[key]) or updated
     return updated
 
-def initialize_config():
+
+def initialize_config() -> Dict[str, object]:
     COLOR_CONFIG_DARK = {
         "default": ["white", "black"],
         "background": [" ", "black"],
@@ -65,7 +68,9 @@ def initialize_config():
         "settings_save": ["green", "black"],
         "settings_breadcrumbs": ["white", "black"],
         "settings_warning": ["red", "black"],
-        "settings_note": ["green", "black"]
+        "settings_note": ["green", "black"],
+        "node_favorite": ["green", "black"],
+        "node_ignored": ["red", "black"],
     }
     COLOR_CONFIG_LIGHT = {
         "default": ["black", "white"],
@@ -89,7 +94,9 @@ def initialize_config():
         "settings_save": ["green", "white"],
         "settings_breadcrumbs": ["black", "white"],
         "settings_warning": ["red", "white"],
-        "settings_note": ["green", "white"]
+        "settings_note": ["green", "white"],
+        "node_favorite": ["green", "white"],
+        "node_ignored": ["red", "white"],
     }
     COLOR_CONFIG_GREEN = {
         "default": ["green", "black"],
@@ -115,7 +122,9 @@ def initialize_config():
         "settings_save": ["green", "black"],
         "settings_breadcrumbs": ["green", "black"],
         "settings_warning": ["green", "black"],
-        "settings_note": ["green", "black"]
+        "settings_note": ["green", "black"],
+        "node_favorite": ["cyan", "white"],
+        "node_ignored": ["red", "white"],
     }
     default_config_variables = {
         "db_file_path": db_file_path,
@@ -131,7 +140,7 @@ def initialize_config():
         "theme": "dark",
         "COLOR_CONFIG_DARK": COLOR_CONFIG_DARK,
         "COLOR_CONFIG_LIGHT": COLOR_CONFIG_LIGHT,
-        "COLOR_CONFIG_GREEN": COLOR_CONFIG_GREEN
+        "COLOR_CONFIG_GREEN": COLOR_CONFIG_GREEN,
     }
 
     if not os.path.exists(json_file_path):
@@ -148,16 +157,17 @@ def initialize_config():
 
     # Update the JSON file if any variables were missing
     if updated:
-            formatted_json = format_json_single_line_arrays(loaded_config)
-            with open(json_file_path, "w", encoding="utf-8") as json_file:
-                json_file.write(formatted_json)
-            logging.info(f"JSON file updated with missing default variables and COLOR_CONFIG items.")
+        formatted_json = format_json_single_line_arrays(loaded_config)
+        with open(json_file_path, "w", encoding="utf-8") as json_file:
+            json_file.write(formatted_json)
+        logging.info(f"JSON file updated with missing default variables and COLOR_CONFIG items.")
 
     return loaded_config
 
-def assign_config_variables(loaded_config):
+
+def assign_config_variables(loaded_config: Dict[str, object]) -> None:
     # Assign values to local variables
-    
+
     global db_file_path, log_file_path, message_prefix, sent_message_prefix
     global notification_symbol, ack_implicit_str, ack_str, nak_str, ack_unknown_str
     global theme, COLOR_CONFIG
@@ -188,9 +198,9 @@ assign_config_variables(loaded_config)
 
 if __name__ == "__main__":
     logging.basicConfig(
-    filename="default_config.log",
-    level=logging.INFO,  # DEBUG, INFO, WARNING, ERROR, CRITICAL)
-    format="%(asctime)s - %(levelname)s - %(message)s"
+        filename="default_config.log",
+        level=logging.INFO,  # DEBUG, INFO, WARNING, ERROR, CRITICAL)
+        format="%(asctime)s - %(levelname)s - %(message)s",
     )
     print("\nLoaded Configuration:")
     print(f"Database File Path: {db_file_path}")
@@ -202,4 +212,4 @@ if __name__ == "__main__":
     print(f"ACK String: {ack_str}")
     print(f"NAK String: {nak_str}")
     print(f"ACK Unknown String: {ack_unknown_str}")
-    print(f"Color Config: {COLOR_CONFIG}")
+    print(f"Color Config: {COLOR_CONFIG}")

contact/ui/dialog.py

@@ -1,7 +1,8 @@
 import curses
 from contact.ui.colors import get_color
 
-def dialog(stdscr, title, message):
+
+def dialog(stdscr: curses.window, title: str, message: str) -> None:
     height, width = stdscr.getmaxyx()
 
     # Calculate dialog dimensions
@@ -37,7 +38,7 @@ def dialog(stdscr, title, message):
     while True:
         char = win.getch()
         # Close dialog with enter, space, or esc
-        if char in(curses.KEY_ENTER, 10, 13, 32, 27):
+        if char in (curses.KEY_ENTER, 10, 13, 32, 27):
             win.erase()
             win.refresh()
             return

contact/ui/menus.py

@@ -1,29 +1,44 @@
-from collections import OrderedDict
-from meshtastic.protobuf import config_pb2, module_config_pb2, channel_pb2
-import logging
 import base64
+import logging
 import os
+from collections import OrderedDict
+
+from typing import Any, Union, Dict
+
+from google.protobuf.message import Message
+from meshtastic.protobuf import channel_pb2, config_pb2, module_config_pb2
+
 
 locals_dir = os.path.dirname(os.path.abspath(__file__))
 translation_file = os.path.join(locals_dir, "localisations", "en.ini")
 
-def encode_if_bytes(value):
+
+def encode_if_bytes(value: Any) -> str:
     """Encode byte values to base64 string."""
     if isinstance(value, bytes):
-        return base64.b64encode(value).decode('utf-8')
+        return base64.b64encode(value).decode("utf-8")
     return value
 
-def extract_fields(message_instance, current_config=None):
+
+def extract_fields(
+    message_instance: Message, current_config: Union[Message, Dict[str, Any], None] = None
+) -> Dict[str, Any]:
     if isinstance(current_config, dict):  # Handle dictionaries
         return {key: (None, encode_if_bytes(current_config.get(key, "Not Set"))) for key in current_config}
-    
+
     if not hasattr(message_instance, "DESCRIPTOR"):
         return {}
-    
+
     menu = {}
     fields = message_instance.DESCRIPTOR.fields
     for field in fields:
-        skip_fields = ["sessionkey", "ChannelSettings.channel_num", "ChannelSettings.id", "LoRaConfig.ignore_incoming", "DeviceUIConfig.version"]
+        skip_fields = [
+            "sessionkey",
+            "ChannelSettings.channel_num",
+            "ChannelSettings.id",
+            "LoRaConfig.ignore_incoming",
+            "DeviceUIConfig.version",
+        ]
         if any(skip_field in field.full_name for skip_field in skip_fields):
             continue
 
@@ -47,7 +62,11 @@ def extract_fields(message_instance, current_config=None):
             menu[field.name] = (field, encode_if_bytes(current_value))
     return menu
 
-def generate_menu_from_protobuf(interface):
+
+def generate_menu_from_protobuf(interface: object) -> Dict[str, Any]:
+    """
+    Builds the full settings menu structure from the protobuf definitions.
+    """
     menu_structure = {"Main Menu": {}}
 
     # Add User Settings
@@ -59,7 +78,7 @@ def generate_menu_from_protobuf(interface):
             menu_structure["Main Menu"]["User Settings"] = {
                 "longName": (None, current_user_config.get("longName", "Not Set")),
                 "shortName": (None, current_user_config.get("shortName", "Not Set")),
-                "isLicensed": (None, current_user_config.get("isLicensed", "False"))
+                "isLicensed": (None, current_user_config.get("isLicensed", "False")),
             }
         else:
             logging.info("User settings not found in Node Info")
@@ -87,7 +106,7 @@ def generate_menu_from_protobuf(interface):
     position_data = {
         "latitude": (None, current_node_info["position"].get("latitude", 0.0)),
         "longitude": (None, current_node_info["position"].get("longitude", 0.0)),
-        "altitude": (None, current_node_info["position"].get("altitude", 0))
+        "altitude": (None, current_node_info["position"].get("altitude", 0)),
     }
 
     existing_position_menu = menu_structure["Main Menu"]["Radio Settings"].get("position", {})
@@ -106,20 +125,22 @@ def generate_menu_from_protobuf(interface):
     module = module_config_pb2.ModuleConfig()
     current_module_config = interface.localNode.moduleConfig if interface else None
     menu_structure["Main Menu"]["Module Settings"] = extract_fields(module, current_module_config)
-    
+
     # Add App Settings
     menu_structure["Main Menu"]["App Settings"] = {"Open": "app_settings"}
 
     # Additional settings options
-    menu_structure["Main Menu"].update({
-        "Export Config File": None,
-        "Load Config File": None,
-        "Config URL": None,
-        "Reboot": None,
-        "Reset Node DB": None,
-        "Shutdown": None,
-        "Factory Reset": None,
-        "Exit": None
-    })
+    menu_structure["Main Menu"].update(
+        {
+            "Export Config File": None,
+            "Load Config File": None,
+            "Config URL": None,
+            "Reboot": None,
+            "Reset Node DB": None,
+            "Shutdown": None,
+            "Factory Reset": None,
+            "Exit": None,
+        }
+    )
 
     return menu_structure

contact/ui/nav_utils.py

@@ -0,0 +1,318 @@
+import curses
+import re
+from contact.ui.colors import get_color
+from contact.utilities.control_utils import transform_menu_path
+from typing import Any, Optional, List, Dict
+
+# Aliases
+Segment = tuple[str, str, bool, bool]
+WrappedLine = List[Segment]
+
+width = 80
+sensitive_settings = ["Reboot", "Reset Node DB", "Shutdown", "Factory Reset"]
+save_option = "Save Changes"
+
+
+def move_highlight(
+    old_idx: int, options: List[str], menu_win: curses.window, menu_pad: curses.window, **kwargs: Any
+) -> None:
+
+    show_save_option = None
+    start_index = [0]
+    help_text = None
+    max_help_lines = 0
+    help_win = None
+
+    if "help_win" in kwargs:
+        help_win = kwargs["help_win"]
+
+    if "menu_state" in kwargs:
+        new_idx = kwargs["menu_state"].selected_index
+        show_save_option = kwargs["menu_state"].show_save_option
+        start_index = kwargs["menu_state"].start_index
+        transformed_path = transform_menu_path(kwargs["menu_state"].menu_path)
+    else:
+        new_idx = kwargs["selected_index"]
+        transformed_path = []
+
+    if "help_text" in kwargs:
+        help_text = kwargs["help_text"]
+
+    if "max_help_lines" in kwargs:
+        max_help_lines = kwargs["max_help_lines"]
+    if old_idx == new_idx:  # No-op
+        return
+
+    max_index = len(options) + (1 if show_save_option else 0) - 1
+    visible_height = menu_win.getmaxyx()[0] - 5 - (2 if show_save_option else 0)
+
+    # Adjust menu_state.start_index only when moving out of visible range
+    if new_idx == max_index and show_save_option:
+        pass
+    elif new_idx < start_index[-1]:  # Moving above the visible area
+        start_index[-1] = new_idx
+    elif new_idx >= start_index[-1] + visible_height:  # Moving below the visible area
+        start_index[-1] = new_idx - visible_height
+
+    # Ensure menu_state.start_index is within bounds
+    start_index[-1] = max(0, min(start_index[-1], max_index - visible_height + 1))
+
+    # Clear old selection
+    if show_save_option and old_idx == max_index:
+        menu_win.chgat(
+            menu_win.getmaxyx()[0] - 2, (width - len(save_option)) // 2, len(save_option), get_color("settings_save")
+        )
+    else:
+        menu_pad.chgat(
+            old_idx,
+            0,
+            menu_pad.getmaxyx()[1],
+            (
+                get_color("settings_sensitive")
+                if options[old_idx] in sensitive_settings
+                else get_color("settings_default")
+            ),
+        )
+
+    # Highlight new selection
+    if show_save_option and new_idx == max_index:
+        menu_win.chgat(
+            menu_win.getmaxyx()[0] - 2,
+            (width - len(save_option)) // 2,
+            len(save_option),
+            get_color("settings_save", reverse=True),
+        )
+    else:
+        menu_pad.chgat(
+            new_idx,
+            0,
+            menu_pad.getmaxyx()[1],
+            (
+                get_color("settings_sensitive", reverse=True)
+                if options[new_idx] in sensitive_settings
+                else get_color("settings_default", reverse=True)
+            ),
+        )
+
+    menu_win.refresh()
+
+    # Refresh pad only if scrolling is needed
+    menu_pad.refresh(
+        start_index[-1],
+        0,
+        menu_win.getbegyx()[0] + 3,
+        menu_win.getbegyx()[1] + 4,
+        menu_win.getbegyx()[0] + 3 + visible_height,
+        menu_win.getbegyx()[1] + menu_win.getmaxyx()[1] - 4,
+    )
+
+    # Update help window only if help_text is populated
+    selected_option = options[new_idx] if new_idx < len(options) else None
+    help_y = menu_win.getbegyx()[0] + menu_win.getmaxyx()[0]
+    if help_win:
+        help_win = update_help_window(
+            help_win,
+            help_text,
+            transformed_path,
+            selected_option,
+            max_help_lines,
+            width,
+            help_y,
+            menu_win.getbegyx()[1],
+        )
+
+    draw_arrows(menu_win, visible_height, max_index, start_index, show_save_option)
+
+
+def draw_arrows(
+    win: object, visible_height: int, max_index: int, start_index: List[int], show_save_option: bool
+) -> None:
+
+    # vh = visible_height + (1 if show_save_option else 0)
+    mi = max_index - (2 if show_save_option else 0)
+
+    if visible_height < mi:
+        if start_index[-1] > 0:
+            win.addstr(3, 2, "▲", get_color("settings_default"))
+        else:
+            win.addstr(3, 2, " ", get_color("settings_default"))
+
+        if mi - start_index[-1] >= visible_height + (0 if show_save_option else 1):
+            win.addstr(visible_height + 3, 2, "▼", get_color("settings_default"))
+        else:
+            win.addstr(visible_height + 3, 2, " ", get_color("settings_default"))
+
+
+def update_help_window(
+    help_win: object,  # curses window or None
+    help_text: Dict[str, str],
+    transformed_path: List[str],
+    selected_option: Optional[str],
+    max_help_lines: int,
+    width: int,
+    help_y: int,
+    help_x: int,
+) -> object:  # returns a curses window
+    """Handles rendering the help window consistently."""
+    wrapped_help = get_wrapped_help_text(help_text, transformed_path, selected_option, width, max_help_lines)
+
+    help_height = min(len(wrapped_help) + 2, max_help_lines + 2)  # +2 for border
+    help_height = max(help_height, 3)  # Ensure at least 3 rows (1 text + border)
+
+    # Ensure help window does not exceed screen size
+    if help_y + help_height > curses.LINES:
+        help_y = curses.LINES - help_height
+
+    # Create or update the help window
+    if help_win is None:
+        help_win = curses.newwin(help_height, width, help_y, help_x)
+    else:
+        help_win.erase()
+        help_win.refresh()
+        help_win.resize(help_height, width)
+        help_win.mvwin(help_y, help_x)
+
+    help_win.bkgd(get_color("background"))
+    help_win.attrset(get_color("window_frame"))
+    help_win.border()
+
+    for idx, line_segments in enumerate(wrapped_help):
+        x_pos = 2  # Start after border
+        for text, color, bold, underline in line_segments:
+            try:
+                attr = get_color(color, bold=bold, underline=underline)
+                help_win.addstr(1 + idx, x_pos, text, attr)
+                x_pos += len(text)
+            except curses.error:
+                pass  # Prevent crashes
+
+    help_win.refresh()
+    return help_win
+
+
+def get_wrapped_help_text(
+    help_text: Dict[str, str], transformed_path: List[str], selected_option: Optional[str], width: int, max_lines: int
+) -> List[WrappedLine]:
+    """Fetches and formats help text for display, ensuring it fits within the allowed lines."""
+
+    full_help_key = ".".join(transformed_path + [selected_option]) if selected_option else None
+    help_content = help_text.get(full_help_key, "No help available.")
+
+    wrap_width = max(width - 6, 10)  # Ensure a valid wrapping width
+
+    # Color replacements
+    color_mappings = {
+        r"\[warning\](.*?)\[/warning\]": ("settings_warning", True, False),  # Red for warnings
+        r"\[note\](.*?)\[/note\]": ("settings_note", True, False),  # Green for notes
+        r"\[underline\](.*?)\[/underline\]": ("settings_default", False, True),  # Underline
+        r"\\033\[31m(.*?)\\033\[0m": ("settings_warning", True, False),  # Red text
+        r"\\033\[32m(.*?)\\033\[0m": ("settings_note", True, False),  # Green text
+        r"\\033\[4m(.*?)\\033\[0m": ("settings_default", False, True),  # Underline
+    }
+
+    def extract_ansi_segments(text: str) -> List[Segment]:
+        """Extracts and replaces ANSI color codes, ensuring spaces are preserved."""
+        matches = []
+        last_pos = 0
+        pattern_matches = []
+
+        # Find all matches and store their positions
+        for pattern, (color, bold, underline) in color_mappings.items():
+            for match in re.finditer(pattern, text):
+                pattern_matches.append((match.start(), match.end(), match.group(1), color, bold, underline))
+
+        # Sort matches by start position to process sequentially
+        pattern_matches.sort(key=lambda x: x[0])
+
+        for start, end, content, color, bold, underline in pattern_matches:
+            # Preserve non-matching text including spaces
+            if last_pos < start:
+                segment = text[last_pos:start]
+                matches.append((segment, "settings_default", False, False))
+
+            # Append the colored segment
+            matches.append((content, color, bold, underline))
+            last_pos = end
+
+        # Preserve any trailing text
+        if last_pos < len(text):
+            matches.append((text[last_pos:], "settings_default", False, False))
+
+        return matches
+
+    def wrap_ansi_text(segments: List[Segment], wrap_width: int) -> List[WrappedLine]:
+        """Wraps text while preserving ANSI formatting and spaces."""
+        wrapped_lines = []
+        line_buffer = []
+        line_length = 0
+
+        for text, color, bold, underline in segments:
+            words = re.findall(r"\S+|\s+", text)  # Capture words and spaces separately
+
+            for word in words:
+                word_length = len(word)
+
+                if line_length + word_length > wrap_width and word.strip():
+                    # If the word (ignoring spaces) exceeds width, wrap the line
+                    wrapped_lines.append(line_buffer)
+                    line_buffer = []
+                    line_length = 0
+
+                line_buffer.append((word, color, bold, underline))
+                line_length += word_length
+
+        if line_buffer:
+            wrapped_lines.append(line_buffer)
+
+        return wrapped_lines
+
+    raw_lines = help_content.split("\\n")  # Preserve new lines
+    wrapped_help = []
+
+    for raw_line in raw_lines:
+        color_segments = extract_ansi_segments(raw_line)
+        wrapped_segments = wrap_ansi_text(color_segments, wrap_width)
+        wrapped_help.extend(wrapped_segments)
+        pass
+
+    # Trim and add ellipsis if needed
+    if len(wrapped_help) > max_lines:
+        wrapped_help = wrapped_help[:max_lines]
+        wrapped_help[-1].append(("...", "settings_default", False, False))
+
+    return wrapped_help
+
+
+def wrap_text(text: str, wrap_width: int) -> List[str]:
+    """Wraps text while preserving spaces and breaking long words."""
+    words = re.findall(r"\S+|\s+", text)  # Capture words and spaces separately
+    wrapped_lines = []
+    line_buffer = ""
+    line_length = 0
+    margin = 2  # Left and right margin
+    wrap_width -= margin
+
+    for word in words:
+        word_length = len(word)
+
+        if word_length > wrap_width:  # Break long words
+            if line_buffer:
+                wrapped_lines.append(line_buffer)
+                line_buffer = ""
+                line_length = 0
+            for i in range(0, word_length, wrap_width):
+                wrapped_lines.append(word[i : i + wrap_width])
+            continue
+
+        if line_length + word_length > wrap_width and word.strip():
+            wrapped_lines.append(line_buffer)
+            line_buffer = ""
+            line_length = 0
+
+        line_buffer += word
+        line_length += word_length
+
+    if line_buffer:
+        wrapped_lines.append(line_buffer)
+
+    return wrapped_lines

contact/ui/splash.py

@@ -1,7 +1,9 @@
 import curses
 from contact.ui.colors import get_color
 
-def draw_splash(stdscr):
+
+def draw_splash(stdscr: object) -> None:
+    """Draw the splash screen with a logo and connecting message."""
     curses.curs_set(0)
 
     stdscr.clear()
@@ -17,11 +19,11 @@ def draw_splash(stdscr):
     start_x2 = width // 2 - len(message_4) // 2
     start_y = height // 2 - 1
     stdscr.addstr(start_y, start_x, message_1, get_color("splash_logo", bold=True))
-    stdscr.addstr(start_y+1, start_x-1, message_2, get_color("splash_logo", bold=True))
-    stdscr.addstr(start_y+2, start_x-2, message_3, get_color("splash_logo", bold=True))
-    stdscr.addstr(start_y+4, start_x2, message_4, get_color("splash_text"))
+    stdscr.addstr(start_y + 1, start_x - 1, message_2, get_color("splash_logo", bold=True))
+    stdscr.addstr(start_y + 2, start_x - 2, message_3, get_color("splash_logo", bold=True))
+    stdscr.addstr(start_y + 4, start_x2, message_4, get_color("splash_text"))
 
     stdscr.attrset(get_color("window_frame"))
     stdscr.box()
     stdscr.refresh()
-    curses.napms(500)
+    curses.napms(500)

contact/ui/ui_state.py

@@ -0,0 +1,11 @@
+from typing import Any, Union, List, Dict
+
+
+class MenuState:
+    def __init__(self):
+        self.menu_index: List[int] = []  # Row we left the previous menus
+        self.start_index: List[int] = [0]  # Row to start the menu if it doesn't all fit
+        self.selected_index: int = 0  # Selected Row
+        self.current_menu: Union[Dict[str, Any], List[Any], str, int] = {}  # Contents of the current menu
+        self.menu_path: List[str] = []  # Menu Path
+        self.show_save_option: bool = False  # Display 'Save'

contact/ui/user_config.py

@@ -1,15 +1,20 @@
 import os
 import json
 import curses
+from typing import Any, List, Dict
+
 from contact.ui.colors import get_color, setup_colors, COLOR_MAP
 from contact.ui.default_config import format_json_single_line_arrays, loaded_config
+from contact.ui.nav_utils import move_highlight, draw_arrows
 from contact.utilities.input_handlers import get_list_input
 
-width = 60
-save_option_text = "Save Changes"
 
-def edit_color_pair(key, current_value):
+width = 80
+max_help_lines = 6
+save_option = "Save Changes"
 
+
+def edit_color_pair(key: str, current_value: List[str]) -> List[str]:
     """
     Allows the user to select a foreground and background color for a key.
     """
@@ -19,8 +24,9 @@ def edit_color_pair(key, current_value):
 
     return [fg_color, bg_color]
 
-def edit_value(key, current_value):
-    width = 60
+
+def edit_value(key: str, current_value: str) -> str:
+
     height = 10
     input_width = width - 16  # Allow space for "New Value: "
     start_y = (curses.LINES - height) // 2
@@ -37,7 +43,7 @@ def edit_value(key, current_value):
     edit_win.addstr(3, 2, "Current Value:", get_color("settings_default"))
 
     wrap_width = width - 4  # Account for border and padding
-    wrapped_lines = [current_value[i:i+wrap_width] for i in range(0, len(current_value), wrap_width)]
+    wrapped_lines = [current_value[i : i + wrap_width] for i in range(0, len(current_value), wrap_width)]
 
     for i, line in enumerate(wrapped_lines[:4]):  # Limit display to fit the window height
         edit_win.addstr(4 + i, 2, line, get_color("settings_default"))
@@ -50,7 +56,7 @@ def edit_value(key, current_value):
         theme_options = [k.split("_", 2)[2].lower() for k in loaded_config.keys() if k.startswith("COLOR_CONFIG")]
         return get_list_input("Select Theme", current_value, theme_options)
     elif key == "node_sort":
-        sort_options = ['lastHeard', 'name', 'hops']
+        sort_options = ["lastHeard", "name", "hops"]
         return get_list_input("Sort By", current_value, sort_options)
 
     # Standard Input Mode (Scrollable)
@@ -62,7 +68,7 @@ def edit_value(key, current_value):
     input_position = (7, 13)  # Tuple for row and column
     row, col = input_position  # Unpack tuple
     while True:
-        visible_text = user_input[scroll_offset:scroll_offset + input_width]  # Only show what fits
+        visible_text = user_input[scroll_offset : scroll_offset + input_width]  # Only show what fits
         edit_win.addstr(row, col, " " * input_width, get_color("settings_default"))  # Clear previous text
         edit_win.addstr(row, col, visible_text, get_color("settings_default"))  # Display text
         edit_win.refresh()
@@ -73,8 +79,10 @@ def edit_value(key, current_value):
         if key in (chr(27), curses.KEY_LEFT):  # ESC or Left Arrow
             curses.curs_set(0)
             return current_value  # Exit without returning a value
+
         elif key in (chr(curses.KEY_ENTER), chr(10), chr(13)):
             break
+
         elif key in (curses.KEY_BACKSPACE, chr(127)):  # Backspace
             if user_input:  # Only process if there's something to delete
                 user_input = user_input[:-1]
@@ -93,114 +101,97 @@ def edit_value(key, current_value):
     return user_input if user_input else current_value
 
 
-def render_menu(current_data, menu_path, selected_index):
+def display_menu(menu_state: Any) -> tuple[Any, Any, List[str]]:
     """
     Render the configuration menu with a Save button directly added to the window.
     """
-    # Determine menu items based on the type of current_data
-    if isinstance(current_data, dict):
-        options = list(current_data.keys())
-    elif isinstance(current_data, list):
-        options = [f"[{i}]" for i in range(len(current_data))]
+    num_items = len(menu_state.current_menu) + (1 if menu_state.show_save_option else 0)
+
+    # Determine menu items based on the type of current_menu
+    if isinstance(menu_state.current_menu, dict):
+        options = list(menu_state.current_menu.keys())
+    elif isinstance(menu_state.current_menu, list):
+        options = [f"[{i}]" for i in range(len(menu_state.current_menu))]
     else:
         options = []  # Fallback in case of unexpected data types
 
     # Calculate dynamic dimensions for the menu
+    max_menu_height = curses.LINES
+    menu_height = min(max_menu_height, num_items + 5)
     num_items = len(options)
-    height = min(curses.LINES - 2, num_items + 6)  # Include space for borders and Save button
-    start_y = (curses.LINES - height) // 2
+    start_y = (curses.LINES - menu_height) // 2
     start_x = (curses.COLS - width) // 2
 
     # Create the window
-    menu_win = curses.newwin(height, width, start_y, start_x)
-    menu_win.clear()
+    menu_win = curses.newwin(menu_height, width, start_y, start_x)
+    menu_win.erase()
     menu_win.bkgd(get_color("background"))
     menu_win.attrset(get_color("window_frame"))
     menu_win.border()
     menu_win.keypad(True)
 
-    # Display the menu path
-    header = " > ".join(menu_path)
-    if len(header) > width - 4:
-        header = header[:width - 7] + "..."
-    menu_win.addstr(1, 2, header, get_color("settings_breadcrumbs", bold=True))
-
     # Create the pad for scrolling
     menu_pad = curses.newpad(num_items + 1, width - 8)
     menu_pad.bkgd(get_color("background"))
 
+    # Display the menu path
+    header = " > ".join(menu_state.menu_path)
+    if len(header) > width - 4:
+        header = header[: width - 7] + "..."
+    menu_win.addstr(1, 2, header, get_color("settings_breadcrumbs", bold=True))
+
     # Populate the pad with menu options
     for idx, key in enumerate(options):
-        value = current_data[key] if isinstance(current_data, dict) else current_data[int(key.strip("[]"))]
-        display_key = f"{key}"[:width // 2 - 2]
-        display_value = (
-            f"{value}"[:width // 2 - 8]
+        value = (
+            menu_state.current_menu[key]
+            if isinstance(menu_state.current_menu, dict)
+            else menu_state.current_menu[int(key.strip("[]"))]
         )
+        display_key = f"{key}"[: width // 2 - 2]
+        display_value = f"{value}"[: width // 2 - 8]
 
-        color = get_color("settings_default", reverse=(idx == selected_index))
+        color = get_color("settings_default", reverse=(idx == menu_state.selected_index))
         menu_pad.addstr(idx, 0, f"{display_key:<{width // 2 - 2}} {display_value}".ljust(width - 8), color)
 
     # Add Save button to the main window
-    save_button_position = height - 2
-    menu_win.addstr(
-        save_button_position,
-        (width - len(save_option_text)) // 2,
-        save_option_text,
-        get_color("settings_save", reverse=(selected_index == len(options))),
-    )
+    if menu_state.show_save_option:
+        save_position = menu_height - 2
+        menu_win.addstr(
+            save_position,
+            (width - len(save_option)) // 2,
+            save_option,
+            get_color("settings_save", reverse=(menu_state.selected_index == len(menu_state.current_menu))),
+        )
 
-    # Refresh menu and pad
     menu_win.refresh()
     menu_pad.refresh(
-        0,
+        menu_state.start_index[-1],
         0,
         menu_win.getbegyx()[0] + 3,
         menu_win.getbegyx()[1] + 4,
-        
-        menu_win.getbegyx()[0] + menu_win.getmaxyx()[0] - 3,
+        menu_win.getbegyx()[0] + 3 + menu_win.getmaxyx()[0] - 5 - (2 if menu_state.show_save_option else 0),
         menu_win.getbegyx()[1] + menu_win.getmaxyx()[1] - 4,
     )
 
+    max_index = num_items + (1 if menu_state.show_save_option else 0) - 1
+    visible_height = menu_win.getmaxyx()[0] - 5 - (2 if menu_state.show_save_option else 0)
+
+    draw_arrows(menu_win, visible_height, max_index, menu_state.start_index, show_save_option=False)
+
     return menu_win, menu_pad, options
 
 
-def move_highlight(old_idx, new_idx, options, menu_win, menu_pad):
-    if old_idx == new_idx:
-        return # no-op
+def json_editor(stdscr: curses.window, menu_state: Any) -> None:
 
-    show_save_option = True
-
-    max_index = len(options) + (1 if show_save_option else 0) - 1
-
-    if show_save_option and old_idx == max_index: # special case un-highlight "Save" option
-        menu_win.chgat(menu_win.getmaxyx()[0] - 2, (width - len(save_option_text)) // 2, len(save_option_text), get_color("settings_save"))
-    else:
-        menu_pad.chgat(old_idx, 0, menu_pad.getmaxyx()[1], get_color("settings_default"))
-
-    if show_save_option and new_idx == max_index: # special case highlight "Save" option
-        menu_win.chgat(menu_win.getmaxyx()[0] - 2, (width - len(save_option_text)) // 2, len(save_option_text), get_color("settings_save", reverse = True))
-    else:
-       menu_pad.chgat(new_idx, 0,menu_pad.getmaxyx()[1], get_color("settings_default", reverse = True))
-
-    start_index = max(0, new_idx - (menu_win.getmaxyx()[0] - 6))
-
-    menu_win.refresh()
-    menu_pad.refresh(start_index, 0,
-                     menu_win.getbegyx()[0] + 3,
-                     menu_win.getbegyx()[1] + 4,
-                     menu_win.getbegyx()[0] + menu_win.getmaxyx()[0] - 3,
-                     menu_win.getbegyx()[1] + 4 + menu_win.getmaxyx()[1] - 4)
-
-
-def json_editor(stdscr):
-    menu_path = ["App Settings"]
-    selected_index = 0  # Track the selected option
+    menu_state.selected_index = 0  # Track the selected option
 
     script_dir = os.path.dirname(os.path.abspath(__file__))
     parent_dir = os.path.abspath(os.path.join(script_dir, os.pardir))
     file_path = os.path.join(parent_dir, "config.json")
-    # file_path = "config.json"
-    show_save_option = True  # Always show the Save button
+
+    menu_state.show_save_option = True  # Always show the Save button
+    menu_state.help_win = None
+    menu_state.help_text = {}
 
     # Ensure the file exists
     if not os.path.exists(file_path):
@@ -208,78 +199,89 @@ def json_editor(stdscr):
             json.dump({}, f)
 
     # Load JSON data
-    with open(file_path, "r") as f:
+    with open(file_path, "r", encoding="utf-8") as f:
         original_data = json.load(f)
 
     data = original_data  # Reference to the original data
-    current_data = data  # Track the current level of the menu
+    menu_state.current_menu = data  # Track the current level of the menu
 
     # Render the menu
-    menu_win, menu_pad, options = render_menu(current_data, menu_path, selected_index)
+    menu_win, menu_pad, options = display_menu(menu_state)
     need_redraw = True
 
     while True:
-        if(need_redraw):
-            menu_win, menu_pad, options = render_menu(current_data, menu_path, selected_index)
+        if need_redraw:
+            menu_win, menu_pad, options = display_menu(menu_state)
             menu_win.refresh()
             need_redraw = False
-            
-        max_index = len(options) + (1 if show_save_option else 0) - 1
-        key = menu_win.getch()
 
+        max_index = len(options) + (1 if menu_state.show_save_option else 0) - 1
+        key = menu_win.getch()
 
         if key == curses.KEY_UP:
 
-            old_selected_index = selected_index
-            selected_index = max_index if selected_index == 0 else selected_index - 1
-            move_highlight(old_selected_index, selected_index, options, menu_win, menu_pad)
+            old_selected_index = menu_state.selected_index
+            menu_state.selected_index = max_index if menu_state.selected_index == 0 else menu_state.selected_index - 1
+            menu_state.help_win = move_highlight(
+                old_selected_index, options, menu_win, menu_pad, menu_state=menu_state, max_help_lines=max_help_lines
+            )
 
         elif key == curses.KEY_DOWN:
 
-            old_selected_index = selected_index
-            selected_index = 0 if selected_index == max_index else selected_index + 1
-            move_highlight(old_selected_index, selected_index, options, menu_win, menu_pad)
+            old_selected_index = menu_state.selected_index
+            menu_state.selected_index = 0 if menu_state.selected_index == max_index else menu_state.selected_index + 1
+            menu_state.help_win = move_highlight(
+                old_selected_index, options, menu_win, menu_pad, menu_state=menu_state, max_help_lines=max_help_lines
+            )
 
-        elif key == ord("\t") and show_save_option:
-            old_selected_index = selected_index
-            selected_index = max_index
-            move_highlight(old_selected_index, selected_index, options, menu_win, menu_pad)
+        elif key == ord("\t") and menu_state.show_save_option:
+            old_selected_index = menu_state.selected_index
+            menu_state.selected_index = max_index
+            menu_state.help_win = move_highlight(
+                old_selected_index, options, menu_win, menu_pad, menu_state=menu_state, max_help_lines=max_help_lines
+            )
 
-        elif key in (curses.KEY_RIGHT, ord("\n")):
+        elif key in (curses.KEY_RIGHT, 10, 13):  # 10 = \n, 13 = carriage return
 
             need_redraw = True
             menu_win.erase()
             menu_win.refresh()
 
-
-            if selected_index < len(options):  # Handle selection of a menu item
-                selected_key = options[selected_index]
+            if menu_state.selected_index < len(options):  # Handle selection of a menu item
+                selected_key = options[menu_state.selected_index]
+                menu_state.menu_path.append(str(selected_key))
+                menu_state.start_index.append(0)
+                menu_state.menu_index.append(menu_state.selected_index)
 
                 # Handle nested data
-                if isinstance(current_data, dict):
-                    if selected_key in current_data:
-                        selected_data = current_data[selected_key]
+                if isinstance(menu_state.current_menu, dict):
+                    if selected_key in menu_state.current_menu:
+                        selected_data = menu_state.current_menu[selected_key]
                     else:
                         continue  # Skip invalid key
-                elif isinstance(current_data, list):
-                    selected_data = current_data[int(selected_key.strip("[]"))]
+                elif isinstance(menu_state.current_menu, list):
+                    selected_data = menu_state.current_menu[int(selected_key.strip("[]"))]
 
                 if isinstance(selected_data, list) and len(selected_data) == 2:
                     # Edit color pair
-                    new_value = edit_color_pair(
-                        selected_key, selected_data)
-                    current_data[selected_key] = new_value
+                    new_value = edit_color_pair(selected_key, selected_data)
+                    menu_state.menu_path.pop()
+                    menu_state.start_index.pop()
+                    menu_state.menu_index.pop()
+                    menu_state.current_menu[selected_key] = new_value
 
                 elif isinstance(selected_data, (dict, list)):
                     # Navigate into nested data
-                    menu_path.append(str(selected_key))
-                    current_data = selected_data
-                    selected_index = 0  # Reset the selected index
+                    menu_state.current_menu = selected_data
+                    menu_state.selected_index = 0  # Reset the selected index
 
                 else:
                     # General value editing
                     new_value = edit_value(selected_key, selected_data)
-                    current_data[selected_key] = new_value
+                    menu_state.menu_path.pop()
+                    menu_state.menu_index.pop()
+                    menu_state.start_index.pop()
+                    menu_state.current_menu[selected_key] = new_value
                     need_redraw = True
 
             else:
@@ -294,31 +296,48 @@ def json_editor(stdscr):
             menu_win.erase()
             menu_win.refresh()
 
+            # menu_state.selected_index = menu_state.menu_index[-1]
+
             # Navigate back in the menu
-            if len(menu_path) > 1:
-                menu_path.pop()
-                current_data = data
-                for path in menu_path[1:]:
-                    current_data = current_data[path] if isinstance(current_data, dict) else current_data[int(path.strip("[]"))]
-                selected_index = 0
+            if len(menu_state.menu_path) > 2:
+                menu_state.menu_path.pop()
+                menu_state.start_index.pop()
+                menu_state.current_menu = data
+
+                for path in menu_state.menu_path[2:]:
+                    menu_state.current_menu = (
+                        menu_state.current_menu[path]
+                        if isinstance(menu_state.current_menu, dict)
+                        else menu_state.current_menu[int(path.strip("[]"))]
+                    )
+
             else:
                 # Exit the editor
                 menu_win.clear()
                 menu_win.refresh()
+
                 break
 
 
-def save_json(file_path, data):
+def save_json(file_path: str, data: Dict[str, Any]) -> None:
     formatted_json = format_json_single_line_arrays(data)
     with open(file_path, "w", encoding="utf-8") as f:
         f.write(formatted_json)
     setup_colors(reinit=True)
 
-def main(stdscr):
+
+def main(stdscr: curses.window) -> None:
+    from contact.ui.ui_state import MenuState
+
+    menu_state = MenuState()
+    if len(menu_state.menu_path) == 0:
+        menu_state.menu_path = ["App Settings"]  # Initialize if not set
+
     curses.curs_set(0)
     stdscr.keypad(True)
     setup_colors()
-    json_editor(stdscr)
+    json_editor(stdscr, menu_state)
+
 
 if __name__ == "__main__":
-    curses.wrapper(main)
+    curses.wrapper(main)

contact/utilities/arg_parser.py

@@ -1,11 +1,15 @@
-import argparse
+from argparse import ArgumentParser
 
-def setup_parser():
-    parser = argparse.ArgumentParser(
-            add_help=True,
-            epilog="If no connection arguments are specified, we attempt a serial connection and then a TCP connection to localhost.")
 
-    connOuter = parser.add_argument_group('Connection', 'Optional arguments to specify a device to connect to and how.')
+def setup_parser() -> ArgumentParser:
+    parser = ArgumentParser(
+        add_help=True,
+        epilog="If no connection arguments are specified, we attempt a serial connection and then a TCP connection to localhost.",
+    )
+
+    connOuter = parser.add_argument_group(
+        "Connection", "Optional arguments to specify a device to connect to and how."
+    )
     conn = connOuter.add_mutually_exclusive_group()
     conn.add_argument(
         "--port",
@@ -26,12 +30,10 @@ def setup_parser():
         const="localhost",
     )
     conn.add_argument(
-        "--ble",
-        "-b",
-        help="The BLE device MAC address or name to connect to.",
-        nargs="?",
-        default=None,
-        const="any"
+        "--ble", "-b", help="The BLE device MAC address or name to connect to.", nargs="?", default=None, const="any"
+    )
+    parser.add_argument(
+        "--settings", "--set", "--control", "-c", help="Launch directly into the settings", action="store_true"
     )
 
-    return parser
+    return parser

contact/utilities/config_io.py

@@ -1,13 +1,13 @@
-
 import yaml
 import logging
 from typing import List
 from google.protobuf.json_format import MessageToDict
-from meshtastic import BROADCAST_ADDR, mt_config
+from meshtastic import mt_config
 from meshtastic.util import camel_to_snake, snake_to_camel, fromStr
 
 # defs are from meshtastic/python/main
 
+
 def traverseConfig(config_root, config, interface_config) -> bool:
     """Iterate through current config level preferences and either traverse deeper if preference is a dict or set preference"""
     snake_name = camel_to_snake(config_root)
@@ -20,6 +20,7 @@ def traverseConfig(config_root, config, interface_config) -> bool:
 
     return True
 
+
 def splitCompoundName(comp_name: str) -> List[str]:
     """Split compound (dot separated) preference name into parts"""
     name: List[str] = comp_name.split(".")
@@ -28,6 +29,7 @@ def splitCompoundName(comp_name: str) -> List[str]:
         name.append(comp_name)
     return name
 
+
 def setPref(config, comp_name, raw_val) -> bool:
     """Set a channel or preferences value"""
 
@@ -75,9 +77,7 @@ def setPref(config, comp_name, raw_val) -> bool:
         if e:
             val = e.number
         else:
-            logging.info(
-                f"{name[0]}.{uni_name} does not have an enum called {val}, so you can not set it."
-            )
+            logging.info(f"{name[0]}.{uni_name} does not have an enum called {val}, so you can not set it.")
             logging.info(f"Choices in sorted order are:")
             names = []
             for f in enumType.values:
@@ -122,44 +122,35 @@ def setPref(config, comp_name, raw_val) -> bool:
     return True
 
 
-
 def config_import(interface, filename):
     with open(filename, encoding="utf8") as file:
         configuration = yaml.safe_load(file)
         closeNow = True
 
-        interface.getNode('^local', False).beginSettingsTransaction()
+        interface.getNode("^local", False).beginSettingsTransaction()
 
         if "owner" in configuration:
             logging.info(f"Setting device owner to {configuration['owner']}")
             waitForAckNak = True
-            interface.getNode('^local', False).setOwner(configuration["owner"])
+            interface.getNode("^local", False).setOwner(configuration["owner"])
 
         if "owner_short" in configuration:
-            logging.info(
-                f"Setting device owner short to {configuration['owner_short']}"
-            )
+            logging.info(f"Setting device owner short to {configuration['owner_short']}")
             waitForAckNak = True
-            interface.getNode('^local', False).setOwner(
-                long_name=None, short_name=configuration["owner_short"]
-            )
+            interface.getNode("^local", False).setOwner(long_name=None, short_name=configuration["owner_short"])
 
         if "ownerShort" in configuration:
-            logging.info(
-                f"Setting device owner short to {configuration['ownerShort']}"
-            )
+            logging.info(f"Setting device owner short to {configuration['ownerShort']}")
             waitForAckNak = True
-            interface.getNode('^local', False).setOwner(
-                long_name=None, short_name=configuration["ownerShort"]
-            )
+            interface.getNode("^local", False).setOwner(long_name=None, short_name=configuration["ownerShort"])
 
         if "channel_url" in configuration:
             logging.info(f"Setting channel url to {configuration['channel_url']}")
-            interface.getNode('^local').setURL(configuration["channel_url"])
+            interface.getNode("^local").setURL(configuration["channel_url"])
 
         if "channelUrl" in configuration:
             logging.info(f"Setting channel url to {configuration['channelUrl']}")
-            interface.getNode('^local').setURL(configuration["channelUrl"])
+            interface.getNode("^local").setURL(configuration["channelUrl"])
 
         if "location" in configuration:
             alt = 0
@@ -180,32 +171,25 @@ def config_import(interface, filename):
             interface.localNode.setFixedPosition(lat, lon, alt)
 
         if "config" in configuration:
-            localConfig = interface.getNode('^local').localConfig
+            localConfig = interface.getNode("^local").localConfig
             for section in configuration["config"]:
-                traverseConfig(
-                    section, configuration["config"][section], localConfig
-                )
-                interface.getNode('^local').writeConfig(
-                    camel_to_snake(section)
-                )
+                traverseConfig(section, configuration["config"][section], localConfig)
+                interface.getNode("^local").writeConfig(camel_to_snake(section))
 
         if "module_config" in configuration:
-            moduleConfig = interface.getNode('^local').moduleConfig
+            moduleConfig = interface.getNode("^local").moduleConfig
             for section in configuration["module_config"]:
                 traverseConfig(
                     section,
                     configuration["module_config"][section],
                     moduleConfig,
                 )
-                interface.getNode('^local').writeConfig(
-                    camel_to_snake(section)
-                )
+                interface.getNode("^local").writeConfig(camel_to_snake(section))
 
-        interface.getNode('^local', False).commitSettingsTransaction()
+        interface.getNode("^local", False).commitSettingsTransaction()
         logging.info("Writing modified configuration to device")
 
 
-
 def config_export(interface) -> str:
     """used in --export-config"""
     configObj = {}
@@ -238,7 +222,7 @@ def config_export(interface) -> str:
         if alt:
             configObj["location"]["alt"] = alt
 
-    config = MessageToDict(interface.localNode.localConfig)	#checkme - Used as a dictionary here and a string below
+    config = MessageToDict(interface.localNode.localConfig)  # checkme - Used as a dictionary here and a string below
     if config:
         # Convert inner keys to correct snake/camelCase
         prefs = {}
@@ -249,15 +233,15 @@ def config_export(interface) -> str:
                 prefs[pref] = config[pref]
             # mark base64 encoded fields as such
             if pref == "security":
-                if 'privateKey' in prefs[pref]:
-                    prefs[pref]['privateKey'] = 'base64:' + prefs[pref]['privateKey']
-                if 'publicKey' in prefs[pref]:
-                    prefs[pref]['publicKey'] = 'base64:' + prefs[pref]['publicKey']
-                if 'adminKey' in prefs[pref]:
-                    for i in range(len(prefs[pref]['adminKey'])):
-                        prefs[pref]['adminKey'][i] = 'base64:' + prefs[pref]['adminKey'][i]
+                if "privateKey" in prefs[pref]:
+                    prefs[pref]["privateKey"] = "base64:" + prefs[pref]["privateKey"]
+                if "publicKey" in prefs[pref]:
+                    prefs[pref]["publicKey"] = "base64:" + prefs[pref]["publicKey"]
+                if "adminKey" in prefs[pref]:
+                    for i in range(len(prefs[pref]["adminKey"])):
+                        prefs[pref]["adminKey"][i] = "base64:" + prefs[pref]["adminKey"][i]
         if mt_config.camel_case:
-            configObj["config"] = config		#Identical command here and 2 lines below?
+            configObj["config"] = config  # Identical command here and 2 lines below?
         else:
             configObj["config"] = config
 
@@ -273,9 +257,9 @@ def config_export(interface) -> str:
         else:
             configObj["module_config"] = prefs
 
-    config_txt = "# start of Meshtastic configure yaml\n"		#checkme - "config" (now changed to config_out)
-                                                                        #was used as a string here and a Dictionary above
+    config_txt = "# start of Meshtastic configure yaml\n"  # checkme - "config" (now changed to config_out)
+    # was used as a string here and a Dictionary above
     config_txt += yaml.dump(configObj)
 
     # logging.info(config_txt)
-    return config_txt
+    return config_txt

contact/utilities/control_utils.py

@@ -1,31 +1,34 @@
+from typing import Optional, Tuple, Dict, List
 import re
 
 
-def parse_ini_file(ini_file_path):
-    field_mapping = {}
-    help_text = {}
-    current_section = None
+def parse_ini_file(ini_file_path: str) -> Tuple[Dict[str, str], Dict[str, str]]:
+    """Parses an INI file and returns a mapping of keys to human-readable names and help text."""
 
-    with open(ini_file_path, 'r', encoding='utf-8') as f:
+    field_mapping: Dict[str, str] = {}
+    help_text: Dict[str, str] = {}
+    current_section: Optional[str] = None
+
+    with open(ini_file_path, "r", encoding="utf-8") as f:
         for line in f:
             line = line.strip()
 
             # Skip empty lines and comments
-            if not line or line.startswith(';') or line.startswith('#'):
+            if not line or line.startswith(";") or line.startswith("#"):
                 continue
 
             # Handle sections like [config.device]
-            if line.startswith('[') and line.endswith(']'):
+            if line.startswith("[") and line.endswith("]"):
                 current_section = line[1:-1]
                 continue
 
             # Parse lines like: key, "Human-readable name", "helptext"
-            parts = [p.strip().strip('"') for p in line.split(',', 2)]
+            parts = [p.strip().strip('"') for p in line.split(",", 2)]
             if len(parts) >= 2:
                 key = parts[0]
 
                 # If key is 'title', map directly to the section
-                if key == 'title':
+                if key == "title":
                     full_key = current_section
                 else:
                     full_key = f"{current_section}.{key}" if current_section else key
@@ -46,20 +49,18 @@ def parse_ini_file(ini_file_path):
 
     return field_mapping, help_text
 
-def transform_menu_path(menu_path):
-    """Applies path replacements and normalizes entries in the menu path."""
-    path_replacements = {
-        "Radio Settings": "config",
-        "Module Settings": "module"
-    }
 
-    transformed_path = []
+def transform_menu_path(menu_path: List[str]) -> List[str]:
+    """Applies path replacements and normalizes entries in the menu path."""
+    path_replacements = {"Radio Settings": "config", "Module Settings": "module"}
+
+    transformed_path: List[str] = []
     for part in menu_path[1:]:  # Skip 'Main Menu'
         # Apply fixed replacements
         part = path_replacements.get(part, part)
 
         # Normalize entries like "Channel 1", "Channel 2", etc.
-        if re.match(r'Channel\s+\d+', part, re.IGNORECASE):
+        if re.match(r"Channel\s+\d+", part, re.IGNORECASE):
             part = "channel"
 
         transformed_path.append(part)

contact/utilities/db_handler.py

@@ -2,29 +2,31 @@ import sqlite3
 import time
 import logging
 from datetime import datetime
+from typing import Optional, Union, Dict
 
 from contact.utilities.utils import decimal_to_hex
 import contact.ui.default_config as config
 import contact.globals as globals
 
-def get_table_name(channel):
+
+def get_table_name(channel: str) -> str:
     # Construct the table name
     table_name = f"{str(globals.myNodeNum)}_{channel}_messages"
     quoted_table_name = f'"{table_name}"'  # Quote the table name becuase we begin with numerics and contain spaces
     return quoted_table_name
 
 
-def save_message_to_db(channel, user_id, message_text):
+def save_message_to_db(channel: str, user_id: str, message_text: str) -> Optional[int]:
     """Save messages to the database, ensuring the table exists."""
     try:
         quoted_table_name = get_table_name(channel)
 
-        schema = '''
+        schema = """
             user_id TEXT,
             message_text TEXT,
             timestamp INTEGER,
             ack_type TEXT
-        '''
+        """
         ensure_table_exists(quoted_table_name, schema)
 
         with sqlite3.connect(config.db_file_path) as db_connection:
@@ -32,10 +34,10 @@ def save_message_to_db(channel, user_id, message_text):
             timestamp = int(time.time())
 
             # Insert the message
-            insert_query = f'''
+            insert_query = f"""
                 INSERT INTO {quoted_table_name} (user_id, message_text, timestamp, ack_type)
                 VALUES (?, ?, ?, ?)
-            '''
+            """
             db_cursor.execute(insert_query, (user_id, message_text, timestamp, None))
             db_connection.commit()
 
@@ -47,7 +49,7 @@ def save_message_to_db(channel, user_id, message_text):
         logging.error(f"Unexpected error in save_message_to_db: {e}")
 
 
-def update_ack_nak(channel, timestamp, message, ack):
+def update_ack_nak(channel: str, timestamp: int, message: str, ack: str) -> None:
     try:
         with sqlite3.connect(config.db_file_path) as db_connection:
             db_cursor = db_connection.cursor()
@@ -69,7 +71,7 @@ def update_ack_nak(channel, timestamp, message, ack):
         logging.error(f"Unexpected error in update_ack_nak: {e}")
 
 
-def load_messages_from_db():
+def load_messages_from_db() -> None:
     """Load messages from the database for all channels and update globals.all_messages and globals.channel_list."""
     try:
         with sqlite3.connect(config.db_file_path) as db_connection:
@@ -81,25 +83,27 @@ def load_messages_from_db():
 
             # Iterate through each table and fetch its messages
             for table_name in tables:
-                quoted_table_name = f'"{table_name}"'  # Quote the table name because we begin with numerics and contain spaces
-                table_columns = [i[1] for i in db_cursor.execute(f'PRAGMA table_info({quoted_table_name})')]
+                quoted_table_name = (
+                    f'"{table_name}"'  # Quote the table name because we begin with numerics and contain spaces
+                )
+                table_columns = [i[1] for i in db_cursor.execute(f"PRAGMA table_info({quoted_table_name})")]
                 if "ack_type" not in table_columns:
                     update_table_query = f"ALTER TABLE {quoted_table_name} ADD COLUMN ack_type TEXT"
                     db_cursor.execute(update_table_query)
 
-                query = f'SELECT user_id, message_text, timestamp, ack_type FROM {quoted_table_name}'
+                query = f"SELECT user_id, message_text, timestamp, ack_type FROM {quoted_table_name}"
 
                 try:
                     # Fetch all messages from the table
                     db_cursor.execute(query)
                     db_messages = [(row[0], row[1], row[2], row[3]) for row in db_cursor.fetchall()]  # Save as tuples
-                    
+
                     # Extract the channel name from the table name
                     channel = table_name.split("_")[1]
-                    
+
                     # Convert the channel to an integer if it's numeric, otherwise keep it as a string (nodenum vs channel name)
                     channel = int(channel) if channel.isdigit() else channel
-                    
+
                     # Add the channel to globals.channel_list if not already present
                     if channel not in globals.channel_list and not is_chat_archived(channel):
                         globals.channel_list.append(channel)
@@ -111,10 +115,10 @@ def load_messages_from_db():
                     # Add messages to globals.all_messages grouped by hourly timestamp
                     hourly_messages = {}
                     for user_id, message, timestamp, ack_type in db_messages:
-                        hour = datetime.fromtimestamp(timestamp).strftime('%Y-%m-%d %H:00')
+                        hour = datetime.fromtimestamp(timestamp).strftime("%Y-%m-%d %H:00")
                         if hour not in hourly_messages:
                             hourly_messages[hour] = []
-                        
+
                         ack_str = config.ack_unknown_str
                         if ack_type == "Implicit":
                             ack_str = config.ack_implicit_str
@@ -126,8 +130,11 @@ def load_messages_from_db():
                         if user_id == str(globals.myNodeNum):
                             formatted_message = (f"{config.sent_message_prefix}{ack_str}: ", message)
                         else:
-                            formatted_message = (f"{config.message_prefix} {get_name_from_database(int(user_id), 'short')}: ", message)
-                        
+                            formatted_message = (
+                                f"{config.message_prefix} {get_name_from_database(int(user_id), 'short')}: ",
+                                message,
+                            )
+
                         hourly_messages[hour].append(formatted_message)
 
                     # Flatten the hourly messages into globals.all_messages[channel]
@@ -142,9 +149,9 @@ def load_messages_from_db():
         logging.error(f"SQLite error in load_messages_from_db: {e}")
 
 
-def init_nodedb():
+def init_nodedb() -> None:
     """Initialize the node database and update it with nodes from the interface."""
-    
+
     try:
         if not globals.interface.nodes:
             return  # No nodes to initialize
@@ -155,13 +162,13 @@ def init_nodedb():
         # Insert or update all nodes
         for node in nodes_snapshot:
             update_node_info_in_db(
-                user_id=node['num'],
-                long_name=node['user'].get('longName', ''),
-                short_name=node['user'].get('shortName', ''),
-                hw_model=node['user'].get('hwModel', ''),
-                is_licensed=node['user'].get('isLicensed', '0'),
-                role=node['user'].get('role', 'CLIENT'),
-                public_key=node['user'].get('publicKey', '')
+                user_id=node["num"],
+                long_name=node["user"].get("longName", ""),
+                short_name=node["user"].get("shortName", ""),
+                hw_model=node["user"].get("hwModel", ""),
+                is_licensed=node["user"].get("isLicensed", "0"),
+                role=node["user"].get("role", "CLIENT"),
+                public_key=node["user"].get("publicKey", ""),
             )
 
         logging.info("Node database initialized successfully.")
@@ -172,16 +179,16 @@ def init_nodedb():
         logging.error(f"Unexpected error in init_nodedb: {e}")
 
 
-def maybe_store_nodeinfo_in_db(packet):
+def maybe_store_nodeinfo_in_db(packet: Dict[str, object]) -> None:
     """Save nodeinfo unless that record is already there, updating if necessary."""
     try:
-        user_id = packet['from']
-        long_name = packet['decoded']['user']['longName']
-        short_name = packet['decoded']['user']['shortName']
-        hw_model = packet['decoded']['user']['hwModel']
-        is_licensed = packet['decoded']['user'].get('isLicensed', '0')
-        role = packet['decoded']['user'].get('role', 'CLIENT')
-        public_key = packet['decoded']['user'].get('publicKey', '')
+        user_id = packet["from"]
+        long_name = packet["decoded"]["user"]["longName"]
+        short_name = packet["decoded"]["user"]["shortName"]
+        hw_model = packet["decoded"]["user"]["hwModel"]
+        is_licensed = packet["decoded"]["user"].get("isLicensed", "0")
+        role = packet["decoded"]["user"].get("role", "CLIENT")
+        public_key = packet["decoded"]["user"].get("publicKey", "")
 
         update_node_info_in_db(user_id, long_name, short_name, hw_model, is_licensed, role, public_key)
 
@@ -190,32 +197,44 @@ def maybe_store_nodeinfo_in_db(packet):
     except Exception as e:
         logging.error(f"Unexpected error in maybe_store_nodeinfo_in_db: {e}")
 
-def update_node_info_in_db(user_id, long_name=None, short_name=None, hw_model="UNSET", is_licensed=0, role="CLIENT", public_key="", chat_archived=0):
+
+def update_node_info_in_db(
+    user_id: Union[int, str],
+    long_name: Optional[str] = None,
+    short_name: Optional[str] = None,
+    hw_model: Optional[str] = None,
+    is_licensed: Optional[Union[str, int]] = None,
+    role: Optional[str] = None,
+    public_key: Optional[str] = None,
+    chat_archived: Optional[int] = None,
+) -> None:
     """Update or insert node information into the database, preserving unchanged fields."""
     try:
         ensure_node_table_exists()  # Ensure the table exists before any operation
 
-        if long_name == None:
-            long_name = "Meshtastic " + str(decimal_to_hex(user_id)[-4:])
-        if short_name == None:
-            short_name = str(decimal_to_hex(user_id)[-4:])
-
         with sqlite3.connect(config.db_file_path) as db_connection:
             db_cursor = db_connection.cursor()
             table_name = f'"{globals.myNodeNum}_nodedb"'  # Quote in case of numeric names
 
-
-            table_columns = [i[1] for i in db_cursor.execute(f'PRAGMA table_info({table_name})')]
+            table_columns = [i[1] for i in db_cursor.execute(f"PRAGMA table_info({table_name})")]
             if "chat_archived" not in table_columns:
                 update_table_query = f"ALTER TABLE {table_name} ADD COLUMN chat_archived INTEGER"
                 db_cursor.execute(update_table_query)
 
             # Fetch existing values to preserve unchanged fields
-            db_cursor.execute(f'SELECT * FROM {table_name} WHERE user_id = ?', (user_id,))
+            db_cursor.execute(f"SELECT * FROM {table_name} WHERE user_id = ?", (user_id,))
             existing_record = db_cursor.fetchone()
 
             if existing_record:
-                existing_long_name, existing_short_name, existing_hw_model, existing_is_licensed, existing_role, existing_public_key, existing_chat_archived = existing_record[1:]
+                (
+                    existing_long_name,
+                    existing_short_name,
+                    existing_hw_model,
+                    existing_is_licensed,
+                    existing_role,
+                    existing_public_key,
+                    existing_chat_archived,
+                ) = existing_record[1:]
 
                 long_name = long_name if long_name is not None else existing_long_name
                 short_name = short_name if short_name is not None else existing_short_name
@@ -225,8 +244,16 @@ def update_node_info_in_db(user_id, long_name=None, short_name=None, hw_model="U
                 public_key = public_key if public_key is not None else existing_public_key
                 chat_archived = chat_archived if chat_archived is not None else existing_chat_archived
 
+            long_name = long_name if long_name is not None else "Meshtastic " + str(decimal_to_hex(user_id)[-4:])
+            short_name = short_name if short_name is not None else str(decimal_to_hex(user_id)[-4:])
+            hw_model = hw_model if hw_model is not None else "UNSET"
+            is_licensed = is_licensed if is_licensed is not None else 0
+            role = role if role is not None else "CLIENT"
+            public_key = public_key if public_key is not None else ""
+            chat_archived = chat_archived if chat_archived is not None else 0
+
             # Upsert logic
-            upsert_query = f'''
+            upsert_query = f"""
                 INSERT INTO {table_name} (user_id, long_name, short_name, hw_model, is_licensed, role, public_key, chat_archived)
                 VALUES (?, ?, ?, ?, ?, ?, ?, ?)
                 ON CONFLICT(user_id) DO UPDATE SET
@@ -237,8 +264,10 @@ def update_node_info_in_db(user_id, long_name=None, short_name=None, hw_model="U
                     role = excluded.role,
                     public_key = excluded.public_key,
                     chat_archived = excluded.chat_archived
-            '''
-            db_cursor.execute(upsert_query, (user_id, long_name, short_name, hw_model, is_licensed, role, public_key, chat_archived))
+            """
+            db_cursor.execute(
+                upsert_query, (user_id, long_name, short_name, hw_model, is_licensed, role, public_key, chat_archived)
+            )
             db_connection.commit()
 
     except sqlite3.Error as e:
@@ -247,10 +276,10 @@ def update_node_info_in_db(user_id, long_name=None, short_name=None, hw_model="U
         logging.error(f"Unexpected error in update_node_info_in_db: {e}")
 
 
-def ensure_node_table_exists():
+def ensure_node_table_exists() -> None:
     """Ensure the node database table exists."""
     table_name = f'"{globals.myNodeNum}_nodedb"'  # Quote for safety
-    schema = '''
+    schema = """
         user_id TEXT PRIMARY KEY,
         long_name TEXT,
         short_name TEXT,
@@ -259,11 +288,11 @@ def ensure_node_table_exists():
         role TEXT,
         public_key TEXT,
         chat_archived INTEGER
-    '''
+    """
     ensure_table_exists(table_name, schema)
 
 
-def ensure_table_exists(table_name, schema):
+def ensure_table_exists(table_name: str, schema: str) -> None:
     """Ensure the given table exists in the database."""
     try:
         with sqlite3.connect(config.db_file_path) as db_connection:
@@ -277,10 +306,10 @@ def ensure_table_exists(table_name, schema):
         logging.error(f"Unexpected error in ensure_table_exists({table_name}): {e}")
 
 
-def get_name_from_database(user_id, type="long"):
+def get_name_from_database(user_id: int, type: str = "long") -> str:
     """
     Retrieve a user's name (long or short) from the node database.
-    
+
     :param user_id: The user ID to look up.
     :param type: "long" for long name, "short" for short name.
     :return: The retrieved name or the hex of the user id
@@ -292,7 +321,7 @@ def get_name_from_database(user_id, type="long"):
             # Construct table name
             table_name = f"{str(globals.myNodeNum)}_nodedb"
             nodeinfo_table = f'"{table_name}"'  # Quote table name for safety
-            
+
             # Determine the correct column to fetch
             column_name = "long_name" if type == "long" else "short_name"
 
@@ -311,7 +340,8 @@ def get_name_from_database(user_id, type="long"):
         logging.error(f"Unexpected error in get_name_from_database: {e}")
         return "Unknown"
 
-def is_chat_archived(user_id):
+
+def is_chat_archived(user_id: int) -> int:
     try:
         with sqlite3.connect(config.db_file_path) as db_connection:
             db_cursor = db_connection.cursor()
@@ -330,4 +360,3 @@ def is_chat_archived(user_id):
     except Exception as e:
         logging.error(f"Unexpected error in is_chat_archived: {e}")
         return "Unknown"
-

contact/utilities/input_handlers.py

@@ -2,45 +2,13 @@ import base64
 import binascii
 import curses
 import ipaddress
-import re
+from typing import Any, Optional, List
+
 from contact.ui.colors import get_color
+from contact.ui.nav_utils import move_highlight, draw_arrows, wrap_text
 
-def wrap_text(text, wrap_width):
-    """Wraps text while preserving spaces and breaking long words."""
-    words = re.findall(r'\S+|\s+', text)  # Capture words and spaces separately
-    wrapped_lines = []
-    line_buffer = ""
-    line_length = 0
-    margin = 2  # Left and right margin
-    wrap_width -= margin
 
-    for word in words:
-        word_length = len(word)
-
-        if word_length > wrap_width:  # Break long words
-            if line_buffer:
-                wrapped_lines.append(line_buffer)
-                line_buffer = ""
-                line_length = 0
-            for i in range(0, word_length, wrap_width):
-                wrapped_lines.append(word[i:i+wrap_width])
-            continue
-
-        if line_length + word_length > wrap_width and word.strip():
-            wrapped_lines.append(line_buffer)
-            line_buffer = ""
-            line_length = 0
-
-        line_buffer += word
-        line_length += word_length
-
-    if line_buffer:
-        wrapped_lines.append(line_buffer)
-
-    return wrapped_lines
-    
-
-def get_text_input(prompt):
+def get_text_input(prompt: str) -> Optional[str]:
     """Handles user input with wrapped text for long prompts."""
     height = 8
     width = 80
@@ -67,7 +35,7 @@ def get_text_input(prompt):
 
     prompt_text = "Enter new value: "
     input_win.addstr(row + 1, margin, prompt_text, get_color("settings_default"))
-    
+
     input_win.refresh()
     curses.curs_set(1)
 
@@ -105,11 +73,13 @@ def get_text_input(prompt):
         remaining_text = user_input[first_line_width:]  # Remaining text for wrapping
 
         wrapped_lines = wrap_text(remaining_text, wrap_width=input_width) if remaining_text else []
-        
+
         # Clear only the input area (without touching prompt text)
         for i in range(max_input_rows):
             if row + 1 + i < height - 1:
-                input_win.addstr(row + 1 + i, margin, " " * min(input_width, width - margin - 1), get_color("settings_default"))
+                input_win.addstr(
+                    row + 1 + i, margin, " " * min(input_width, width - margin - 1), get_color("settings_default")
+                )
 
         # Redraw the prompt text so it never disappears
         input_win.addstr(row + 1, margin, prompt_text, get_color("settings_default"))
@@ -128,7 +98,7 @@ def get_text_input(prompt):
     return user_input
 
 
-def get_admin_key_input(current_value):
+def get_admin_key_input(current_value: List[bytes]) -> Optional[List[str]]:
     def to_base64(byte_strings):
         """Convert byte values to Base64-encoded strings."""
         return [base64.b64encode(b).decode() for b in byte_strings]
@@ -168,7 +138,9 @@ def get_admin_key_input(current_value):
         # Display current values, allowing editing
         for i, line in enumerate(user_values):
             prefix = "→ " if i == cursor_pos else "  "  # Highlight the current line
-            repeated_win.addstr(3 + i, 2, f"{prefix}Admin Key {i + 1}: ", get_color("settings_default", bold=(i == cursor_pos)))
+            repeated_win.addstr(
+                3 + i, 2, f"{prefix}Admin Key {i + 1}: ", get_color("settings_default", bold=(i == cursor_pos))
+            )
             repeated_win.addstr(3 + i, 18, line)  # Align text for easier editing
 
         # Move cursor to the correct position inside the field
@@ -188,8 +160,8 @@ def get_admin_key_input(current_value):
             curses.noecho()
             curses.curs_set(0)
             return None
-        
-        elif key == ord('\n'):  # Enter key to save and return
+
+        elif key == ord("\n"):  # Enter key to save and return
             if all(is_valid_base64(val) for val in user_values):  # Ensure all values are valid Base64 and 32 bytes
                 curses.noecho()
                 curses.curs_set(0)
@@ -211,8 +183,7 @@ def get_admin_key_input(current_value):
                 pass  # Ignore invalid character inputs
 
 
-
-def get_repeated_input(current_value):
+def get_repeated_input(current_value: List[str]) -> Optional[str]:
     height = 9
     width = 80
     start_y = (curses.LINES - height) // 2
@@ -239,8 +210,10 @@ def get_repeated_input(current_value):
         # Display current values, allowing editing
         for i, line in enumerate(user_values):
             prefix = "→ " if i == cursor_pos else "  "  # Highlight the current line
-            repeated_win.addstr(3 + i, 2, f"{prefix}Value{i + 1}: ", get_color("settings_default", bold=(i == cursor_pos)))
-            repeated_win.addstr(3 + i, 18, line) 
+            repeated_win.addstr(
+                3 + i, 2, f"{prefix}Value{i + 1}: ", get_color("settings_default", bold=(i == cursor_pos))
+            )
+            repeated_win.addstr(3 + i, 18, line)
 
         # Move cursor to the correct position inside the field
         curses.curs_set(1)
@@ -259,8 +232,8 @@ def get_repeated_input(current_value):
             curses.noecho()
             curses.curs_set(0)
             return None
-        
-        elif key == ord('\n'):  # Enter key to save and return
+
+        elif key == ord("\n"):  # Enter key to save and return
             curses.noecho()
             curses.curs_set(0)
             return ", ".join(user_values)
@@ -279,7 +252,7 @@ def get_repeated_input(current_value):
                 pass  # Ignore invalid character inputs
 
 
-def get_fixed32_input(current_value):
+def get_fixed32_input(current_value: int) -> int:
     cvalue = current_value
     current_value = str(ipaddress.IPv4Address(current_value))
     height = 10
@@ -312,7 +285,7 @@ def get_fixed32_input(current_value):
             curses.noecho()
             curses.curs_set(0)
             return cvalue  # Return the current value unchanged
-        elif key == ord('\n'):  # Enter key to validate and save
+        elif key == ord("\n"):  # Enter key to validate and save
             # Validate IP address
             octets = user_input.split(".")
             if len(octets) == 4 and all(octet.isdigit() and 0 <= int(octet) <= 255 for octet in octets):
@@ -336,7 +309,7 @@ def get_fixed32_input(current_value):
                 pass  # Ignore invalid inputs
 
 
-def get_list_input(prompt, current_option, list_options):
+def get_list_input(prompt: str, current_option: Optional[str], list_options: List[str]) -> Optional[str]:
     """
     Displays a scrollable list of list_options for the user to choose from.
     """
@@ -369,14 +342,19 @@ def get_list_input(prompt, current_option, list_options):
 
     # Initial refresh
     list_win.refresh()
-    list_pad.refresh(0, 0,
-                    list_win.getbegyx()[0] + 3, list_win.getbegyx()[1] + 4,
-                    list_win.getbegyx()[0] + list_win.getmaxyx()[0] - 2, list_win.getbegyx()[1] + list_win.getmaxyx()[1] - 4)
-    
+    list_pad.refresh(
+        0,
+        0,
+        list_win.getbegyx()[0] + 3,
+        list_win.getbegyx()[1] + 4,
+        list_win.getbegyx()[0] + list_win.getmaxyx()[0] - 2,
+        list_win.getbegyx()[1] + list_win.getmaxyx()[1] - 4,
+    )
+
     max_index = len(list_options) - 1
     visible_height = list_win.getmaxyx()[0] - 5
 
-    draw_arrows(list_win, visible_height, max_index, 0)
+    draw_arrows(list_win, visible_height, max_index, [0], show_save_option=False)  # Initial call to draw arrows
 
     while True:
         key = list_win.getch()
@@ -384,12 +362,12 @@ def get_list_input(prompt, current_option, list_options):
         if key == curses.KEY_UP:
             old_selected_index = selected_index
             selected_index = max(0, selected_index - 1)
-            move_highlight(old_selected_index, selected_index, list_options, list_win, list_pad)
+            move_highlight(old_selected_index, list_options, list_win, list_pad, selected_index=selected_index)
         elif key == curses.KEY_DOWN:
             old_selected_index = selected_index
             selected_index = min(len(list_options) - 1, selected_index + 1)
-            move_highlight(old_selected_index, selected_index, list_options, list_win, list_pad)
-        elif key == ord('\n'):  # Enter key
+            move_highlight(old_selected_index, list_options, list_win, list_pad, selected_index=selected_index)
+        elif key == ord("\n"):  # Enter key
             list_win.clear()
             list_win.refresh()
             return list_options[selected_index]
@@ -397,58 +375,3 @@ def get_list_input(prompt, current_option, list_options):
             list_win.clear()
             list_win.refresh()
             return current_option
-
-
-def move_highlight(old_idx, new_idx, options, list_win, list_pad):
-
-    global scroll_offset
-    if 'scroll_offset' not in globals():
-        scroll_offset = 0  # Initialize if not set
-
-    if old_idx == new_idx:
-        return  # No-op
-
-    max_index = len(options) - 1
-    visible_height = list_win.getmaxyx()[0] - 5
-
-    # Adjust scroll_offset only when moving out of visible range
-    if new_idx < scroll_offset:  # Moving above the visible area
-        scroll_offset = new_idx
-    elif new_idx >= scroll_offset + visible_height:  # Moving below the visible area
-        scroll_offset = new_idx - visible_height
-
-    # Ensure scroll_offset is within bounds
-    scroll_offset = max(0, min(scroll_offset, max_index - visible_height + 1))
-
-    # Clear old highlight
-    list_pad.chgat(old_idx, 0, list_pad.getmaxyx()[1], get_color("settings_default"))
-
-    # Highlight new selection
-    list_pad.chgat(new_idx, 0, list_pad.getmaxyx()[1], get_color("settings_default", reverse=True))
-
-    list_win.refresh()
-    
-    # Refresh pad only if scrolling is needed
-    list_pad.refresh(scroll_offset, 0,
-                     list_win.getbegyx()[0] + 3, list_win.getbegyx()[1] + 4,
-                     list_win.getbegyx()[0] + 3 + visible_height, 
-                     list_win.getbegyx()[1] + list_win.getmaxyx()[1] - 4)
-    
-    draw_arrows(list_win, visible_height, max_index, scroll_offset)
-
-    return scroll_offset  # Return updated scroll_offset to be stored externally
-
-
-def draw_arrows(win, visible_height, max_index, start_index):
-
-    if visible_height < max_index:
-        if start_index > 0:
-            win.addstr(3, 2, "▲", get_color("settings_default"))
-        else:
-            win.addstr(3, 2, " ", get_color("settings_default"))
-
-        if max_index - start_index > visible_height:
-            win.addstr(visible_height + 3, 2, "▼", get_color("settings_default"))
-        else:
-            win.addstr(visible_height + 3, 2, " ", get_color("settings_default"))
-        

contact/utilities/interfaces.py

@@ -1,23 +1,43 @@
 import logging
 import meshtastic.serial_interface, meshtastic.tcp_interface, meshtastic.ble_interface
-import contact.globals as globals
+
 
 def initialize_interface(args):
     try:
+
         if args.ble:
             return meshtastic.ble_interface.BLEInterface(args.ble if args.ble != "any" else None)
+
         elif args.host:
-            return meshtastic.tcp_interface.TCPInterface(args.host)
+            try:
+                if ":" in args.host:
+                    tcp_hostname, tcp_port = args.host.split(":")
+                else:
+                    tcp_hostname = args.host
+                    tcp_port = meshtastic.tcp_interface.DEFAULT_TCP_PORT
+                return meshtastic.tcp_interface.TCPInterface(tcp_hostname, portNumber=tcp_port)
+            except Exception as ex:
+                logging.error(f"Error connecting to {args.host}. {ex}")
         else:
             try:
-                return meshtastic.serial_interface.SerialInterface(args.port)
+                client = meshtastic.serial_interface.SerialInterface(args.port)
+            except FileNotFoundError as ex:
+                logging.error(f"The serial device at '{args.port}' was not found. {ex}")
             except PermissionError as ex:
-                logging.error(f"You probably need to add yourself to the `dialout` group to use a serial connection. {ex}")
+                logging.error(
+                    f"You probably need to add yourself to the `dialout` group to use a serial connection. {ex}"
+                )
             except Exception as ex:
                 logging.error(f"Unexpected error initializing interface: {ex}")
-            if globals.interface.devPath is None:
-                return meshtastic.tcp_interface.TCPInterface("meshtastic.local")
-    
+            except OSError as ex:
+                logging.error(f"The serial device couldn't be opened, it might be in use by another process. {ex}")
+            if client.devPath is None:
+                try:
+                    client = meshtastic.tcp_interface.TCPInterface("localhost")
+                except Exception as ex:
+                    logging.error(f"Error connecting to localhost:{ex}")
+
+            return client
+
     except Exception as ex:
         logging.critical(f"Fatal error initializing interface: {ex}")
-    

contact/utilities/save_to_radio.py

@@ -4,7 +4,8 @@ import logging
 import base64
 import time
 
-def save_changes(interface, menu_path, modified_settings):
+
+def save_changes(interface, modified_settings, menu_state):
     """
     Save changes to the device based on modified settings.
     :param interface: Meshtastic interface instance
@@ -15,16 +16,16 @@ def save_changes(interface, menu_path, modified_settings):
         if not modified_settings:
             logging.info("No changes to save. modified_settings is empty.")
             return
-        
-        node = interface.getNode('^local')
+
+        node = interface.getNode("^local")
         admin_key_backup = None
-        if 'admin_key' in modified_settings:
+        if "admin_key" in modified_settings:
             # Get reference to security config
             security_config = node.localConfig.security
-            admin_keys = modified_settings['admin_key']
+            admin_keys = modified_settings["admin_key"]
 
             # Filter out empty keys
-            valid_keys = [key for key in admin_keys if key and key.strip() and key != b'']
+            valid_keys = [key for key in admin_keys if key and key.strip() and key != b""]
 
             if not valid_keys:
                 logging.warning("No valid admin keys provided. Skipping admin key update.")
@@ -42,29 +43,29 @@ def save_changes(interface, menu_path, modified_settings):
                     security_config.admin_key.append(key)
                 node.writeConfig("security")
                 logging.info("Admin keys updated successfully!")
-            
+
             # Backup 'admin_key' before removing it
-            admin_key_backup = modified_settings.get('admin_key', None)
+            admin_key_backup = modified_settings.get("admin_key", None)
             # Remove 'admin_key' from modified_settings to prevent interference
-            del modified_settings['admin_key']
+            del modified_settings["admin_key"]
 
             # Return early if there are no other settings left to process
             if not modified_settings:
                 return
 
-        if menu_path[1] ==  "Radio Settings" or menu_path[1] == "Module Settings":
-            config_category = menu_path[2].lower() # for radio and module configs
+        if menu_state.menu_path[1] == "Radio Settings" or menu_state.menu_path[1] == "Module Settings":
+            config_category = menu_state.menu_path[2].lower()  # for radio and module configs
 
-            if {'latitude', 'longitude', 'altitude'} & modified_settings.keys():
-                lat = float(modified_settings.get('latitude', 0.0))
-                lon = float(modified_settings.get('longitude', 0.0))
-                alt = int(modified_settings.get('altitude', 0))
+            if {"latitude", "longitude", "altitude"} & modified_settings.keys():
+                lat = float(modified_settings.get("latitude", 0.0))
+                lon = float(modified_settings.get("longitude", 0.0))
+                alt = int(modified_settings.get("altitude", 0))
 
                 interface.localNode.setFixedPosition(lat, lon, alt)
                 logging.info(f"Updated {config_category} with Latitude: {lat} and Longitude {lon} and Altitude {alt}")
                 return
 
-        elif menu_path[1] == "User Settings":  # for user configs
+        elif menu_state.menu_path[1] == "User Settings":  # for user configs
             config_category = "User Settings"
             long_name = modified_settings.get("longName")
             short_name = modified_settings.get("shortName")
@@ -73,24 +74,26 @@ def save_changes(interface, menu_path, modified_settings):
 
             node.setOwner(long_name, short_name, is_licensed)
 
-            logging.info(f"Updated {config_category} with Long Name: {long_name}, Short Name: {short_name}, Licensed Mode: {is_licensed}")
+            logging.info(
+                f"Updated {config_category} with Long Name: {long_name}, Short Name: {short_name}, Licensed Mode: {is_licensed}"
+            )
 
             return
-        
-        elif menu_path[1] == "Channels":    # for channel configs
+
+        elif menu_state.menu_path[1] == "Channels":  # for channel configs
             config_category = "Channels"
 
             try:
-                channel = menu_path[-1]
+                channel = menu_state.menu_path[-1]
                 channel_num = int(channel.split()[-1]) - 1
             except (IndexError, ValueError) as e:
                 channel_num = None
 
             channel = node.channels[channel_num]
             for key, value in modified_settings.items():
-                if key == 'psk':  # Special case: decode Base64 for psk
+                if key == "psk":  # Special case: decode Base64 for psk
                     channel.settings.psk = base64.b64decode(value)
-                elif key == 'position_precision':  # Special case: module_settings
+                elif key == "position_precision":  # Special case: module_settings
                     channel.settings.module_settings.position_precision = value
                 else:
                     setattr(channel.settings, key, value)  # Use setattr for other fields
@@ -135,7 +138,9 @@ def save_changes(interface, menu_path, modified_settings):
                                     setattr(field, sub_field, sub_value)
                                     logging.info(f"Updated {config_category}.{config_item}.{sub_field} to {sub_value}")
                                 else:
-                                    logging.warning(f"Sub-field '{sub_field}' not found in {config_category}.{config_item}")
+                                    logging.warning(
+                                        f"Sub-field '{sub_field}' not found in {config_category}.{config_item}"
+                                    )
                         else:
                             logging.warning(f"Invalid value for {config_category}.{config_item}. Expected dict.")
                     else:
@@ -151,9 +156,9 @@ def save_changes(interface, menu_path, modified_settings):
             logging.info(f"Changes written to config category: {config_category}")
 
             if admin_key_backup is not None:
-                modified_settings['admin_key'] = admin_key_backup
+                modified_settings["admin_key"] = admin_key_backup
         except Exception as e:
             logging.error(f"Failed to write configuration for category '{config_category}': {e}")
 
     except Exception as e:
-        logging.error(f"Error saving changes: {e}")
+        logging.error(f"Error saving changes: {e}")

contact/utilities/utils.py

@@ -3,9 +3,10 @@ import datetime
 from meshtastic.protobuf import config_pb2
 import contact.ui.default_config as config
 
+
 def get_channels():
     """Retrieve channels from the node and update globals.channel_list and globals.all_messages."""
-    node = globals.interface.getNode('^local')
+    node = globals.interface.getNode("^local")
     device_channels = node.channels
 
     # Clear and rebuild channel list
@@ -20,7 +21,9 @@ def get_channels():
                 # If channel name is blank, use the modem preset
                 lora_config = node.localConfig.lora
                 modem_preset_enum = lora_config.modem_preset
-                modem_preset_string = config_pb2._CONFIG_LORACONFIG_MODEMPRESET.values_by_number[modem_preset_enum].name
+                modem_preset_string = config_pb2._CONFIG_LORACONFIG_MODEMPRESET.values_by_number[
+                    modem_preset_enum
+                ].name
                 channel_name = convert_to_camel_case(modem_preset_string)
 
             # Add channel to globals.channel_list if not already present
@@ -31,27 +34,38 @@ def get_channels():
             if channel_name not in globals.all_messages:
                 globals.all_messages[channel_name] = []
 
-
     return globals.channel_list
 
+
 def get_node_list():
     if globals.interface.nodes:
         my_node_num = globals.myNodeNum
 
         def node_sort(node):
-            if(config.node_sort == 'lastHeard'):
-                return -node['lastHeard'] if ('lastHeard' in node and isinstance(node['lastHeard'], int)) else 0
-            elif(config.node_sort == "name"):
-                return node['user']['longName']
-            elif(config.node_sort == "hops"):
-                return node['hopsAway'] if 'hopsAway' in node else 100
+            if config.node_sort == "lastHeard":
+                return -node["lastHeard"] if ("lastHeard" in node and isinstance(node["lastHeard"], int)) else 0
+            elif config.node_sort == "name":
+                return node["user"]["longName"]
+            elif config.node_sort == "hops":
+                return node["hopsAway"] if "hopsAway" in node else 100
             else:
                 return node
-        sorted_nodes = sorted(globals.interface.nodes.values(), key = node_sort)
-        node_list = [node['num'] for node in sorted_nodes if node['num'] != my_node_num]
+
+        sorted_nodes = sorted(globals.interface.nodes.values(), key=node_sort)
+
+        # Move favorite nodes to the beginning
+        sorted_nodes = sorted(
+            sorted_nodes, key=lambda node: node["isFavorite"] if "isFavorite" in node else False, reverse=True
+        )
+
+        # Move ignored nodes to the end
+        sorted_nodes = sorted(sorted_nodes, key=lambda node: node["isIgnored"] if "isIgnored" in node else False)
+
+        node_list = [node["num"] for node in sorted_nodes if node["num"] != my_node_num]
         return [my_node_num] + node_list  # Ensuring your node is always first
     return []
 
+
 def refresh_node_list():
     new_node_list = get_node_list()
     if new_node_list != globals.node_list:
@@ -59,19 +73,23 @@ def refresh_node_list():
         return True
     return False
 
+
 def get_nodeNum():
     myinfo = globals.interface.getMyNodeInfo()
-    myNodeNum = myinfo['num']
+    myNodeNum = myinfo["num"]
     return myNodeNum
 
+
 def decimal_to_hex(decimal_number):
     return f"!{decimal_number:08x}"
 
+
 def convert_to_camel_case(string):
-    words = string.split('_')
-    camel_case_string = ''.join(word.capitalize() for word in words)
+    words = string.split("_")
+    camel_case_string = "".join(word.capitalize() for word in words)
     return camel_case_string
 
+
 def get_time_val_units(time_delta):
     value = 0
     unit = ""
@@ -99,11 +117,13 @@ def get_time_val_units(time_delta):
         unit = "s"
     return (value, unit)
 
+
 def get_readable_duration(seconds):
-    delta = datetime.timedelta(seconds = seconds)
+    delta = datetime.timedelta(seconds=seconds)
     val, units = get_time_val_units(delta)
     return f"{val} {units}"
 
+
 def get_time_ago(timestamp):
     now = datetime.datetime.now()
     dt = datetime.datetime.fromtimestamp(timestamp)
@@ -113,4 +133,3 @@ def get_time_ago(timestamp):
     if unit != "s":
         return f"{value} {unit} ago"
     return "now"
-

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "contact"
-version = "1.3.0"
+version = "1.3.7"
 description = "This Python curses client for Meshtastic is a terminal-based client designed to manage device settings, enable mesh chat communication, and handle configuration backups and restores."
 authors = [
     {name = "Ben Lipsey",email = "ben@pdxlocations.com"}
@@ -12,10 +12,13 @@ dependencies = [
     "meshtastic (>=2.6.0,<3.0.0)"
 ]
 
+[project.urls]
+Homepage = "https://github.com/pdxlocations/contact"
+Issues = "https://github.com/pdxlocations/contact/issues"
 
 [build-system]
 requires = ["poetry-core>=2.0.0,<3.0.0"]
 build-backend = "poetry.core.masonry.api"
 
 [tool.poetry.scripts]
-contact = "contact.main:start"
+contact = "contact.__main__:start"