current state

* update interfaces.py

* fix logging

* update

* update

* fix devpath

* fix returns

* changes

.vscode/settings.json

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

README.md

@@ -1,8 +1,12 @@
 ## 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.
 
 
@@ -11,7 +15,7 @@ This Python curses client for Meshtastic is a terminal-based client designed to
 <br><br>
 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="573" alt="Contact - Settings Dialogue" src="https://github.com/user-attachments/assets/dbe1287b-5558-407c-84b8-2a1bc913dec8" />
+<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 
 

contact/__main__.py

@@ -1,114 +1,133 @@
 #!/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.
+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 os
-from pubsub import pub
-import sys
 import io
 import logging
+import os
 import subprocess
-import traceback
+import sys
 import threading
+import traceback
 
-from contact.utilities.db_handler import init_nodedb, load_messages_from_db
+# 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.contact_ui import main_ui
 from contact.ui.colors import setup_colors
+from contact.ui.contact_ui import main_ui
 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.db_handler import init_nodedb, load_messages_from_db
 from contact.utilities.input_handlers import get_list_input
-from contact.utilities.utils import get_channels, get_node_list, get_nodeNum
+from contact.utilities.interfaces import initialize_interface
-import contact.globals as globals
+from contact.utilities.utils import get_channels, get_nodeNum, get_node_list
+
+
+# ------------------------------------------------------------------------------
+# Environment & Logging Setup
+# ------------------------------------------------------------------------------
 
-# 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)
+    level=logging.INFO,
     format="%(asctime)s - %(levelname)s - %(message)s"
 )
 
 globals.lock = threading.Lock()
 
-def main(stdscr):
+# ------------------------------------------------------------------------------
+# 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)
-            parser = setup_parser()
-            args = parser.parse_args()
 
-            # Check if --settings was passed and run settings.py as a subprocess
+            args = setup_parser().parse_args()
+
             if getattr(args, 'settings', False):
                 subprocess.run([sys.executable, "-m", "contact.settings"], check=True)
                 return
 
-            logging.info("Initializing interface %s", args)
+            logging.info("Initializing interface...")
             with globals.lock:
-                globals.interface = initialize_interface(args)
+                initialize_globals(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("Uncaught exception: %s", e)
         logging.error("Traceback: %s", traceback.format_exc())
-        logging.error("Console output before crash:\n%s", console_output)
+        logging.error("Console output:\n%s", console_output)
-        raise  # Re-raise only unexpected errors
+        raise
 
-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
+def start() -> None:
-    sys.stderr = log_f
+    """Launch curses wrapper and redirect logs to file."""
+    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)
 
-    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,17 +1,34 @@
 import logging
 import time
-from contact.utilities.utils import refresh_node_list
 from datetime import datetime
-from contact.ui.contact_ui import draw_packetlog_win, draw_node_list, draw_messages_window, draw_channel_list, add_notification
+from typing import Any
-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 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: dict[str, Any], interface: Any) -> None:
-
+    """
-def on_receive(packet, interface):
+    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)

contact/message_handlers/tx_handler.py

@@ -1,17 +1,29 @@
 from datetime import datetime
+from typing import Any
+
 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):
+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):
@@ -41,8 +53,10 @@ def onAckNak(packet):
     if globals.channel_list[channel_number] == globals.channel_list[globals.selected_channel]:
         draw_messages_window()
 
-def on_response_traceroute(packet):
+def on_response_traceroute(packet: dict[str, Any]) -> None:
-    """on response for trace route"""
+    """
+    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
@@ -118,7 +132,10 @@ def on_response_traceroute(packet):
     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]
@@ -168,7 +185,10 @@ def send_message(message, destination=BROADCAST_NUM, channel=0):
 
     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,7 +14,7 @@ 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):   

contact/ui/colors.py

@@ -12,7 +12,7 @@ COLOR_MAP = {
     "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 +29,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.
     """

contact/ui/contact_ui.py

@@ -13,7 +13,7 @@ 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
@@ -90,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)
@@ -377,7 +377,7 @@ def main_ui(stdscr):
 
 
 
-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
@@ -418,7 +418,7 @@ def draw_channel_list():
 
     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()
 
@@ -461,7 +461,7 @@ 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
@@ -501,7 +501,7 @@ 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)
@@ -515,7 +515,7 @@ 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:
@@ -525,7 +525,7 @@ 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]
@@ -533,7 +533,7 @@ 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))
 
@@ -543,7 +543,7 @@ 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:
@@ -553,7 +553,7 @@ def scroll_nodes(direction):
 
     select_node(new_selected_node)
 
-def draw_packetlog_win():
+def draw_packetlog_win() -> None:
 
     columns = [10,10,15,30]
     span = 0
@@ -602,7 +602,7 @@ 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
 
@@ -645,7 +645,7 @@ def search(win):
 
     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]]
@@ -693,7 +693,7 @@ def draw_node_details():
 
     draw_centered_text_field(function_win, nodestr, 0, get_color("commands"))
 
-def draw_help():
+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:
@@ -702,19 +702,18 @@ def draw_help():
 
     draw_centered_text_field(function_win, function_str, 0, get_color("commands"))
 
-def draw_function_win():
+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):
+def refresh_pad(window: int) -> None:
-    # global messages_pad, nodes_pad, channel_pad 
+
-    
     win_height = channel_win.getmaxyx()[0]
 
     if(window == 1):
@@ -746,7 +745,7 @@ def refresh_pad(window):
                         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")
@@ -767,25 +766,25 @@ def highlight_line(highlight, window, line):
 
     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: str | int) -> None:
     function_win.addstr(1, 1, f"debug: {value}    ")
     function_win.refresh()

contact/ui/default_config.py

@@ -1,5 +1,5 @@
-import logging
 import json
+import logging
 import os
 
 # Get the parent directory of the script
@@ -11,11 +11,11 @@ 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():
@@ -31,7 +31,7 @@ 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 +42,7 @@ 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"],
@@ -161,7 +161,7 @@ def initialize_config():
 
     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

contact/ui/dialog.py

@@ -1,7 +1,7 @@
 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

contact/ui/menus.py

@@ -1,19 +1,27 @@
-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
+
+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 value
 
-def extract_fields(message_instance, current_config=None):
+def extract_fields(
+    message_instance: Message,
+    current_config: 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}
     
@@ -47,7 +55,10 @@ 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

contact/ui/navigation_utils.py

@@ -0,0 +1,120 @@
+# contact/ui/navigation_utils.py
+
+import curses
+from contact.ui.colors import get_color
+
+save_option = "Save Changes"
+sensitive_settings = ["Reboot", "Reset Node DB", "Shutdown", "Factory Reset"]
+
+
+def move_highlight(
+    old_idx: int,
+    new_idx: int,
+    options: list[str],
+    win: curses.window,
+    pad: curses.window,
+    *,
+    start_index_ref: list[int] = None,
+    selected_index: int = None,
+    max_help_lines: int = 0,
+    show_save: bool = False,
+    help_win: curses.window = None,
+    help_updater=None,
+    field_mapping=None,
+    menu_path: list[str] = None,
+    width: int = 80,
+    sensitive_mode: bool = False,
+):
+    if old_idx == new_idx:
+        return
+
+    max_index = len(options) + (1 if show_save else 0) - 1
+    visible_height = win.getmaxyx()[0] - 5 - (2 if show_save else 0)
+
+    # Scrolling logic
+    if start_index_ref is not None:
+        if new_idx == max_index and show_save:
+            pass
+        elif new_idx < start_index_ref[0]:
+            start_index_ref[0] = new_idx
+        elif new_idx >= start_index_ref[0] + visible_height:
+            start_index_ref[0] = new_idx - visible_height
+        start_index_ref[0] = max(
+            0, min(start_index_ref[0], max_index - visible_height + 1)
+        )
+
+    scroll = start_index_ref[0] if start_index_ref else 0
+
+    # Clear previous highlight
+    if show_save and old_idx == max_index:
+        win.chgat(
+            win.getmaxyx()[0] - 2,
+            (width - len(save_option)) // 2,
+            len(save_option),
+            get_color("settings_save"),
+        )
+    else:
+        color = (
+            "settings_sensitive"
+            if sensitive_mode and options[old_idx] in sensitive_settings
+            else "settings_default"
+        )
+        pad.chgat(old_idx, 0, pad.getmaxyx()[1], get_color(color))
+
+    # Apply new highlight
+    if show_save and new_idx == max_index:
+        win.chgat(
+            win.getmaxyx()[0] - 2,
+            (width - len(save_option)) // 2,
+            len(save_option),
+            get_color("settings_save", reverse=True),
+        )
+    else:
+        color = (
+            "settings_sensitive"
+            if sensitive_mode and options[new_idx] in sensitive_settings
+            else "settings_default"
+        )
+        pad.chgat(new_idx, 0, pad.getmaxyx()[1], get_color(color, reverse=True))
+
+    win.refresh()
+    pad.refresh(
+        scroll,
+        0,
+        win.getbegyx()[0] + 3,
+        win.getbegyx()[1] + 4,
+        win.getbegyx()[0] + 3 + visible_height,
+        win.getbegyx()[1] + win.getmaxyx()[1] - 4,
+    )
+
+    # Optional help update
+    if help_win and help_updater and menu_path and selected_index is not None:
+        selected_option = (
+            options[selected_index] if selected_index < len(options) else None
+        )
+        help_y = win.getbegyx()[0] + win.getmaxyx()[0]
+        help_updater(
+            help_win,
+            field_mapping,
+            menu_path,
+            selected_option,
+            max_help_lines,
+            width,
+            help_y,
+            win.getbegyx()[1],
+        )
+
+
+def draw_arrows(
+    win: curses.window, visible_height: int, max_index: int, start_index: int
+) -> None:
+    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/ui/splash.py

@@ -1,7 +1,8 @@
 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()

contact/ui/ui_state.py

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

contact/ui/user_config.py

@@ -1,26 +1,33 @@
 import os
 import json
 import curses
+from typing import Any
 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.utilities.input_handlers import get_list_input
+from contact.ui.navigation_utils import move_highlight
 
 width = 80
 save_option = "Save Changes"
 sensitive_settings = []
 
-def edit_color_pair(key, current_value):
 
+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.
     """
     color_list = [" "] + list(COLOR_MAP.keys())
-    fg_color = get_list_input(f"Select Foreground Color for {key}", current_value[0], color_list)
+    fg_color = get_list_input(
-    bg_color = get_list_input(f"Select Background Color for {key}", current_value[1], color_list)
+        f"Select Foreground Color for {key}", current_value[0], color_list
+    )
+    bg_color = get_list_input(
+        f"Select Background Color for {key}", current_value[1], color_list
+    )
 
     return [fg_color, bg_color]
 
-def edit_value(key, current_value, state):
+
+def edit_value(key: str, current_value: str) -> str:
 
     height = 10
     input_width = width - 16  # Allow space for "New Value: "
@@ -38,9 +45,14 @@ def edit_value(key, current_value, state):
     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
+    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"))
 
     edit_win.refresh()
@@ -48,10 +60,14 @@ def edit_value(key, current_value, state):
     # Handle theme selection dynamically
     if key == "theme":
         # Load theme names dynamically from the JSON
-        theme_options = [k.split("_", 2)[2].lower() for k in loaded_config.keys() if k.startswith("COLOR_CONFIG")]
+        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)
@@ -63,18 +79,26 @@ def edit_value(key, current_value, state):
     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[
-        edit_win.addstr(row, col, " " * input_width, get_color("settings_default"))  # Clear previous text
+            scroll_offset : scroll_offset + input_width
-        edit_win.addstr(row, col, visible_text, get_color("settings_default"))  # Display text
+        ]  # 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()
 
-        edit_win.move(row, col + min(len(user_input) - scroll_offset, input_width))  # Adjust cursor position
+        edit_win.move(
+            row, col + min(len(user_input) - scroll_offset, input_width)
+        )  # Adjust cursor position
         key = edit_win.get_wch()
 
         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
 
@@ -82,7 +106,9 @@ def edit_value(key, current_value, state):
             if user_input:  # Only process if there's something to delete
                 user_input = user_input[:-1]
                 if scroll_offset > 0 and len(user_input) < scroll_offset + input_width:
-                    scroll_offset -= 1  # Move back if text is shorter than scrolled area
+                    scroll_offset -= (
+                        1  # Move back if text is shorter than scrolled area
+                    )
         else:
             if isinstance(key, str):
                 user_input += key
@@ -96,23 +122,23 @@ def edit_value(key, current_value, state):
     return user_input if user_input else current_value
 
 
-def display_menu(state):
+def display_menu(menu_state: Any) -> tuple[Any, Any, list[str]]:
     """
     Render the configuration menu with a Save button directly added to the window.
     """
-    num_items = len(state.current_menu) + (1 if state.show_save_option else 0)
+    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(state.current_menu, dict):
+    if isinstance(menu_state.current_menu, dict):
-        options = list(state.current_menu.keys())
+        options = list(menu_state.current_menu.keys())
-    elif isinstance(state.current_menu, list):
+    elif isinstance(menu_state.current_menu, list):
-        options = [f"[{i}]" for i in range(len(state.current_menu))]
+        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)  
+    menu_height = min(max_menu_height, num_items + 5)
     num_items = len(options)
     start_y = (curses.LINES - menu_height) // 2
     start_x = (curses.COLS - width) // 2
@@ -130,110 +156,146 @@ def display_menu(state):
     menu_pad.bkgd(get_color("background"))
 
     # Display the menu path
-    header = " > ".join(state.menu_path)
+    header = " > ".join(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))
 
     # Populate the pad with menu options
     for idx, key in enumerate(options):
-        value = state.current_menu[key] if isinstance(state.current_menu, dict) else state.current_menu[int(key.strip("[]"))]
+        value = (
-        display_key = f"{key}"[:width // 2 - 2]
+            menu_state.current_menu[key]
-        display_value = (
+            if isinstance(menu_state.current_menu, dict)
-            f"{value}"[:width // 2 - 8]
+            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 == menu_state.selected_index)
+        )
+        menu_pad.addstr(
+            idx,
+            0,
+            f"{display_key:<{width // 2 - 2}} {display_value}".ljust(width - 8),
+            color,
         )
 
-        color = get_color("settings_default", reverse=(idx == 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
-    if state.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=(state.selected_index == len(state.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)),
+            ),
+        )
 
     menu_win.refresh()
     menu_pad.refresh(
-        state.start_index[-1], 0,
+        menu_state.start_index[-1],
-        menu_win.getbegyx()[0] + 3, menu_win.getbegyx()[1] + 4,
+        0,
-        menu_win.getbegyx()[0] + 3 + menu_win.getmaxyx()[0] - 5 - (2 if state.show_save_option else 0),
+        menu_win.getbegyx()[0] + 3,
-        menu_win.getbegyx()[1] + menu_win.getmaxyx()[1] - 4
+        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 state.show_save_option else 0) - 1
+    max_index = num_items + (1 if menu_state.show_save_option else 0) - 1
-    visible_height = menu_win.getmaxyx()[0] - 5 - (2 if state.show_save_option else 0)
+    visible_height = (
+        menu_win.getmaxyx()[0] - 5 - (2 if menu_state.show_save_option else 0)
+    )
 
-    draw_arrows(menu_win, visible_height, max_index, state)
+    draw_arrows(menu_win, visible_height, max_index, menu_state)
 
     return menu_win, menu_pad, options
 
 
-def move_highlight(old_idx, options, menu_win, menu_pad, state):
+# def move_highlight(
-    if old_idx == state.selected_index:  # No-op
+#     old_idx: int,
-        return
+#     options: list[str],
+#     menu_win: curses.window,
+#     menu_pad: curses.window,
+#     menu_state: Any
+# ) -> None:
 
-    max_index = len(options) + (1 if state.show_save_option else 0) - 1
+#     if old_idx == menu_state.selected_index:  # No-op
-    visible_height = menu_win.getmaxyx()[0] - 5 - (2 if state.show_save_option else 0)
+#         return
 
-    # Adjust state.start_index only when moving out of visible range
+#     max_index = len(options) + (1 if menu_state.show_save_option else 0) - 1
-    if state.selected_index == max_index and state.show_save_option:
+#     visible_height = menu_win.getmaxyx()[0] - 5 - (2 if menu_state.show_save_option else 0)
-        pass
-    elif state.selected_index < state.start_index[-1]:  # Moving above the visible area
-        state.start_index[-1] = state.selected_index
-    elif state.selected_index >= state.start_index[-1] + visible_height:  # Moving below the visible area
-        state.start_index[-1] = state.selected_index - visible_height
-    pass
 
-    # Ensure state.start_index is within bounds
+#     # Adjust menu_state.start_index only when moving out of visible range
-    state.start_index[-1] = max(0, min(state.start_index[-1], max_index - visible_height + 1))
+#     if menu_state.selected_index == max_index and menu_state.show_save_option:
+#         pass
+#     elif menu_state.selected_index < menu_state.start_index[-1]:  # Moving above the visible area
+#         menu_state.start_index[-1] = menu_state.selected_index
+#     elif menu_state.selected_index >= menu_state.start_index[-1] + visible_height:  # Moving below the visible area
+#         menu_state.start_index[-1] = menu_state.selected_index - visible_height
+#     pass
 
-    # Clear old selection
+#     # Ensure menu_state.start_index is within bounds
-    if state.show_save_option and old_idx == max_index:
+#     menu_state.start_index[-1] = max(0, min(menu_state.start_index[-1], max_index - visible_height + 1))
-        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
+#     # Clear old selection
-    if state.show_save_option and state.selected_index == max_index:
+#     if menu_state.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", reverse=True))
+#         menu_win.chgat(menu_win.getmaxyx()[0] - 2, (width - len(save_option)) // 2, len(save_option), get_color("settings_save"))
-    else:
+#     else:
-        menu_pad.chgat(state.selected_index, 0, menu_pad.getmaxyx()[1], get_color("settings_sensitive", reverse=True) if options[state.selected_index] in sensitive_settings else get_color("settings_default", reverse=True))
+#         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"))
 
-    menu_win.refresh()
+#     # Highlight new selection
-    
+#     if menu_state.show_save_option and menu_state.selected_index == max_index:
-    # Refresh pad only if scrolling is needed
+#         menu_win.chgat(menu_win.getmaxyx()[0] - 2, (width - len(save_option)) // 2, len(save_option), get_color("settings_save", reverse=True))
-    menu_pad.refresh(state.start_index[-1], 0,
+#     else:
-                     menu_win.getbegyx()[0] + 3, menu_win.getbegyx()[1] + 4,
+#         menu_pad.chgat(menu_state.selected_index, 0, menu_pad.getmaxyx()[1], get_color("settings_sensitive", reverse=True) if options[menu_state.selected_index] in sensitive_settings else get_color("settings_default", reverse=True))
-                     menu_win.getbegyx()[0] + 3 + visible_height, 
-                     menu_win.getbegyx()[1] + menu_win.getmaxyx()[1] - 4)
 
-    draw_arrows(menu_win, visible_height, max_index, state)
+#     menu_win.refresh()
+
+#     # Refresh pad only if scrolling is needed
+#     menu_pad.refresh(menu_state.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)
+
+#     draw_arrows(menu_win, visible_height, max_index, menu_state)
 
 
-def draw_arrows(win, visible_height, max_index, state):
+def draw_arrows(
+    win: curses.window, visible_height: int, max_index: int, menu_state: any
+) -> None:
 
-    mi = max_index - (2 if state.show_save_option else 0) 
+    mi = max_index - (2 if menu_state.show_save_option else 0)
 
     if visible_height < mi:
-        if state.start_index[-1] > 0:
+        if menu_state.start_index[-1] > 0:
             win.addstr(3, 2, "▲", get_color("settings_default"))
         else:
             win.addstr(3, 2, " ", get_color("settings_default"))
 
-        if mi - state.start_index[-1] >= visible_height + (0 if state.show_save_option else 1) :
+        if mi - menu_state.start_index[-1] >= visible_height + (
+            0 if menu_state.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 json_editor(stdscr, state):
+def json_editor(stdscr: curses.window, menu_state: Any) -> None:
 
-    state.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")
 
-    state.show_save_option = True  # Always show the Save button
+    menu_state.show_save_option = True  # Always show the Save button
 
     # Ensure the file exists
     if not os.path.exists(file_path):
@@ -241,41 +303,79 @@ def json_editor(stdscr, state):
             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
-    state.current_menu = 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 = display_menu(state)
+    menu_win, menu_pad, options = display_menu(menu_state)
     need_redraw = True
 
     while True:
-        if(need_redraw):
+        if need_redraw:
-            menu_win, menu_pad, options = display_menu(state)
+            menu_win, menu_pad, options = display_menu(menu_state)
             menu_win.refresh()
             need_redraw = False
-            
+
-        max_index = len(options) + (1 if state.show_save_option else 0) - 1
+        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 = state.selected_index
+            old_idx = menu_state.selected_index
-            state.selected_index = max_index if state.selected_index == 0 else state.selected_index - 1
+            menu_state.selected_index = (
-            move_highlight(old_selected_index, options, menu_win, menu_pad, state)
+                max_index
+                if menu_state.selected_index == 0
+                else menu_state.selected_index - 1
+            )
+            move_highlight(
+                old_idx,
+                menu_state.selected_index,
+                options,
+                menu_win,
+                menu_pad,
+                start_index_ref=menu_state.start_index[-1:],
+                selected_index=menu_state.selected_index,
+                show_save=menu_state.show_save_option,
+                sensitive_mode=True,
+            )
 
         elif key == curses.KEY_DOWN:
 
-            old_selected_index = state.selected_index
+            old_idx = menu_state.selected_index
-            state.selected_index = 0 if state.selected_index == max_index else state.selected_index + 1
+            menu_state.selected_index = (
-            move_highlight(old_selected_index, options, menu_win, menu_pad, state)
+                0
+                if menu_state.selected_index == max_index
+                else menu_state.selected_index + 1
+            )
+            move_highlight(
+                old_idx,
+                menu_state.selected_index,
+                options,
+                menu_win,
+                menu_pad,
+                start_index_ref=menu_state.start_index[-1:],
+                selected_index=menu_state.selected_index,
+                show_save=menu_state.show_save_option,
+                sensitive_mode=True,
+            )
 
-        elif key == ord("\t") and state.show_save_option:
+        elif key == ord("\t") and menu_state.show_save_option:
-            old_selected_index = state.selected_index
+            old_idx = menu_state.selected_index
-            state.selected_index = max_index
+            menu_state.selected_index = max_index
-            move_highlight(old_selected_index, options, menu_win, menu_pad, state)
+            move_highlight(
+                old_idx,
+                menu_state.selected_index,
+                options,
+                menu_win,
+                menu_pad,
+                start_index_ref=menu_state.start_index[-1:],
+                selected_index=menu_state.selected_index,
+                show_save=menu_state.show_save_option,
+                sensitive_mode=True,
+            )
 
         elif key in (curses.KEY_RIGHT, 10, 13):  # 10 = \n, 13 = carriage return
 
@@ -283,43 +383,47 @@ def json_editor(stdscr, state):
             menu_win.erase()
             menu_win.refresh()
 
-            if state.selected_index < len(options):  # Handle selection of a menu item
+            if menu_state.selected_index < len(
-                selected_key = options[state.selected_index]
+                options
-                state.menu_path.append(str(selected_key))
+            ):  # Handle selection of a menu item
-                state.start_index.append(0)
+                selected_key = options[menu_state.selected_index]
-                state.menu_index.append(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(state.current_menu, dict):
+                if isinstance(menu_state.current_menu, dict):
-                    if selected_key in state.current_menu:
+                    if selected_key in menu_state.current_menu:
-                        selected_data = state.current_menu[selected_key]
+                        selected_data = menu_state.current_menu[selected_key]
                     else:
                         continue  # Skip invalid key
-                elif isinstance(state.current_menu, list):
+                elif isinstance(menu_state.current_menu, list):
-                    selected_data = state.current_menu[int(selected_key.strip("[]"))]
+                    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)
-                    state.menu_path.pop()
+                    menu_state.menu_path.pop()
-                    state.start_index.pop()
+                    menu_state.start_index.pop()
-                    state.menu_index.pop()
+                    menu_state.menu_index.pop()
-                    state.current_menu[selected_key] = new_value
+                    menu_state.current_menu[selected_key] = new_value
 
                 elif isinstance(selected_data, (dict, list)):
                     # Navigate into nested data
-                    state.current_menu = selected_data
+                    menu_state.current_menu = selected_data
-                    state.selected_index = 0  # Reset the selected index
+                    menu_state.selected_index = 0  # Reset the selected index
 
                 else:
                     # General value editing
-                    new_value = edit_value(selected_key, selected_data, state)
+                    new_value = edit_value(selected_key, selected_data)
-                    state.menu_path.pop()
+                    menu_state.menu_path.pop()
-                    state.menu_index.pop()
+                    menu_state.menu_index.pop()
-                    state.start_index.pop()
+                    menu_state.start_index.pop()
-                    state.current_menu[selected_key] = new_value
+                    menu_state.current_menu[selected_key] = new_value
                     need_redraw = True
-                
+
             else:
                 # Save button selected
                 save_json(file_path, data)
@@ -332,42 +436,48 @@ def json_editor(stdscr, state):
             menu_win.erase()
             menu_win.refresh()
 
-            # state.selected_index = state.menu_index[-1]
+            # menu_state.selected_index = menu_state.menu_index[-1]
 
             # Navigate back in the menu
-            if len(state.menu_path) > 2:
+            if len(menu_state.menu_path) > 2:
-                state.menu_path.pop()
+                menu_state.menu_path.pop()
-                state.start_index.pop()
+                menu_state.start_index.pop()
-                state.current_menu = data
+                menu_state.current_menu = data
 
-                for path in state.menu_path[2:]:
+                for path in menu_state.menu_path[2:]:
-                    state.current_menu = state.current_menu[path] if isinstance(state.current_menu, dict) else state.current_menu[int(path.strip("[]"))]
+                    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
 
-    state = MenuState()
+    menu_state = MenuState()
-    if len(state.menu_path) == 0:
+    if len(menu_state.menu_path) == 0:
-        state.menu_path = ["App Settings"]  # Initialize if not set
+        menu_state.menu_path = ["App Settings"]  # Initialize if not set
 
     curses.curs_set(0)
     stdscr.keypad(True)
     setup_colors()
-    json_editor(stdscr, state)
+    json_editor(stdscr, menu_state)
+
 
 if __name__ == "__main__":
-    curses.wrapper(main)
+    curses.wrapper(main)

contact/utilities/arg_parser.py

@@ -1,7 +1,7 @@
-import argparse
+from argparse import ArgumentParser
 
-def setup_parser():
+def setup_parser() -> ArgumentParser:
-    parser = argparse.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.")
 

contact/utilities/config_io.py

@@ -1,9 +1,8 @@
 
 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
@@ -20,9 +19,9 @@ def traverseConfig(config_root, config, interface_config) -> bool:
 
     return True
 
-def splitCompoundName(comp_name: str) -> List[str]:
+def splitCompoundName(comp_name: str) -> list[str]:
     """Split compound (dot separated) preference name into parts"""
-    name: List[str] = comp_name.split(".")
+    name: list[str] = comp_name.split(".")
     if len(name) < 2:
         name[0] = comp_name
         name.append(comp_name)

contact/utilities/control_utils.py

@@ -1,10 +1,11 @@
 import re
 
+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."""
 
-def parse_ini_file(ini_file_path):
+    field_mapping: dict[str, str] = {}
-    field_mapping = {}
+    help_text: dict[str, str] = {}
-    help_text = {}
+    current_section: str | None = None
-    current_section = None
 
     with open(ini_file_path, 'r', encoding='utf-8') as f:
         for line in f:
@@ -46,14 +47,14 @@ def parse_ini_file(ini_file_path):
 
     return field_mapping, help_text
 
-def transform_menu_path(menu_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 = []
+    transformed_path: list[str] = []
     for part in menu_path[1:]:  # Skip 'Main Menu'
         # Apply fixed replacements
         part = path_replacements.get(part, part)

contact/utilities/db_handler.py

@@ -7,14 +7,15 @@ 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) -> int | None:
+
     """Save messages to the database, ensuring the table exists."""
     try:
         quoted_table_name = get_table_name(channel)
@@ -47,7 +48,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 +70,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:
@@ -142,7 +143,7 @@ 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:
@@ -172,7 +173,7 @@ 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']
@@ -190,7 +191,17 @@ 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=None, is_licensed=None, role=None, public_key=None, chat_archived=None):
+def update_node_info_in_db(
+    user_id: int | str,
+    long_name: str | None = None,
+    short_name: str | None = None,
+    hw_model: str | None = None,
+    is_licensed: str | int | None = None,
+    role: str | None = None,
+    public_key: str | None = None,
+    chat_archived: int | None = 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
@@ -249,7 +260,7 @@ def update_node_info_in_db(user_id, long_name=None, short_name=None, hw_model=No
         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 = '''
@@ -265,7 +276,7 @@ def ensure_node_table_exists():
     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:
@@ -279,7 +290,7 @@ 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.
     
@@ -313,7 +324,7 @@ 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()

contact/utilities/input_handlers.py

@@ -3,11 +3,14 @@ import binascii
 import curses
 import ipaddress
 import re
+from typing import Any, Optional
 from contact.ui.colors import get_color
+from contact.ui.navigation_utils import move_highlight
 
-def wrap_text(text, wrap_width):
+
+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
+    words = re.findall(r"\S+|\s+", text)  # Capture words and spaces separately
     wrapped_lines = []
     line_buffer = ""
     line_length = 0
@@ -23,7 +26,7 @@ def wrap_text(text, wrap_width):
                 line_buffer = ""
                 line_length = 0
             for i in range(0, word_length, wrap_width):
-                wrapped_lines.append(word[i:i+wrap_width])
+                wrapped_lines.append(word[i : i + wrap_width])
             continue
 
         if line_length + word_length > wrap_width and word.strip():
@@ -38,9 +41,9 @@ def wrap_text(text, wrap_width):
         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
@@ -60,14 +63,16 @@ def get_text_input(prompt):
     wrapped_prompt = wrap_text(prompt, wrap_width=input_width)
     row = 1
     for line in wrapped_prompt:
-        input_win.addstr(row, margin, line[:input_width], get_color("settings_default", bold=True))
+        input_win.addstr(
+            row, margin, line[:input_width], get_color("settings_default", bold=True)
+        )
         row += 1
         if row >= height - 3:  # Prevent overflow
             break
 
     prompt_text = "Enter new value: "
     input_win.addstr(row + 1, margin, prompt_text, get_color("settings_default"))
-    
+
     input_win.refresh()
     curses.curs_set(1)
 
@@ -104,21 +109,35 @@ def get_text_input(prompt):
         first_line = user_input[:first_line_width]  # Cut to max first line width
         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 []
+        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"))
 
         # Redraw wrapped input
-        input_win.addstr(row + 1, col_start, first_line, get_color("settings_default"))  # First line next to prompt
+        input_win.addstr(
+            row + 1, col_start, first_line, get_color("settings_default")
+        )  # First line next to prompt
         for i, line in enumerate(wrapped_lines):
             if row + 2 + i < height - 1:
-                input_win.addstr(row + 2 + i, margin, line[:input_width], get_color("settings_default"))
+                input_win.addstr(
+                    row + 2 + i,
+                    margin,
+                    line[:input_width],
+                    get_color("settings_default"),
+                )
 
         input_win.refresh()
 
@@ -128,7 +147,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]
@@ -163,56 +182,76 @@ def get_admin_key_input(current_value):
     while True:
         repeated_win.erase()
         repeated_win.border()
-        repeated_win.addstr(1, 2, "Edit up to 3 Admin Keys:", get_color("settings_default", bold=True))
+        repeated_win.addstr(
+            1, 2, "Edit up to 3 Admin Keys:", get_color("settings_default", bold=True)
+        )
 
         # 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
         curses.curs_set(1)
-        repeated_win.move(3 + cursor_pos, 18 + len(user_values[cursor_pos]))  # Position cursor at end of text
+        repeated_win.move(
+            3 + cursor_pos, 18 + len(user_values[cursor_pos])
+        )  # Position cursor at end of text
 
         # Show error message if needed
         if error_message:
-            repeated_win.addstr(7, 2, error_message, get_color("settings_default", bold=True))
+            repeated_win.addstr(
+                7, 2, error_message, get_color("settings_default", bold=True)
+            )
 
         repeated_win.refresh()
         key = repeated_win.getch()
 
-        if key == 27 or key == curses.KEY_LEFT:  # Escape or Left Arrow -> Cancel and return original
+        if (
+            key == 27 or key == curses.KEY_LEFT
+        ):  # Escape or Left Arrow -> Cancel and return original
             repeated_win.erase()
             repeated_win.refresh()
             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
+            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)
                 return user_values  # Return the edited Base64 values
             else:
-                error_message = "Error: Each key must be valid Base64 and 32 bytes long!"
+                error_message = (
+                    "Error: Each key must be valid Base64 and 32 bytes long!"
+                )
         elif key == curses.KEY_UP:  # Move cursor up
             cursor_pos = (cursor_pos - 1) % len(user_values)
         elif key == curses.KEY_DOWN:  # Move cursor down
             cursor_pos = (cursor_pos + 1) % len(user_values)
         elif key == curses.KEY_BACKSPACE or key == 127:  # Backspace key
             if len(user_values[cursor_pos]) > 0:
-                user_values[cursor_pos] = user_values[cursor_pos][:-1]  # Remove last character
+                user_values[cursor_pos] = user_values[cursor_pos][
+                    :-1
+                ]  # Remove last character
         else:
             try:
-                user_values[cursor_pos] += chr(key)  # Append valid character input to the selected field
+                user_values[cursor_pos] += chr(
+                    key
+                )  # Append valid character input to the selected field
                 error_message = ""  # Clear error if user starts fixing input
             except ValueError:
                 pass  # Ignore invalid character inputs
 
 
-
+def get_repeated_input(current_value: list[str]) -> Optional[str]:
-def get_repeated_input(current_value):
     height = 9
     width = 80
     start_y = (curses.LINES - height) // 2
@@ -234,33 +273,46 @@ def get_repeated_input(current_value):
     while True:
         repeated_win.erase()
         repeated_win.border()
-        repeated_win.addstr(1, 2, "Edit up to 3 Values:", get_color("settings_default", bold=True))
+        repeated_win.addstr(
+            1, 2, "Edit up to 3 Values:", get_color("settings_default", bold=True)
+        )
 
         # 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(
-            repeated_win.addstr(3 + i, 18, line) 
+                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)
-        repeated_win.move(3 + cursor_pos, 18 + len(user_values[cursor_pos]))  #  Position cursor at end of text
+        repeated_win.move(
+            3 + cursor_pos, 18 + len(user_values[cursor_pos])
+        )  #  Position cursor at end of text
 
         # Show error message if needed
         if error_message:
-            repeated_win.addstr(7, 2, error_message, get_color("settings_default", bold=True))
+            repeated_win.addstr(
+                7, 2, error_message, get_color("settings_default", bold=True)
+            )
 
         repeated_win.refresh()
         key = repeated_win.getch()
 
-        if key == 27 or key == curses.KEY_LEFT:  # Escape or Left Arrow -> Cancel and return original
+        if (
+            key == 27 or key == curses.KEY_LEFT
+        ):  # Escape or Left Arrow -> Cancel and return original
             repeated_win.erase()
             repeated_win.refresh()
             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)
@@ -270,16 +322,20 @@ def get_repeated_input(current_value):
             cursor_pos = (cursor_pos + 1) % len(user_values)
         elif key == curses.KEY_BACKSPACE or key == 127:  # Backspace key
             if len(user_values[cursor_pos]) > 0:
-                user_values[cursor_pos] = user_values[cursor_pos][:-1]  # Remove last character
+                user_values[cursor_pos] = user_values[cursor_pos][
+                    :-1
+                ]  # Remove last character
         else:
             try:
-                user_values[cursor_pos] += chr(key)  # Append valid character input to the selected field
+                user_values[cursor_pos] += chr(
+                    key
+                )  # Append valid character input to the selected field
                 error_message = ""  # Clear error if user starts fixing input
             except ValueError:
                 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
@@ -299,7 +355,9 @@ def get_fixed32_input(current_value):
     while True:
         fixed32_win.erase()
         fixed32_win.border()
-        fixed32_win.addstr(1, 2, "Enter an IP address (xxx.xxx.xxx.xxx):", curses.A_BOLD)
+        fixed32_win.addstr(
+            1, 2, "Enter an IP address (xxx.xxx.xxx.xxx):", curses.A_BOLD
+        )
         fixed32_win.addstr(3, 2, f"Current: {current_value}")
         fixed32_win.addstr(5, 2, f"New value: {user_input}")
         fixed32_win.refresh()
@@ -312,16 +370,23 @@ 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):
+            if len(octets) == 4 and all(
+                octet.isdigit() and 0 <= int(octet) <= 255 for octet in octets
+            ):
                 curses.noecho()
                 curses.curs_set(0)
                 fixed32_address = ipaddress.ip_address(user_input)
                 return int(fixed32_address)  # Return the valid IP address
             else:
-                fixed32_win.addstr(7, 2, "Invalid IP address. Try again.", curses.A_BOLD | curses.color_pair(5))
+                fixed32_win.addstr(
+                    7,
+                    2,
+                    "Invalid IP address. Try again.",
+                    curses.A_BOLD | curses.color_pair(5),
+                )
                 fixed32_win.refresh()
                 curses.napms(1500)  # Wait for 1.5 seconds before refreshing
                 user_input = ""  # Clear invalid input
@@ -336,11 +401,16 @@ 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.
     """
-    selected_index = list_options.index(current_option) if current_option in list_options else 0
+    selected_index = (
+        list_options.index(current_option) if current_option in list_options else 0
+    )
+    scroll_offset = 0
 
     height = min(len(list_options) + 5, curses.LINES)
     width = 80
@@ -363,16 +433,28 @@ def get_list_input(prompt, current_option, list_options):
     # Render options on the pad
     for idx, color in enumerate(list_options):
         if idx == selected_index:
-            list_pad.addstr(idx, 0, color.ljust(width - 8), get_color("settings_default", reverse=True))
+            list_pad.addstr(
+                idx,
+                0,
+                color.ljust(width - 8),
+                get_color("settings_default", reverse=True),
+            )
         else:
-            list_pad.addstr(idx, 0, color.ljust(width - 8), get_color("settings_default"))
+            list_pad.addstr(
+                idx, 0, color.ljust(width - 8), get_color("settings_default")
+            )
 
     # Initial refresh
     list_win.refresh()
-    list_pad.refresh(0, 0,
+    list_pad.refresh(
-                    list_win.getbegyx()[0] + 3, list_win.getbegyx()[1] + 4,
+        0,
-                    list_win.getbegyx()[0] + list_win.getmaxyx()[0] - 2, list_win.getbegyx()[1] + list_win.getmaxyx()[1] - 4)
+        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
 
@@ -382,14 +464,32 @@ def get_list_input(prompt, current_option, list_options):
         key = list_win.getch()
 
         if key == curses.KEY_UP:
-            old_selected_index = selected_index
+            old_idx = selected_index
             selected_index = max(0, selected_index - 1)
-            move_highlight(old_selected_index, selected_index, list_options, list_win, list_pad)
+            scroll_ref = [scroll_offset]
+            move_highlight(
+                old_idx,
+                selected_index,
+                list_options,
+                list_win,
+                list_pad,
+                start_index_ref=scroll_ref,
+            )
+            scroll_offset = scroll_ref[0]
         elif key == curses.KEY_DOWN:
-            old_selected_index = selected_index
+            old_idx = 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)
+            scroll_ref = [scroll_offset]
-        elif key == ord('\n'):  # Enter key
+            move_highlight(
+                old_idx,
+                selected_index,
+                list_options,
+                list_win,
+                list_pad,
+                start_index_ref=scroll_ref,
+            )
+            scroll_offset = scroll_ref[0]
+        elif key == ord("\n"):  # Enter key
             list_win.clear()
             list_win.refresh()
             return list_options[selected_index]
@@ -399,47 +499,55 @@ def get_list_input(prompt, current_option, list_options):
             return current_option
 
 
-def move_highlight(old_idx, new_idx, options, list_win, list_pad):
+# def move_highlight(
+#     old_idx: int,
+#     new_idx: int,
+#     options: list[str],
+#     list_win: curses.window,
+#     list_pad: curses.window
+# ) -> int:
 
-    global scroll_offset
+#     global scroll_offset
-    if 'scroll_offset' not in globals():
+#     if 'scroll_offset' not in globals():
-        scroll_offset = 0  # Initialize if not set
+#         scroll_offset = 0  # Initialize if not set
 
-    if old_idx == new_idx:
+#     if old_idx == new_idx:
-        return  # No-op
+#         return  # No-op
 
-    max_index = len(options) - 1
+#     max_index = len(options) - 1
-    visible_height = list_win.getmaxyx()[0] - 5
+#     visible_height = list_win.getmaxyx()[0] - 5
 
-    # Adjust scroll_offset only when moving out of visible range
+#     # Adjust scroll_offset only when moving out of visible range
-    if new_idx < scroll_offset:  # Moving above the visible area
+#     if new_idx < scroll_offset:  # Moving above the visible area
-        scroll_offset = new_idx
+#         scroll_offset = new_idx
-    elif new_idx >= scroll_offset + visible_height:  # Moving below the visible area
+#     elif new_idx >= scroll_offset + visible_height:  # Moving below the visible area
-        scroll_offset = new_idx - visible_height
+#         scroll_offset = new_idx - visible_height
 
-    # Ensure scroll_offset is within bounds
+#     # Ensure scroll_offset is within bounds
-    scroll_offset = max(0, min(scroll_offset, max_index - visible_height + 1))
+#     scroll_offset = max(0, min(scroll_offset, max_index - visible_height + 1))
 
-    # Clear old highlight
+#     # Clear old highlight
-    list_pad.chgat(old_idx, 0, list_pad.getmaxyx()[1], get_color("settings_default"))
+#     list_pad.chgat(old_idx, 0, list_pad.getmaxyx()[1], get_color("settings_default"))
 
-    # Highlight new selection
+#     # Highlight new selection
-    list_pad.chgat(new_idx, 0, list_pad.getmaxyx()[1], get_color("settings_default", reverse=True))
+#     list_pad.chgat(new_idx, 0, list_pad.getmaxyx()[1], get_color("settings_default", reverse=True))
 
-    list_win.refresh()
+#     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
+#     # 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):
+def draw_arrows(
+    win: curses.window, visible_height: int, max_index: int, start_index: int
+) -> None:
 
     if visible_height < max_index:
         if start_index > 0:
@@ -451,4 +559,3 @@ def draw_arrows(win, visible_height, max_index, start_index):
             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,41 @@
 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}")
             except Exception as ex:
                 logging.error(f"Unexpected error initializing interface: {ex}")
-            if globals.interface.devPath is None:
+            except OSError as ex:
-                return meshtastic.tcp_interface.TCPInterface("localhost")
+                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,7 @@ import logging
 import base64
 import time
 
-def save_changes(interface, modified_settings, state):
+def save_changes(interface, modified_settings, menu_state):
     """
     Save changes to the device based on modified settings.
     :param interface: Meshtastic interface instance
@@ -52,8 +52,8 @@ def save_changes(interface, modified_settings, state):
             if not modified_settings:
                 return
 
-        if state.menu_path[1] ==  "Radio Settings" or state.menu_path[1] == "Module Settings":
+        if menu_state.menu_path[1] ==  "Radio Settings" or menu_state.menu_path[1] == "Module Settings":
-            config_category = state.menu_path[2].lower() # for radio and module configs
+            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))
@@ -64,7 +64,7 @@ def save_changes(interface, modified_settings, state):
                 logging.info(f"Updated {config_category} with Latitude: {lat} and Longitude {lon} and Altitude {alt}")
                 return
 
-        elif state.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")
@@ -77,11 +77,11 @@ def save_changes(interface, modified_settings, state):
 
             return
         
-        elif state.menu_path[1] == "Channels":    # for channel configs
+        elif menu_state.menu_path[1] == "Channels":    # for channel configs
             config_category = "Channels"
 
             try:
-                channel = state.menu_path[-1]
+                channel = menu_state.menu_path[-1]
                 channel_num = int(channel.split()[-1]) - 1
             except (IndexError, ValueError) as e:
                 channel_num = None

pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "contact"
-version = "1.3.4"
+version = "1.3.6"
 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"}