ignore

.github/workflows/release.yaml

@@ -1,143 +0,0 @@
-name: release
-
-on:
-  push:
-    tags:
-      - "[0-9]+.[0-9]+.[0-9]+"
-      - "[0-9]+.[0-9]+.[0-9]+a[0-9]+"
-      - "[0-9]+.[0-9]+.[0-9]+b[0-9]+"
-      - "[0-9]+.[0-9]+.[0-9]+rc[0-9]+"
-
-env:
-  PACKAGE_NAME: "contact"
-  OWNER: "pdxlocations"
-
-jobs:
-  details:
-    runs-on: ubuntu-latest
-    outputs:
-      new_version: ${{ steps.release.outputs.new_version }}
-      suffix: ${{ steps.release.outputs.suffix }}
-      tag_name: ${{ steps.release.outputs.tag_name }}
-    steps:
-      - uses: actions/checkout@v2
-
-      - name: Extract tag and Details
-        id: release
-        run: |
-          if [ "${{ github.ref_type }}" = "tag" ]; then
-            TAG_NAME=${GITHUB_REF#refs/tags/}
-            NEW_VERSION=$(echo $TAG_NAME | awk -F'-' '{print $1}')
-            SUFFIX=$(echo $TAG_NAME | grep -oP '[a-z]+[0-9]+' || echo "")
-            echo "new_version=$NEW_VERSION" >> "$GITHUB_OUTPUT"
-            echo "suffix=$SUFFIX" >> "$GITHUB_OUTPUT"
-            echo "tag_name=$TAG_NAME" >> "$GITHUB_OUTPUT"
-            echo "Version is $NEW_VERSION"
-            echo "Suffix is $SUFFIX"
-            echo "Tag name is $TAG_NAME"
-          else
-            echo "No tag found"
-            exit 1
-          fi
-
-  check_pypi:
-    needs: details
-    runs-on: ubuntu-latest
-    steps:
-      - name: Fetch information from PyPI
-        run: |
-          response=$(curl -s https://pypi.org/pypi/${{ env.PACKAGE_NAME }}/json || echo "{}")
-          latest_previous_version=$(echo $response | jq --raw-output "select(.releases != null) | .releases | keys_unsorted | last")
-          if [ -z "$latest_previous_version" ]; then
-            echo "Package not found on PyPI."
-            latest_previous_version="0.0.0"
-          fi
-          echo "Latest version on PyPI: $latest_previous_version"
-          echo "latest_previous_version=$latest_previous_version" >> $GITHUB_ENV
-
-      - name: Compare versions and exit if not newer
-        run: |
-          NEW_VERSION=${{ needs.details.outputs.new_version }}
-          LATEST_VERSION=$latest_previous_version
-          if [ "$(printf '%s\n' "$LATEST_VERSION" "$NEW_VERSION" | sort -rV | head -n 1)" != "$NEW_VERSION" ] || [ "$NEW_VERSION" == "$LATEST_VERSION" ]; then
-            echo "The new version $NEW_VERSION is not greater than the latest version $LATEST_VERSION on PyPI."
-            exit 1
-          else
-            echo "The new version $NEW_VERSION is greater than the latest version $LATEST_VERSION on PyPI."
-          fi
-
-  setup_and_build:
-    needs: [details, check_pypi]
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v4
-
-      - name: Set up Python
-        uses: actions/setup-python@v4
-        with:
-          python-version: "3.12"
-
-      - name: Install Poetry
-        run: |
-          curl -sSL https://install.python-poetry.org | python3 -
-          echo "$HOME/.local/bin" >> $GITHUB_PATH
-
-      - name: Set project version with Poetry
-        run: |
-          poetry version ${{ needs.details.outputs.new_version }}
-
-      - name: Install dependencies
-        run: poetry install --sync --no-interaction
-
-      - name: Build source and wheel distribution
-        run: |
-          poetry build
-
-      - name: Upload artifacts
-        uses: actions/upload-artifact@v4
-        with:
-          name: dist
-          path: dist/
-
-  pypi_publish:
-    name: Upload release to PyPI
-    needs: [setup_and_build, details]
-    runs-on: ubuntu-latest
-    environment:
-      name: release
-    permissions:
-      id-token: write
-    steps:
-      - name: Download artifacts
-        uses: actions/download-artifact@v4
-        with:
-          name: dist
-          path: dist/
-
-      - name: Publish distribution to PyPI
-        uses: pypa/gh-action-pypi-publish@release/v1
-
-  github_release:
-    name: Create GitHub Release
-    needs: [setup_and_build, details]
-    runs-on: ubuntu-latest
-    permissions:
-      contents: write
-    steps:
-      - name: Checkout Code
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Download artifacts
-        uses: actions/download-artifact@v4
-        with:
-          name: dist
-          path: dist/
-
-      - name: Create GitHub Release
-        id: create_release
-        env:
-          GH_TOKEN: ${{ github.token }}
-        run: |
-          gh release create ${{ needs.details.outputs.tag_name }} dist/* --title ${{ needs.details.outputs.tag_name }} --generate-notes

.gitignore

@@ -8,4 +8,6 @@ client.log
 settings.log
 config.json
 default_config.log
-dist/
+client.db-shm
+client.db-wal
+client.db.bk

.vscode/launch.json

@@ -1,13 +0,0 @@
-{
-    "version": "0.1.0",
-    "configurations": [
-        {
-            "name": "Python Debugger: Current File",
-            "type": "debugpy",
-            "request": "launch",
-            "cwd": "${workspaceFolder}",
-            "module": "contact.__main__",
-            "args": []
-        }
-    ]
-}

.vscode/settings.json

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

README.md

@@ -1,21 +1,17 @@
 ## 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 `contact --settings` or `contact -c`
+The settings dialogue can be accessed within the client or may be run standalone to configure your node by launching `settings.py`
 
-<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" />
+<img width="441" alt="Contact - Settings Dialogue" src="https://github.com/user-attachments/assets/dd47f52a-d4d8-4e40-8001-9ea53d87f816" />
 
 ## Message Persistence 
 
@@ -52,18 +48,17 @@ 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.
 
 ### Example Usage
 
 ```sh
-contact --port /dev/ttyUSB0
-contact --host 192.168.1.1
-contact --ble BlAddressOfDevice
+python main.py --port /dev/ttyUSB0
+python main.py --host 192.168.1.1
+python main.py --ble BlAddressOfDevice
 ```
 To quickly connect to localhost, use:
 ```sh
-contact -t
+python main.py -t
 ```

contact/__main__.py

@@ -1,137 +0,0 @@
-#!/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/ui/control_ui.py

@@ -1,535 +0,0 @@
-import base64
-import curses
-import logging
-import os
-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.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.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
-
-menu_state = MenuState()
-
-# Constants
-width = 80
-save_option = "Save Changes"
-max_help_lines = 0
-help_win = None
-sensitive_settings = ["Reboot", "Reset Node DB", "Shutdown", "Factory Reset"]
-
-# Get the parent directory of the script
-script_dir = os.path.dirname(os.path.abspath(__file__))
-parent_dir = os.path.abspath(os.path.join(script_dir, os.pardir))
-
-# Paths
-locals_dir = os.path.dirname(os.path.abspath(sys.argv[0]))  # Current script directory
-translation_file = os.path.join(parent_dir, "localisations", "en.ini")
-
-config_folder = os.path.join(locals_dir, "node-configs")
-
-# Load translations
-field_mapping, help_text = parse_ini_file(translation_file)
-
-
-def display_menu(menu_state: MenuState) -> tuple[object, object]:  # curses.window or pad types
-
-    min_help_window_height = 6
-    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)
-    start_y = (curses.LINES - menu_height) // 2 - (min_help_window_height // 2)
-    start_x = (curses.COLS - width) // 2
-
-    # Calculate remaining space for help window
-    global max_help_lines
-    remaining_space = curses.LINES - (start_y + menu_height + 2)  # +2 for padding
-    max_help_lines = max(remaining_space, 1)  # Ensure at least 1 lines for help
-
-    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)
-
-    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_state.menu_path)
-    if len(header) > width - 4:
-        header = header[: width - 7] + "..."
-    menu_win.addstr(1, 2, header, get_color("settings_breadcrumbs", bold=True))
-
-    transformed_path = transform_menu_path(menu_state.menu_path)
-
-    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])
-        display_name = field_mapping.get(full_key, option)
-
-        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 == 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 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))),
-        )
-
-    # Draw help window with dynamically updated max_help_lines
-    draw_help_window(start_y, start_x, menu_height, max_help_lines, transformed_path, menu_state)
-
-    menu_win.refresh()
-    menu_pad.refresh(
-        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 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, menu_state.show_save_option)
-
-    return menu_win, menu_pad
-
-
-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():
-        help_win = None  # Initialize if it does not exist
-
-    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 settings_menu(stdscr: object, interface: object) -> None:
-    curses.update_lines_cols()
-
-    menu = generate_menu_from_protobuf(interface)
-    menu_state.current_menu = menu["Main Menu"]
-    menu_state.menu_path = ["Main Menu"]
-
-    modified_settings = {}
-
-    need_redraw = True
-    menu_state.show_save_option = False
-
-    while True:
-        if need_redraw:
-            options = list(menu_state.current_menu.keys())
-
-            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(menu_state)
-
-            need_redraw = False
-
-        # Capture user input
-        key = menu_win.getch()
-
-        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 = 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 = 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
-            curses.update_lines_cols()
-
-            menu_win.erase()
-            help_win.erase()
-
-            menu_win.refresh()
-            help_win.refresh()
-
-        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"):
-            need_redraw = True
-            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, menu_state.current_menu, selected_index, transform_menu_path(menu_state.menu_path))
-
-            menu_win.refresh()
-            help_win.refresh()
-
-            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_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[menu_state.selected_index]
-
-            if selected_option == "Exit":
-                break
-
-            elif selected_option == "Export Config File":
-                filename = get_text_input("Enter a filename for the config file")
-                if not filename:
-                    logging.info("Export aborted: No filename provided.")
-                    menu_state.start_index.pop()
-                    continue  # Go back to the menu
-                if not filename.lower().endswith(".yaml"):
-                    filename += ".yaml"
-
-                try:
-                    config_text = config_export(interface)
-                    yaml_file_path = os.path.join(config_folder, filename)
-
-                    if os.path.exists(yaml_file_path):
-                        overwrite = get_list_input(f"{filename} already exists. Overwrite?", None, ["Yes", "No"])
-                        if overwrite == "No":
-                            logging.info("Export cancelled: User chose not to overwrite.")
-                            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)
-                    menu_state.start_index.pop()
-                    continue
-                except PermissionError:
-                    logging.error(f"Permission denied: Unable to write to {yaml_file_path}")
-                except OSError as e:
-                    logging.error(f"OS error while saving config: {e}")
-                except Exception as e:
-                    logging.error(f"Unexpected error: {e}")
-                menu_state.start_index.pop()
-                continue
-
-            elif selected_option == "Load Config File":
-
-                # Check if folder exists and is not empty
-                if not os.path.exists(config_folder) or not any(os.listdir(config_folder)):
-                    dialog(stdscr, "", " No config files found. Export a config first.")
-                    continue  # Return to menu
-
-                file_list = [f for f in os.listdir(config_folder) if os.path.isfile(os.path.join(config_folder, f))]
-
-                # Ensure file_list is not empty before proceeding
-                if not file_list:
-                    dialog(stdscr, "", " No config files found. Export a config first.")
-                    continue
-
-                filename = get_list_input("Choose a config file", None, file_list)
-                if filename:
-                    file_path = os.path.join(config_folder, filename)
-                    overwrite = get_list_input(f"Are you sure you want to load {filename}?", None, ["Yes", "No"])
-                    if overwrite == "Yes":
-                        config_import(interface, file_path)
-                menu_state.start_index.pop()
-                continue
-
-            elif selected_option == "Config URL":
-                current_value = interface.localNode.getURL()
-                new_value = get_text_input(f"Config URL is currently: {current_value}")
-                if new_value is not None:
-                    current_value = new_value
-                    overwrite = get_list_input(f"Are you sure you want to load this config?", None, ["Yes", "No"])
-                    if overwrite == "Yes":
-                        interface.localNode.setURL(new_value)
-                        logging.info(f"New Config URL sent to node")
-                menu_state.start_index.pop()
-                continue
-
-            elif selected_option == "Reboot":
-                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")
-                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"])
-                if confirmation == "Yes":
-                    interface.localNode.resetNodeDb()
-                    logging.info(f"Node DB Reset Requested by menu")
-                menu_state.start_index.pop()
-                continue
-
-            elif selected_option == "Shutdown":
-                confirmation = get_list_input("Are you sure you want to Shutdown?", None, ["Yes", "No"])
-                if confirmation == "Yes":
-                    interface.localNode.shutdown()
-                    logging.info(f"Node Shutdown Requested by menu")
-                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"])
-                if confirmation == "Yes":
-                    interface.localNode.factoryReset()
-                    logging.info(f"Factory Reset Requested by menu")
-                menu_state.start_index.pop()
-                continue
-
-            elif selected_option == "App Settings":
-                menu_win.clear()
-                menu_win.refresh()
-                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 = 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_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"]:
-                        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
-                        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"],
-                        )
-                        new_value = new_value == "True"
-                        menu_state.current_menu[selected_option] = (field, new_value)
-
-                    for option, (field, value) in menu_state.current_menu.items():
-                        modified_settings[option] = value
-
-                    menu_state.start_index.pop()
-
-                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
-                    menu_state.current_menu[selected_option] = (field, new_value)
-
-                    for option in ["latitude", "longitude", "altitude"]:
-                        if option in menu_state.current_menu:
-                            modified_settings[option] = menu_state.current_menu[option][1]
-
-                    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]
-                    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"])
-                    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(", ")
-                    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)
-                    menu_state.start_index.pop()
-
-                elif field.type == 7:  # Field type 7 corresponds to FIXED32
-                    new_value = get_fixed32_input(current_value)
-                    menu_state.start_index.pop()
-
-                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)
-                    menu_state.start_index.pop()
-
-                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)
-                    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
-                    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
-                modified_settings[selected_option] = new_value
-
-                # Convert enum string to int
-                if field and field.enum_type:
-                    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
-
-                menu_state.current_menu[selected_option] = (field, new_value)
-            else:
-                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
-
-            menu_win.erase()
-            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, menu_state.current_menu, selected_index, transform_menu_path(menu_state.menu_path))
-
-            menu_win.refresh()
-            help_win.refresh()
-
-            if len(menu_state.menu_path) < 2:
-                modified_settings.clear()
-
-            # Navigate back to the previous menu
-            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: object) -> None:
-    node = interface.getNode("^local")
-    device_config = node.localConfig
-    lora_descriptor = device_config.lora.DESCRIPTOR
-
-    # Get the enum mapping of region names to their numerical values
-    region_enum = lora_descriptor.fields_by_name["region"].enum_type
-    region_name_to_number = {v.name: v.number for v in region_enum.values}
-
-    regions = list(region_name_to_number.keys())
-
-    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")

contact/ui/nav_utils.py

@@ -1,318 +0,0 @@
-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/ui_state.py

@@ -1,11 +0,0 @@
-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,343 +0,0 @@
-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 = 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.
-    """
-    color_list = [" "] + list(COLOR_MAP.keys())
-    fg_color = get_list_input(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: str, current_value: str) -> str:
-
-    height = 10
-    input_width = width - 16  # Allow space for "New Value: "
-    start_y = (curses.LINES - height) // 2
-    start_x = (curses.COLS - width) // 2
-
-    # Create a centered window
-    edit_win = curses.newwin(height, width, start_y, start_x)
-    edit_win.bkgd(get_color("background"))
-    edit_win.attrset(get_color("window_frame"))
-    edit_win.border()
-
-    # Display instructions
-    edit_win.addstr(1, 2, f"Editing {key}", get_color("settings_default", bold=True))
-    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)]
-
-    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()
-
-    # 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")]
-        return get_list_input("Select Theme", current_value, theme_options)
-    elif key == "node_sort":
-        sort_options = ["lastHeard", "name", "hops"]
-        return get_list_input("Sort By", current_value, sort_options)
-
-    # Standard Input Mode (Scrollable)
-    edit_win.addstr(7, 2, "New Value: ", get_color("settings_default"))
-    curses.curs_set(1)
-
-    scroll_offset = 0  # Determines which part of the text is visible
-    user_input = ""
-    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
-        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
-        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
-
-        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]
-                if scroll_offset > 0 and len(user_input) < scroll_offset + input_width:
-                    scroll_offset -= 1  # Move back if text is shorter than scrolled area
-        else:
-            if isinstance(key, str):
-                user_input += key
-            else:
-                user_input += chr(key)
-
-            if len(user_input) > input_width:  # Scroll if input exceeds visible area
-                scroll_offset += 1
-
-    curses.curs_set(0)
-    return user_input if user_input else current_value
-
-
-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(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)
-    start_y = (curses.LINES - menu_height) // 2
-    start_x = (curses.COLS - width) // 2
-
-    # Create the window
-    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)
-
-    # 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 = (
-            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 == 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
-    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))),
-        )
-
-    menu_win.refresh()
-    menu_pad.refresh(
-        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 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, menu_state.show_save_option)
-
-    return menu_win, menu_pad, options
-
-
-def json_editor(stdscr: curses.window, menu_state: Any) -> None:
-
-    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")
-
-    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):
-        with open(file_path, "w") as f:
-            json.dump({}, f)
-
-    # Load JSON data
-    with open(file_path, "r", encoding="utf-8") as f:
-        original_data = json.load(f)
-
-    data = original_data  # Reference to the original data
-    menu_state.current_menu = data  # Track the current level of the menu
-
-    # Render the menu
-    menu_win, menu_pad, options = display_menu(menu_state)
-    need_redraw = True
-
-    while True:
-        if need_redraw:
-            menu_win, menu_pad, options = display_menu(menu_state)
-            menu_win.refresh()
-            need_redraw = False
-
-        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 = 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 = 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 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, 10, 13):  # 10 = \n, 13 = carriage return
-
-            need_redraw = True
-            menu_win.erase()
-            menu_win.refresh()
-
-            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(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(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)
-                    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_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)
-                    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:
-                # Save button selected
-                save_json(file_path, data)
-                stdscr.refresh()
-                continue
-
-        elif key in (27, curses.KEY_LEFT):  # Escape or Left Arrow
-
-            need_redraw = True
-            menu_win.erase()
-            menu_win.refresh()
-
-            # menu_state.selected_index = menu_state.menu_index[-1]
-
-            # Navigate back in the menu
-            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: 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: 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, menu_state)
-
-
-if __name__ == "__main__":
-    curses.wrapper(main)

contact/utilities/arg_parser.py

@@ -1,39 +0,0 @@
-from argparse import ArgumentParser
-
-
-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",
-        "--serial",
-        "-s",
-        help="The port to connect to via serial, e.g. `/dev/ttyUSB0`.",
-        nargs="?",
-        default=None,
-        const=None,
-    )
-    conn.add_argument(
-        "--host",
-        "--tcp",
-        "-t",
-        help="The hostname or IP address to connect to using TCP.",
-        nargs="?",
-        default=None,
-        const="localhost",
-    )
-    conn.add_argument(
-        "--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

contact/utilities/interfaces.py

@@ -1,43 +0,0 @@
-import logging
-import meshtastic.serial_interface, meshtastic.tcp_interface, meshtastic.ble_interface
-
-
-def initialize_interface(args):
-    try:
-
-        if args.ble:
-            return meshtastic.ble_interface.BLEInterface(args.ble if args.ble != "any" else None)
-
-        elif 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:
-                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}")
-            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}")

globals.py

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

localisations/en.ini

@@ -24,9 +24,9 @@ serial_enabled, "Enable serial console", ""
 button_gpio, "Button GPIO", "GPIO pin for user button."
 buzzer_gpio, "Buzzer GPIO", "GPIO pin for user buzzer."
 rebroadcast_mode, "Rebroadcast mode", "This setting defines the device's behavior for how messages are rebroadcast."
-node_info_broadcast_secs, "Nodeinfo broadcast interval", "This is the number of seconds between NodeInfo message broadcasts. Will also send a nodeinfo in response to new nodes on the mesh."
+node_info_broadcast_secs, "Nodeinfo broadcast interval", "This is the number of seconds between NodeInfo message broadcasts. Femtofox will still send nodeinfo in response to new nodes on the mesh."
 double_tap_as_button_press, "Double tap as button press", "This option will enable a double tap, when a supported accelerometer is attached to the device, to be treated as a button press."
-is_managed, "Enable managed mode", "Enabling Managed Mode blocks smartphone apps and web UI from changing configuration. [note]This setting is not required for remote node administration.[/note] Before enabling, verify that node can be controlled via Remote Admin to [warning]prevent being locked out.[/warning]"
+is_managed, "Enable managed mode", "Enabling Managed Mode blocks smartphone apps and web UI from changing configuration. [note]This setting is not required for remote node administration.[/note]Before enabling, verify that node can be controlled via Remote Admin to [warning]prevent being locked out.[/warning]"
 disable_triple_click, "Disable triple button press", ""
 tzdef, "Timezone", "Uses the TZ Database format to display the correct local time on the device display and in its logs."
 led_heartbeat_disabled, "Disable LED heartbeat", "On certain hardware models, this disables the blinking heartbeat LED."
@@ -78,13 +78,6 @@ 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."
@@ -112,35 +105,6 @@ 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"
@@ -151,7 +115,7 @@ spread_factor, "Spread factor", "Indicates the number of chirps per symbol. Only
 coding_rate, "Coding rate", "The proportion of each LoRa transmission that contains actual data - the rest is used for error correction."
 frequency_offset, "Frequency offset", "This parameter is for advanced users with advanced test equipment."
 region, "Region", "Sets the region for your node. As long as this is not set, the node will display a message and not transmit any packets."
-hop_limit, "Hop limit", "The maximum number of intermediate nodes between our node and a node it is sending to. Does not impact received messages.\n[warning]Excessive hop limit increases congestion![/warning]\nMust be between 0-7."
+hop_limit, "Hop limit", "The maximum number of intermediate nodes between Femtofox and a node it is sending to. Does not impact received messages.\n[warning]Excessive hop limit increases congestion![/warning]\nMust be between 0-7."
 tx_enabled, "Enable TX", "Enables/disables the radio chip. Useful for hot-swapping antennas."
 tx_power, "TX power in dBm", "[warning]Setting a 33db radio above 8db will permanently damage it. ERP above 27db violates EU law. ERP above 36db violates US (unlicensed) law.[/warning] If 0, will use the max continuous power legal in region. Must be 0-30 (0=automatic)."
 channel_num, "Frequency slot", "Determines the exact frequency the radio transmits and receives. If unset or set to 0, determined automatically by the primary channel name."
@@ -175,7 +139,7 @@ private_key, "Private key", "The private key of the device, used to create a sha
 is_managed, "Enable managed mode", "Enabling Managed Mode blocks smartphone apps and web UI from changing configuration. [note]This setting is not required for remote node administration.[/note]Before enabling, verify that node can be controlled via Remote Admin to [warning]prevent being locked out.[/warning]"
 serial_enabled, "Enable serial console", ""
 debug_log_api_enabled, "Enable debug log", "Set this to true to continue outputting live debug logs over serial or Bluetooth when the API is active."
-admin_channel_enabled, "Enable legacy admin channel", "If the node you need to administer or be administered by is running 2.4.x or earlier, you should set this to enabled. Requires a secondary channel named 'admin' be present on both nodes."
+admin_channel_enabled, "Enable legacy admin channel", "If the node you Femtofox needs to administer or be administered by is running 2.4.x or earlier, you should set this to enabled. Requires a secondary channel named 'admin' be present on both nodes."
 admin_key, "Admin keys", "The public key(s) authorized to send administrative messages to this node. Only messages signed by these keys will be accepted for administrative control. Up to 3."
 
 [module.mqtt]

main.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+
+'''
+Contact - A Console UI for Meshtastic by http://github.com/pdxlocations
+Powered by Meshtastic.org
+V 1.2.2
+'''
+
+import contextlib
+import curses
+import os
+from pubsub import pub
+import sys
+import io
+import logging
+import traceback
+import threading
+
+from utilities.db_handler import init_nodedb, load_messages_from_db
+from message_handlers.rx_handler import on_receive
+from settings import set_region
+from ui.curses_ui import main_ui
+from ui.colors import setup_colors
+from ui.splash import draw_splash
+import ui.default_config as config
+from utilities.arg_parser import setup_parser
+from utilities.interfaces import initialize_interface
+from utilities.input_handlers import get_list_input
+from utilities.utils import get_channels, get_node_list, get_nodeNum
+import 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
+
+if __name__ == "__main__":
+    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

message_handlers/rx_handler.py

@@ -1,79 +1,62 @@
 import logging
 import time
+from utilities.utils import refresh_node_list
 from datetime import datetime
-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 ui.curses_ui import draw_packetlog_win, draw_node_list, draw_messages_window, draw_channel_list, add_notification
+from utilities.db_handler import save_message_to_db, maybe_store_nodeinfo_in_db, get_name_from_database, update_node_info_in_db
+import ui.default_config as config
+import globals
 
 
-def on_receive(packet: Dict[str, Any], interface: Any) -> None:
-    """
-    Handles an incoming packet from a Meshtastic interface.
+from datetime import datetime
+
+def on_receive(packet, 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)
@@ -82,15 +65,15 @@ def on_receive(packet: Dict[str, Any], interface: Any) -> None:
                     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]]
@@ -109,9 +92,7 @@ def on_receive(packet: Dict[str, Any], interface: Any) -> None:
                 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()

message_handlers/tx_handler.py

@@ -1,42 +1,29 @@
 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,
-)
-import contact.ui.default_config as config
-import contact.globals as globals
-
-ack_naks: Dict[str, Dict[str, Any]] = {}  # requestId -> {channel, messageIndex, timestamp}
+from utilities.db_handler import save_message_to_db, update_ack_nak, get_name_from_database, is_chat_archived, update_node_info_in_db
+import ui.default_config as config
+import globals
 
+ack_naks = {}
 
 # 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: 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:
+def onAckNak(packet):
+    from ui.curses_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:
@@ -46,28 +33,22 @@ def onAckNak(packet: Dict[str, Any]) -> None:
         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: 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
+def on_response_traceroute(packet):
+    """on response for trace route"""
+    from ui.curses_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"])
@@ -75,76 +56,48 @@ def on_response_traceroute(packet: Dict[str, Any]) -> None:
 
     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
@@ -152,25 +105,20 @@ def on_response_traceroute(packet: Dict[str, Any]) -> None:
         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: str, destination: int = BROADCAST_NUM, channel: int = 0) -> None:
-    """
-    Sends a chat message using the selected channel.
-    """
+def send_message(message, destination=BROADCAST_NUM, channel=0):
     myid = globals.myNodeNum
     send_on_channel = 0
     channel_id = globals.channel_list[channel]
@@ -195,7 +143,7 @@ def send_message(message: str, destination: int = BROADCAST_NUM, channel: int =
 
     # 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]
@@ -218,17 +166,9 @@ def send_message(message: str, destination: int = BROADCAST_NUM, channel: int =
 
     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() -> None:
-    """
-    Sends a RouteDiscovery protobuf to the selected node.
-    """
+def send_traceroute():
     r = mesh_pb2.RouteDiscovery()
     globals.interface.sendData(
         r,

pyproject.toml

@@ -1,24 +0,0 @@
-[project]
-name = "contact"
-version = "1.3.8"
-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"}
-]
-license = "GPL-3.0-only"
-readme = "README.md"
-requires-python = ">=3.9,<3.14"
-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"

settings.py

@@ -5,19 +5,19 @@ import logging
 import sys
 import traceback
 
-import contact.ui.default_config as config
-from contact.utilities.input_handlers import get_list_input
-from contact.ui.colors import setup_colors
-from contact.ui.splash import draw_splash
-from contact.ui.control_ui import set_region, settings_menu
-from contact.utilities.arg_parser import setup_parser
-from contact.utilities.interfaces import initialize_interface
+import ui.default_config as config
+from utilities.input_handlers import get_list_input
+from ui.colors import setup_colors
+from ui.splash import draw_splash
+from ui.control_ui import set_region, settings_menu
+from utilities.arg_parser import setup_parser
+from utilities.interfaces import initialize_interface
 
 
-def main(stdscr: curses.window) -> None:
+def main(stdscr):
     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: curses.window) -> None:
             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: curses.window) -> None:
         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

ui/colors.py

@@ -1,5 +1,5 @@
 import curses
-import contact.ui.default_config as config
+import ui.default_config as config
 
 COLOR_MAP = {
     "black": curses.COLOR_BLACK,
@@ -9,11 +9,10 @@ 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: bool = False) -> None:
+def setup_colors(reinit=False):
     """
     Initialize curses color pairs based on the COLOR_CONFIG.
     """
@@ -30,7 +29,7 @@ def setup_colors(reinit: bool = False) -> None:
     print()
 
 
-def get_color(category: str, bold: bool = False, reverse: bool = False, underline: bool = False) -> int:
+def get_color(category, bold=False, reverse=False, underline=False):
     """
     Retrieve a curses color pair with optional attributes.
     """
@@ -41,4 +40,4 @@ def get_color(category: str, bold: bool = False, reverse: bool = False, underlin
         color |= curses.A_REVERSE
     if underline:
         color |= curses.A_UNDERLINE
-    return color
+    return color

ui/control_ui.py

@@ -0,0 +1,638 @@
+import base64
+import curses
+import logging
+import os
+import re
+import sys
+
+from utilities.save_to_radio import save_changes
+from utilities.config_io import config_export, config_import
+from utilities.input_handlers import get_repeated_input, get_text_input, get_fixed32_input, get_list_input, get_admin_key_input
+from ui.menus import generate_menu_from_protobuf
+from ui.colors import get_color
+from ui.dialog import dialog
+from utilities.control_utils import parse_ini_file, transform_menu_path
+from ui.user_config import json_editor
+
+# Constants
+width = 80
+save_option = "Save Changes"
+max_help_lines = 0
+help_win = None
+sensitive_settings = ["Reboot", "Reset Node DB", "Shutdown", "Factory Reset"]
+
+# Get the parent directory of the script
+script_dir = os.path.dirname(os.path.abspath(__file__))
+parent_dir = os.path.abspath(os.path.join(script_dir, os.pardir))
+
+# Paths
+locals_dir = os.path.dirname(os.path.abspath(sys.argv[0]))  # Current script directory
+translation_file = os.path.join(locals_dir, "localisations", "en.ini")
+config_folder = os.path.join(parent_dir, "node-configs")
+
+# Load translations
+field_mapping, help_text = parse_ini_file(translation_file)
+
+
+def display_menu(current_menu, menu_path, selected_index, show_save_option, help_text):
+    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
+
+    # 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)  
+    start_y = (curses.LINES - menu_height) // 2 - (min_help_window_height // 2)
+    start_x = (curses.COLS - width) // 2
+
+    # Calculate remaining space for help window
+    global max_help_lines
+    remaining_space = curses.LINES - (start_y + menu_height + 2)  # +2 for padding
+    max_help_lines = max(remaining_space, 1)  # Ensure at least 1 lines for help
+
+    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)
+
+    menu_pad = curses.newpad(len(current_menu) + 1, width - 8)
+    menu_pad.bkgd(get_color("background"))
+
+    header = " > ".join(word.title() for word in menu_path)
+    if len(header) > width - 4:
+        header = header[:width - 7] + "..."
+    menu_win.addstr(1, 2, header, get_color("settings_breadcrumbs", bold=True))
+
+    transformed_path = transform_menu_path(menu_path)
+
+    for idx, option in enumerate(current_menu):
+        field_info = current_menu[option]
+        current_value = field_info[1] if isinstance(field_info, tuple) else ""
+        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]
+
+        try:
+            color = get_color("settings_sensitive" if option in sensitive_settings else "settings_default", reverse=(idx == 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:
+        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))))
+
+    # 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)
+
+    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
+    )
+
+    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):
+    global help_win
+
+    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
+    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
+
+
+
+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 < 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 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] - 8)
+
+    # 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])
+
+
+def settings_menu(stdscr, interface):
+    curses.update_lines_cols()
+
+    menu = generate_menu_from_protobuf(interface)
+    current_menu = menu["Main Menu"]
+    menu_path = ["Main Menu"]
+    menu_index = []
+    selected_index = 0
+    modified_settings = {}
+    
+    need_redraw = True
+    show_save_option = False
+
+    while True:
+        if(need_redraw):
+            options = list(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
+            )
+
+            # Display the menu
+            menu_win, menu_pad = display_menu(current_menu, menu_path, selected_index, show_save_option, help_text)
+
+            need_redraw = False
+
+        # Capture user input
+        key = menu_win.getch()
+
+        max_index = len(options) + (1 if 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)
+            
+        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)
+
+        elif key == curses.KEY_RESIZE:
+            need_redraw = True
+            curses.update_lines_cols()
+
+            menu_win.erase()
+            help_win.erase()
+
+            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 == curses.KEY_RIGHT or key == ord('\n'):
+            need_redraw = True
+            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))
+
+            menu_win.refresh()
+            help_win.refresh()
+
+            # Get the parent directory of the script
+            app_directory = os.path.abspath(os.path.join(os.path.dirname(__file__), os.pardir))
+            config_folder = "node-configs"
+
+            if show_save_option and selected_index == len(options):
+                save_changes(interface, menu_path, modified_settings)
+                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
+
+                continue
+
+            selected_option = options[selected_index]
+
+            if selected_option == "Exit":
+                break
+
+            elif selected_option == "Export Config File":
+                filename = get_text_input("Enter a filename for the config file")
+                if not filename:
+                    logging.info("Export aborted: No filename provided.")
+                    start_index.pop()
+                    continue  # Go back to the menu
+                if not filename.lower().endswith(".yaml"):
+                    filename += ".yaml"
+
+                try:
+                    config_text = config_export(interface)
+                    yaml_file_path = os.path.join(app_directory, config_folder, filename)
+
+                    if os.path.exists(yaml_file_path):
+                        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()
+                            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()
+                    continue
+                except PermissionError:
+                    logging.error(f"Permission denied: Unable to write to {yaml_file_path}")
+                except OSError as e:
+                    logging.error(f"OS error while saving config: {e}")
+                except Exception as e:
+                    logging.error(f"Unexpected error: {e}")
+                start_index.pop()
+                continue
+                
+            elif selected_option == "Load Config File":
+                folder_path = os.path.join(app_directory, config_folder)
+
+                # Check if folder exists and is not empty
+                if not os.path.exists(folder_path) or not any(os.listdir(folder_path)):
+                    dialog(stdscr, "", " No config files found. Export a config first.")
+                    continue  # Return to menu
+
+                file_list = [f for f in os.listdir(folder_path) if os.path.isfile(os.path.join(folder_path, f))]
+
+                # Ensure file_list is not empty before proceeding
+                if not file_list:
+                    dialog(stdscr, "", " No config files found. Export a config first.")
+                    continue
+
+                filename = get_list_input("Choose a config file", None, file_list)
+                if filename:
+                    file_path = os.path.join(app_directory, config_folder, filename)
+                    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()
+                continue
+
+            elif selected_option == "Config URL":
+                current_value = interface.localNode.getURL()
+                new_value = get_text_input(f"Config URL is currently: {current_value}")
+                if new_value is not None:
+                    current_value = new_value
+                    overwrite = get_list_input(f"Are you sure you want to load this config?", None, ["Yes", "No"])
+                    if overwrite == "Yes":
+                        interface.localNode.setURL(new_value)
+                        logging.info(f"New Config URL sent to node")
+                start_index.pop()
+                continue
+
+            elif selected_option == "Reboot":
+                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()
+                continue
+
+            elif selected_option == "Reset Node DB":
+                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()
+                continue
+
+            elif selected_option == "Shutdown":
+                confirmation = get_list_input("Are you sure you want to Shutdown?", None, ["Yes", "No"])
+                if confirmation == "Yes":
+                    interface.localNode.shutdown()
+                    logging.info(f"Node Shutdown Requested by menu")
+                start_index.pop()
+                continue
+
+            elif selected_option == "Factory Reset":
+                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()
+                continue
+
+            elif selected_option == "App Settings":
+                menu_win.clear()
+                menu_win.refresh()
+                json_editor(stdscr)  # Open the App Settings menu
+                continue
+                # need_redraw = True
+                
+            field_info = 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])
+
+                # 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']:
+                        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)
+
+                    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)
+
+                    for option, (field, value) in current_menu.items():
+                        modified_settings[option] = value
+
+                    start_index.pop()
+
+                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)
+
+                    for option in ['latitude', 'longitude', 'altitude']:
+                        if option in current_menu:
+                            modified_settings[option] = current_menu[option][1]
+
+                    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()
+
+                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()
+
+                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()
+
+                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()
+
+                elif field.type == 7: # Field type 7 corresponds to FIXED32
+                    new_value = get_fixed32_input(current_value)
+                    start_index.pop()
+
+                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()
+
+                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()
+
+                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"
+                    modified_settings = modified_settings.setdefault(key, {})
+
+                # Add the new value to the appropriate level
+                modified_settings[selected_option] = new_value
+
+                # Convert enum string to int
+                if field and field.enum_type:
+                    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)
+            else:
+                current_menu = current_menu[selected_option]
+                menu_path.append(selected_option)
+                menu_index.append(selected_index)
+                selected_index = 0
+
+
+        elif key == curses.KEY_LEFT:
+            need_redraw = True
+
+            menu_win.erase()
+            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))
+
+            menu_win.refresh()
+            help_win.refresh()
+
+            if len(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()
+                
+        elif key == 27:  # Escape key
+            menu_win.erase()
+            menu_win.refresh()
+            break
+
+def set_region(interface):
+    node = interface.getNode('^local')
+    device_config = node.localConfig
+    lora_descriptor = device_config.lora.DESCRIPTOR
+
+    # Get the enum mapping of region names to their numerical values
+    region_enum = lora_descriptor.fields_by_name["region"].enum_type
+    region_name_to_number = {v.name: v.number for v in region_enum.values}
+
+    regions = list(region_name_to_number.keys())
+
+    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")

ui/curses_ui.py

@@ -2,20 +2,16 @@ import curses
 import textwrap
 import logging
 import traceback
-from typing import Union, List
+from utilities.utils import get_channels, get_readable_duration, get_time_ago, refresh_node_list
+from settings import settings_menu
+from message_handlers.tx_handler import send_message, send_traceroute
+from ui.colors import setup_colors, get_color
+from utilities.db_handler import get_name_from_database, update_node_info_in_db, is_chat_archived
+import ui.default_config as config
+import ui.dialog
+import globals
 
-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 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: curses.window, firstrun: bool) -> None:
+def handle_resize(stdscr, firstrun):
     global messages_pad, messages_win, nodes_pad, nodes_win, channel_pad, channel_win, function_win, packetlog_win, entry_win
 
     # Calculate window max dimensions
@@ -35,9 +31,9 @@ def handle_resize(stdscr: curses.window, firstrun: bool) -> None:
         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]:
@@ -51,6 +47,7 @@ def handle_resize(stdscr: curses.window, firstrun: bool) -> None:
         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()
@@ -71,6 +68,7 @@ def handle_resize(stdscr: curses.window, firstrun: bool) -> None:
         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()
@@ -90,7 +88,7 @@ def handle_resize(stdscr: curses.window, firstrun: bool) -> None:
         pass
 
 
-def main_ui(stdscr: curses.window) -> None:
+def main_ui(stdscr):
     global input_text
     input_text = ""
     stdscr.keypad(True)
@@ -142,32 +140,22 @@ def main_ui(stdscr: curses.window) -> None:
 
         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
@@ -181,15 +169,11 @@ def main_ui(stdscr: curses.window) -> None:
                 channel_win.refresh()
                 highlight_line(False, 0, globals.selected_channel)
                 refresh_pad(0)
-                setup_arrows(channel_win, channel_pad)
-                channel_win.refresh()
             if old_window == 1:
                 messages_win.attrset(get_color("window_frame"))
                 messages_win.box()
                 messages_win.refresh()
                 refresh_pad(1)
-                setup_arrows(messages_win, messages_pad)
-                messages_win.refresh()
             elif old_window == 2:
                 draw_function_win()
                 nodes_win.attrset(get_color("window_frame"))
@@ -197,8 +181,6 @@ def main_ui(stdscr: curses.window) -> None:
                 nodes_win.refresh()
                 highlight_line(False, 2, globals.selected_node)
                 refresh_pad(2)
-                setup_arrows(nodes_win, nodes_pad)
-                nodes_win.refresh()
 
             if globals.current_window == 0:
                 channel_win.attrset(get_color("window_frame_selected"))
@@ -207,18 +189,12 @@ def main_ui(stdscr: curses.window) -> None:
                 channel_win.refresh()
                 highlight_line(True, 0, globals.selected_channel)
                 refresh_pad(0)
-                setup_arrows(channel_win, channel_pad)
-                channel_win.refresh()
-
             elif globals.current_window == 1:
                 messages_win.attrset(get_color("window_frame_selected"))
                 messages_win.box()
                 messages_win.attrset(get_color("window_frame"))
                 messages_win.refresh()
                 refresh_pad(1)
-                setup_arrows(messages_win, messages_pad)
-                messages_win.refresh()
-
             elif globals.current_window == 2:
                 draw_function_win()
                 nodes_win.attrset(get_color("window_frame_selected"))
@@ -227,8 +203,6 @@ def main_ui(stdscr: curses.window) -> None:
                 nodes_win.refresh()
                 highlight_line(True, 2, globals.selected_node)
                 refresh_pad(2)
-                setup_arrows(nodes_win, nodes_pad)
-                nodes_win.refresh()
 
         # Check for Esc
         elif char == chr(27):
@@ -238,11 +212,7 @@ def main_ui(stdscr: curses.window) -> None:
         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.",
-            )
+            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)
 
@@ -251,12 +221,13 @@ def main_ui(stdscr: curses.window) -> None:
                 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
@@ -280,17 +251,17 @@ def main_ui(stdscr: curses.window) -> None:
                 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:
@@ -307,8 +278,8 @@ def main_ui(stdscr: curses.window) -> None:
 
         # ^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
@@ -322,108 +293,20 @@ def main_ui(stdscr: curses.window) -> None:
                     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() -> None:
+
+def draw_channel_list():
     channel_pad.erase()
     win_height, win_width = channel_win.getmaxyx()
     start_index = max(0, globals.selected_channel - (win_height - 3))  # Leave room for borders
@@ -436,7 +319,7 @@ def draw_channel_list() -> None:
         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
@@ -445,9 +328,7 @@ def draw_channel_list() -> None:
         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:
@@ -459,17 +340,14 @@ def draw_channel_list() -> None:
         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: bool = False) -> None:
+def draw_messages_window(scroll_to_bottom = False):
     """Update the messages window based on the selected channel and scroll position."""
     messages_pad.erase()
 
@@ -481,7 +359,7 @@ def draw_messages_window(scroll_to_bottom: bool = False) -> None:
         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)
@@ -491,21 +369,19 @@ def draw_messages_window(scroll_to_bottom: bool = False) -> None:
                 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)
@@ -514,37 +390,28 @@ def draw_messages_window(scroll_to_bottom: bool = False) -> None:
 
     draw_packetlog_win()
 
-
-def draw_node_list() -> None:
+def draw_node_list():
     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
-        ]
-        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)
-        )
+        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))
 
     nodes_win.attrset(get_color("window_frame_selected") if globals.current_window == 2 else get_color("window_frame"))
     nodes_win.box()
@@ -554,12 +421,11 @@ def draw_node_list() -> None:
     refresh_pad(2)
 
     # Restore cursor to input field
-    entry_win.keypad(True)
-    curses.curs_set(1)
+    entry_win.move(1, len("Input: ") + len(input_text)+1)
     entry_win.refresh()
+    curses.curs_set(1)
 
-
-def select_channel(idx: int) -> None:
+def select_channel(idx):
     old_selected_channel = globals.selected_channel
     globals.selected_channel = max(0, min(idx, len(globals.channel_list) - 1))
     draw_messages_window(True)
@@ -573,8 +439,7 @@ def select_channel(idx: int) -> None:
     highlight_line(True, 0, globals.selected_channel)
     refresh_pad(0)
 
-
-def scroll_channels(direction: int) -> None:
+def scroll_channels(direction):
     new_selected_channel = globals.selected_channel + direction
 
     if new_selected_channel < 0:
@@ -584,8 +449,7 @@ def scroll_channels(direction: int) -> None:
 
     select_channel(new_selected_channel)
 
-
-def scroll_messages(direction: int) -> None:
+def scroll_messages(direction):
     globals.selected_message += direction
 
     msg_line_count = messages_pad.getmaxyx()[0]
@@ -593,8 +457,7 @@ def scroll_messages(direction: int) -> None:
 
     refresh_pad(1)
 
-
-def select_node(idx: int) -> None:
+def select_node(idx):
     old_selected_node = globals.selected_node
     globals.selected_node = max(0, min(idx, len(globals.node_list) - 1))
 
@@ -604,8 +467,7 @@ def select_node(idx: int) -> None:
 
     draw_function_win()
 
-
-def scroll_nodes(direction: int) -> None:
+def scroll_nodes(direction):
     new_selected_node = globals.selected_node + direction
 
     if new_selected_node < 0:
@@ -615,61 +477,56 @@ def scroll_nodes(direction: int) -> None:
 
     select_node(new_selected_node)
 
+def draw_packetlog_win():
 
-def draw_packetlog_win() -> None:
-
-    columns = [10, 10, 15, 30]
+    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()
 
     # Restore cursor to input field
-    entry_win.keypad(True)
-    curses.curs_set(1)
+    entry_win.move(1, len("Input: ") + len(input_text)+1)
     entry_win.refresh()
+    curses.curs_set(1)
 
-
-def search(win: int) -> None:
+def search(win):
     start_idx = globals.selected_node
     select_func = select_node
 
@@ -693,7 +550,7 @@ def search(win: int) -> None:
                 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()
@@ -704,20 +561,15 @@ def search(win: int) -> None:
 
         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() -> None:
+def draw_node_details():
     node = None
     try:
         node = globals.interface.nodesByNum[globals.node_list[globals.selected_node]]
@@ -730,48 +582,34 @@ def draw_node_details() -> None:
     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:
@@ -779,44 +617,31 @@ def draw_node_details() -> None:
 
     draw_centered_text_field(function_win, nodestr, 0, get_color("commands"))
 
-
-def draw_help() -> None:
-    cmds = [
-        "↑→↓← = Select",
-        "    ENTER = Send",
-        "    ` = Settings",
-        "    ^P = Packet Log",
-        "    ESC = Quit",
-        "    ^t = Traceroute",
-        "    ^d = Archive Chat",
-        "    ^f = Favorite",
-        "    ^g = Ignore",
-    ]
+def draw_help():
+    cmds = ["↑→↓← = Select", "    ENTER = Send", "    ` = Settings", "    ^P = Packet Log", "    ESC = Quit", "    ^t = Traceroute", "    ^d = Archive Chat"]
     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() -> None:
-    if globals.current_window == 2:
+def draw_function_win():
+    if(globals.current_window == 2):
         draw_node_details()
     else:
         draw_help()
 
-
-def get_msg_window_lines() -> None:
+def get_msg_window_lines():
     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: int) -> None:
-
+def refresh_pad(window):
+    # global messages_pad, nodes_pad, channel_pad 
+    
     win_height = channel_win.getmaxyx()[0]
 
-    if window == 1:
+    if(window == 1):
         pad = messages_pad
         box = messages_win
         lines = get_msg_window_lines()
@@ -827,7 +652,7 @@ def refresh_pad(window: int) -> None:
             packetlog_win.box()
             packetlog_win.refresh()
 
-    elif window == 2:
+    elif(window == 2):
         pad = nodes_pad
         box = nodes_win
         lines = box.getmaxyx()[0] - 2
@@ -841,93 +666,41 @@ def refresh_pad(window: int) -> None:
         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: bool, window: int, line: int) -> None:
+def highlight_line(highlight, window, line):
     pad = nodes_pad
-
     color = get_color("node_list")
     select_len = nodes_win.getmaxyx()[1] - 2
 
-    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:
+    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 setup_arrows(win: curses.window, pad: curses.window) -> None:
-
-    margin = 8
-    height, width = win.getmaxyx()
-    start_index = [0]
-    pad_height = pad.getmaxyx()[0]
-    draw_chat_arrows(win=win, visible_height=height - 3, max_index=pad_height, start_index=start_index)
-
-
-def draw_chat_arrows(win: object, visible_height: int, max_index: int, start_index: List[int]) -> None:
-
-    mi = max_index
-
-    height, width = win.getmaxyx()
-
-    win.addstr(1, width - 2, "▲", get_color("settings_default"))
-    win.addstr(visible_height + 1, width - 2, "▼", get_color("settings_default"))
-
-    # if visible_height < mi:
-    #     if start_index[-1] > 0:
-    #         win.addstr(1, width - 2, "▲", get_color("settings_default"))
-    #     else:
-    #         win.addstr(1, 1, " ", get_color("settings_default"))
-
-    #     if mi - start_index[-1] >= visible_height + 1:
-    #         win.addstr(visible_height + 1, 1, "▼", get_color("settings_default"))
-    #     else:
-    #         win.addstr(visible_height + 1, 1, " ", get_color("settings_default"))
-
-
-def add_notification(channel_number: int) -> None:
+def add_notification(channel_number):
     if channel_number not in globals.notifications:
         globals.notifications.append(channel_number)
 
-
-def remove_notification(channel_number: int) -> None:
+def remove_notification(channel_number):
     if channel_number in globals.notifications:
         globals.notifications.remove(channel_number)
 
-
-def draw_text_field(win: curses.window, text: str, color: int) -> None:
+def draw_text_field(win, text, color):
     win.border()
     win.addstr(1, 1, text, color)
 
-
-def draw_centered_text_field(win: curses.window, text: str, y_offset: int, color: int) -> None:
+def draw_centered_text_field(win, text, y_offset, color):
     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: Union[str, int]) -> None:
+def draw_debug(value):
     function_win.addstr(1, 1, f"debug: {value}    ")
-    function_win.refresh()
+    function_win.refresh()

ui/default_config.py

@@ -1,7 +1,6 @@
-import json
 import logging
+import json
 import os
-from typing import Dict
 
 # Get the parent directory of the script
 script_dir = os.path.dirname(os.path.abspath(__file__))
@@ -12,17 +11,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: Dict[str, object], indent: int = 4) -> str:
+def format_json_single_line_arrays(data, indent=4):
     """
     Formats JSON with arrays on a single line while keeping other elements properly indented.
     """
-
-    def format_value(value: object, current_indent: int) -> str:
+    def format_value(value, current_indent):
         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)}]"
@@ -31,9 +30,8 @@ def format_json_single_line_arrays(data: Dict[str, object], indent: int = 4) ->
 
     return format_value(data, indent)
 
-
 # Recursive function to check and update nested dictionaries
-def update_dict(default: Dict[str, object], actual: Dict[str, object]) -> bool:
+def update_dict(default, actual):
     updated = False
     for key, value in default.items():
         if key not in actual:
@@ -44,8 +42,7 @@ def update_dict(default: Dict[str, object], actual: Dict[str, object]) -> bool:
             updated = update_dict(value, actual[key]) or updated
     return updated
 
-
-def initialize_config() -> Dict[str, object]:
+def initialize_config():
     COLOR_CONFIG_DARK = {
         "default": ["white", "black"],
         "background": [" ", "black"],
@@ -68,9 +65,7 @@ def initialize_config() -> Dict[str, object]:
         "settings_save": ["green", "black"],
         "settings_breadcrumbs": ["white", "black"],
         "settings_warning": ["red", "black"],
-        "settings_note": ["green", "black"],
-        "node_favorite": ["green", "black"],
-        "node_ignored": ["red", "black"],
+        "settings_note": ["green", "black"]
     }
     COLOR_CONFIG_LIGHT = {
         "default": ["black", "white"],
@@ -94,9 +89,7 @@ def initialize_config() -> Dict[str, object]:
         "settings_save": ["green", "white"],
         "settings_breadcrumbs": ["black", "white"],
         "settings_warning": ["red", "white"],
-        "settings_note": ["green", "white"],
-        "node_favorite": ["green", "white"],
-        "node_ignored": ["red", "white"],
+        "settings_note": ["green", "white"]
     }
     COLOR_CONFIG_GREEN = {
         "default": ["green", "black"],
@@ -122,9 +115,7 @@ def initialize_config() -> Dict[str, object]:
         "settings_save": ["green", "black"],
         "settings_breadcrumbs": ["green", "black"],
         "settings_warning": ["green", "black"],
-        "settings_note": ["green", "black"],
-        "node_favorite": ["cyan", "white"],
-        "node_ignored": ["red", "white"],
+        "settings_note": ["green", "black"]
     }
     default_config_variables = {
         "db_file_path": db_file_path,
@@ -140,7 +131,7 @@ def initialize_config() -> Dict[str, object]:
         "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):
@@ -157,17 +148,16 @@ def initialize_config() -> Dict[str, object]:
 
     # 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: Dict[str, object]) -> None:
+def assign_config_variables(loaded_config):
     # 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
@@ -198,9 +188,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}")
@@ -212,4 +202,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}")

ui/dialog.py

@@ -1,8 +1,7 @@
 import curses
-from contact.ui.colors import get_color
+from ui.colors import get_color
 
-
-def dialog(stdscr: curses.window, title: str, message: str) -> None:
+def dialog(stdscr, title, message):
     height, width = stdscr.getmaxyx()
 
     # Calculate dialog dimensions
@@ -38,7 +37,7 @@ def dialog(stdscr: curses.window, title: str, message: str) -> None:
     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

ui/menus.py

@@ -1,44 +1,29 @@
-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
-
+from meshtastic.protobuf import config_pb2, module_config_pb2, channel_pb2
+import logging
+import base64
+import os
 
 locals_dir = os.path.dirname(os.path.abspath(__file__))
 translation_file = os.path.join(locals_dir, "localisations", "en.ini")
 
-
-def encode_if_bytes(value: Any) -> str:
+def encode_if_bytes(value):
     """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: Message, current_config: Union[Message, Dict[str, Any], None] = None
-) -> Dict[str, Any]:
+def extract_fields(message_instance, current_config=None):
     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
 
@@ -62,11 +47,7 @@ def extract_fields(
             menu[field.name] = (field, encode_if_bytes(current_value))
     return menu
 
-
-def generate_menu_from_protobuf(interface: object) -> Dict[str, Any]:
-    """
-    Builds the full settings menu structure from the protobuf definitions.
-    """
+def generate_menu_from_protobuf(interface):
     menu_structure = {"Main Menu": {}}
 
     # Add User Settings
@@ -78,7 +59,7 @@ def generate_menu_from_protobuf(interface: object) -> Dict[str, Any]:
             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")
@@ -106,7 +87,7 @@ def generate_menu_from_protobuf(interface: object) -> Dict[str, Any]:
     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", {})
@@ -125,22 +106,20 @@ def generate_menu_from_protobuf(interface: object) -> Dict[str, Any]:
     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

ui/splash.py

@@ -1,9 +1,7 @@
 import curses
-from contact.ui.colors import get_color
+from ui.colors import get_color
 
-
-def draw_splash(stdscr: object) -> None:
-    """Draw the splash screen with a logo and connecting message."""
+def draw_splash(stdscr):
     curses.curs_set(0)
 
     stdscr.clear()
@@ -19,11 +17,11 @@ def draw_splash(stdscr: object) -> None:
     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)

ui/user_config.py

@@ -0,0 +1,321 @@
+import os
+import json
+import curses
+from ui.colors import get_color, setup_colors, COLOR_MAP
+from ui.default_config import format_json_single_line_arrays, loaded_config
+from utilities.input_handlers import get_list_input
+
+width = 60
+save_option_text = "Save Changes"
+
+def edit_color_pair(key, current_value):
+
+    """
+    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)
+    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):
+    width = 60
+    height = 10
+    input_width = width - 16  # Allow space for "New Value: "
+    start_y = (curses.LINES - height) // 2
+    start_x = (curses.COLS - width) // 2
+
+    # Create a centered window
+    edit_win = curses.newwin(height, width, start_y, start_x)
+    edit_win.bkgd(get_color("background"))
+    edit_win.attrset(get_color("window_frame"))
+    edit_win.border()
+
+    # Display instructions
+    edit_win.addstr(1, 2, f"Editing {key}", get_color("settings_default", bold=True))
+    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)]
+
+    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()
+
+    # 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")]
+        return get_list_input("Select Theme", current_value, theme_options)
+    elif key == "node_sort":
+        sort_options = ['lastHeard', 'name', 'hops']
+        return get_list_input("Sort By", current_value, sort_options)
+
+    # Standard Input Mode (Scrollable)
+    edit_win.addstr(7, 2, "New Value: ", get_color("settings_default"))
+    curses.curs_set(1)
+
+    scroll_offset = 0  # Determines which part of the text is visible
+    user_input = ""
+    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
+        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
+        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
+        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]
+                if scroll_offset > 0 and len(user_input) < scroll_offset + input_width:
+                    scroll_offset -= 1  # Move back if text is shorter than scrolled area
+        else:
+            if isinstance(key, str):
+                user_input += key
+            else:
+                user_input += chr(key)
+
+            if len(user_input) > input_width:  # Scroll if input exceeds visible area
+                scroll_offset += 1
+
+    curses.curs_set(0)
+    return user_input if user_input else current_value
+
+
+def render_menu(current_data, menu_path, selected_index):
+    """
+    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))]
+    else:
+        options = []  # Fallback in case of unexpected data types
+
+    # Calculate dynamic dimensions for the menu
+    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_x = (curses.COLS - width) // 2
+
+    # Create the window
+    menu_win = curses.newwin(height, width, start_y, start_x)
+    menu_win.clear()
+    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"))
+
+    # 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]
+        )
+
+        color = get_color("settings_default", reverse=(idx == 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))),
+    )
+
+    # Refresh menu and pad
+    menu_win.refresh()
+    menu_pad.refresh(
+        0,
+        0,
+        menu_win.getbegyx()[0] + 3,
+        menu_win.getbegyx()[1] + 4,
+        
+        menu_win.getbegyx()[0] + menu_win.getmaxyx()[0] - 3,
+        menu_win.getbegyx()[1] + menu_win.getmaxyx()[1] - 4,
+    )
+
+    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
+
+    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
+
+    file_path = "config.json"
+    show_save_option = True  # Always show the Save button
+
+    # Ensure the file exists
+    if not os.path.exists(file_path):
+        with open(file_path, "w") as f:
+            json.dump({}, f)
+
+    # Load JSON data
+    with open(file_path, "r") 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
+
+    # Render the menu
+    menu_win, menu_pad, options = render_menu(current_data, menu_path, selected_index)
+    need_redraw = True
+
+    while True:
+        if(need_redraw):
+            menu_win, menu_pad, options = render_menu(current_data, menu_path, selected_index)
+            menu_win.refresh()
+            need_redraw = False
+            
+        max_index = len(options) + (1 if 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)
+
+        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)
+
+        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 in (curses.KEY_RIGHT, ord("\n")):
+
+            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]
+
+                # Handle nested data
+                if isinstance(current_data, dict):
+                    if selected_key in current_data:
+                        selected_data = current_data[selected_key]
+                    else:
+                        continue  # Skip invalid key
+                elif isinstance(current_data, list):
+                    selected_data = current_data[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
+
+                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
+
+                else:
+                    # General value editing
+                    new_value = edit_value(selected_key, selected_data)
+                    current_data[selected_key] = new_value
+                    need_redraw = True
+
+            else:
+                # Save button selected
+                save_json(file_path, data)
+                stdscr.refresh()
+                continue
+
+        elif key in (27, curses.KEY_LEFT):  # Escape or Left Arrow
+
+            need_redraw = True
+            menu_win.erase()
+            menu_win.refresh()
+
+            # 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
+            else:
+                # Exit the editor
+                menu_win.clear()
+                menu_win.refresh()
+                break
+
+
+def save_json(file_path, data):
+    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):
+    curses.curs_set(0)
+    stdscr.keypad(True)
+    setup_colors()
+    json_editor(stdscr)
+
+if __name__ == "__main__":
+    curses.wrapper(main)

utilities/arg_parser.py

@@ -0,0 +1,37 @@
+import argparse
+
+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.')
+    conn = connOuter.add_mutually_exclusive_group()
+    conn.add_argument(
+        "--port",
+        "--serial",
+        "-s",
+        help="The port to connect to via serial, e.g. `/dev/ttyUSB0`.",
+        nargs="?",
+        default=None,
+        const=None,
+    )
+    conn.add_argument(
+        "--host",
+        "--tcp",
+        "-t",
+        help="The hostname or IP address to connect to using TCP.",
+        nargs="?",
+        default=None,
+        const="localhost",
+    )
+    conn.add_argument(
+        "--ble",
+        "-b",
+        help="The BLE device MAC address or name to connect to.",
+        nargs="?",
+        default=None,
+        const="any"
+    )
+
+    return parser

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 mt_config
+from meshtastic import BROADCAST_ADDR, 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,7 +20,6 @@ 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(".")
@@ -29,7 +28,6 @@ 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"""
 
@@ -77,7 +75,9 @@ 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,35 +122,44 @@ 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
@@ -171,25 +180,32 @@ 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 = {}
@@ -222,7 +238,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 = {}
@@ -233,15 +249,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
 
@@ -257,9 +273,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

utilities/control_utils.py

@@ -1,34 +1,31 @@
-from typing import Optional, Tuple, Dict, List
 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 = {}
+    help_text = {}
+    current_section = None
 
-    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:
+    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
@@ -49,18 +46,20 @@ def parse_ini_file(ini_file_path: str) -> Tuple[Dict[str, str], Dict[str, str]]:
 
     return field_mapping, help_text
 
-
-def transform_menu_path(menu_path: List[str]) -> List[str]:
+def transform_menu_path(menu_path):
     """Applies path replacements and normalizes entries in the menu path."""
-    path_replacements = {"Radio Settings": "config", "Module Settings": "module"}
+    path_replacements = {
+        "Radio Settings": "config",
+        "Module Settings": "module"
+    }
 
-    transformed_path: List[str] = []
+    transformed_path = []
     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)

utilities/db_handler.py

@@ -1,43 +1,66 @@
 import sqlite3
 import time
 import logging
+import re
 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
+from utilities.utils import decimal_to_hex
+import ui.default_config as config
+import globals
 
 
-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 get_db_connection():
+    """Get a SQLite connection with optimized PRAGMA settings."""
+    db_connection = sqlite3.connect(config.db_file_path, check_same_thread=False)
+    db_cursor = db_connection.cursor()
+
+    # Check if journal_mode is already set to WAL
+    db_cursor.execute("PRAGMA journal_mode;")
+    current_journal_mode = db_cursor.fetchone()[0]
+
+    if current_journal_mode != "wal":
+        db_cursor.execute("PRAGMA journal_mode=WAL;")
+
+    # Apply remaining PRAGMA settings (these are fine to execute every time)
+    db_cursor.executescript("""
+        PRAGMA synchronous=NORMAL;
+        PRAGMA cache_size=-64000;
+        PRAGMA temp_store=MEMORY;
+        PRAGMA foreign_keys=ON;
+    """)
+
+    return db_connection
 
 
-def save_message_to_db(channel: str, user_id: str, message_text: str) -> Optional[int]:
+def get_table_name(channel):
+    """Returns a properly formatted and safe table name."""
+    safe_channel = re.sub(r'[^a-zA-Z0-9_]', '', str(channel))
+    table_name = f"{globals.myNodeNum}_{safe_channel}_messages"
+    return f'"{table_name}"'
+
+
+def save_message_to_db(channel, user_id, message_text):
     """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:
+        with get_db_connection() as db_connection:
             db_cursor = db_connection.cursor()
             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()
 
@@ -49,9 +72,9 @@ def save_message_to_db(channel: str, user_id: str, message_text: str) -> Optiona
         logging.error(f"Unexpected error in save_message_to_db: {e}")
 
 
-def update_ack_nak(channel: str, timestamp: int, message: str, ack: str) -> None:
+def update_ack_nak(channel, timestamp, message, ack):
     try:
-        with sqlite3.connect(config.db_file_path) as db_connection:
+        with get_db_connection() as db_connection:
             db_cursor = db_connection.cursor()
             update_query = f"""
                 UPDATE {get_table_name(channel)}
@@ -71,10 +94,10 @@ def update_ack_nak(channel: str, timestamp: int, message: str, ack: str) -> None
         logging.error(f"Unexpected error in update_ack_nak: {e}")
 
 
-def load_messages_from_db() -> None:
+def load_messages_from_db():
     """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:
+        with get_db_connection() as db_connection:
             db_cursor = db_connection.cursor()
 
             query = "SELECT name FROM sqlite_master WHERE type='table' AND name LIKE ?"
@@ -83,27 +106,25 @@ def load_messages_from_db() -> None:
 
             # 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)
@@ -115,10 +136,10 @@ def load_messages_from_db() -> None:
                     # 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
@@ -130,11 +151,8 @@ def load_messages_from_db() -> None:
                         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]
@@ -149,9 +167,9 @@ def load_messages_from_db() -> None:
         logging.error(f"SQLite error in load_messages_from_db: {e}")
 
 
-def init_nodedb() -> None:
+def init_nodedb():
     """Initialize the node database and update it with nodes from the interface."""
-
+    
     try:
         if not globals.interface.nodes:
             return  # No nodes to initialize
@@ -162,13 +180,13 @@ def init_nodedb() -> None:
         # 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.")
@@ -179,16 +197,16 @@ def init_nodedb() -> None:
         logging.error(f"Unexpected error in init_nodedb: {e}")
 
 
-def maybe_store_nodeinfo_in_db(packet: Dict[str, object]) -> None:
+def maybe_store_nodeinfo_in_db(packet):
     """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)
 
@@ -198,43 +216,27 @@ def maybe_store_nodeinfo_in_db(packet: Dict[str, object]) -> None:
         logging.error(f"Unexpected error in maybe_store_nodeinfo_in_db: {e}")
 
 
-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:
+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):
     """Update or insert node information into the database, preserving unchanged fields."""
     try:
         ensure_node_table_exists()  # Ensure the table exists before any operation
 
-        with sqlite3.connect(config.db_file_path) as db_connection:
+        with get_db_connection() 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
@@ -244,30 +246,20 @@ def update_node_info_in_db(
                 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"""
-                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
-                    long_name = excluded.long_name,
-                    short_name = excluded.short_name,
-                    hw_model = excluded.hw_model,
-                    is_licensed = excluded.is_licensed,
-                    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)
-            )
+            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
+                long_name = excluded.long_name,
+                short_name = excluded.short_name,
+                hw_model = excluded.hw_model,
+                is_licensed = excluded.is_licensed,
+                role = excluded.role,
+                public_key = excluded.public_key,
+                chat_archived = COALESCE(excluded.chat_archived, 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:
@@ -276,10 +268,10 @@ def update_node_info_in_db(
         logging.error(f"Unexpected error in update_node_info_in_db: {e}")
 
 
-def ensure_node_table_exists() -> None:
+def ensure_node_table_exists():
     """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,
@@ -288,14 +280,14 @@ def ensure_node_table_exists() -> None:
         role TEXT,
         public_key TEXT,
         chat_archived INTEGER
-    """
+    '''
     ensure_table_exists(table_name, schema)
 
 
-def ensure_table_exists(table_name: str, schema: str) -> None:
+def ensure_table_exists(table_name, schema):
     """Ensure the given table exists in the database."""
     try:
-        with sqlite3.connect(config.db_file_path) as db_connection:
+        with get_db_connection() as db_connection:
             db_cursor = db_connection.cursor()
             create_table_query = f"CREATE TABLE IF NOT EXISTS {table_name} ({schema})"
             db_cursor.execute(create_table_query)
@@ -306,31 +298,32 @@ def ensure_table_exists(table_name: str, schema: str) -> None:
         logging.error(f"Unexpected error in ensure_table_exists({table_name}): {e}")
 
 
-def get_name_from_database(user_id: int, type: str = "long") -> str:
-    """
-    Retrieve a user's name (long or short) from the node database.
+name_cache = {}
+
+def get_name_from_database(user_id, type="long"):
+    """Retrieve a user's name from the node database with caching."""
+    # Check if we already cached both long and short names
+    if user_id in name_cache and type in name_cache[user_id]:
+        return name_cache[user_id][type]
 
-    :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
-    """
     try:
-        with sqlite3.connect(config.db_file_path) as db_connection:
+        with get_db_connection() as db_connection:
             db_cursor = db_connection.cursor()
-
-            # Construct table name
             table_name = f"{str(globals.myNodeNum)}_nodedb"
-            nodeinfo_table = f'"{table_name}"'  # Quote table name for safety
+            nodeinfo_table = f'"{table_name}"'
 
-            # Determine the correct column to fetch
-            column_name = "long_name" if type == "long" else "short_name"
-
-            # Query the database
-            query = f"SELECT {column_name} FROM {nodeinfo_table} WHERE user_id = ?"
-            db_cursor.execute(query, (user_id,))
+            # Fetch both long and short names in one query
+            db_cursor.execute(f"SELECT long_name, short_name FROM {nodeinfo_table} WHERE user_id = ?", (user_id,))
             result = db_cursor.fetchone()
 
-            return result[0] if result else decimal_to_hex(user_id)
+            if result:
+                long_name, short_name = result or ("Unknown", "Unknown")  # Handle empty result
+                name_cache[user_id] = {"long": long_name, "short": short_name}
+                return name_cache[user_id][type]
+
+            # If no result, store a fallback value in the cache to avoid future DB queries
+            name_cache[user_id] = {"long": decimal_to_hex(user_id), "short": decimal_to_hex(user_id)}
+            return name_cache[user_id][type]
 
     except sqlite3.Error as e:
         logging.error(f"SQLite error in get_name_from_database: {e}")
@@ -339,11 +332,12 @@ def get_name_from_database(user_id: int, type: str = "long") -> str:
     except Exception as e:
         logging.error(f"Unexpected error in get_name_from_database: {e}")
         return "Unknown"
+    
 
-
-def is_chat_archived(user_id: int) -> int:
+def is_chat_archived(user_id):
+    """Check if a chat is archived, returning 0 (False) if not found."""
     try:
-        with sqlite3.connect(config.db_file_path) as db_connection:
+        with get_db_connection() as db_connection:
             db_cursor = db_connection.cursor()
             table_name = f"{str(globals.myNodeNum)}_nodedb"
             nodeinfo_table = f'"{table_name}"'
@@ -355,8 +349,8 @@ def is_chat_archived(user_id: int) -> int:
 
     except sqlite3.Error as e:
         logging.error(f"SQLite error in is_chat_archived: {e}")
-        return "Unknown"
+        return 0
 
     except Exception as e:
         logging.error(f"Unexpected error in is_chat_archived: {e}")
-        return "Unknown"
+        return 0

utilities/input_handlers.py

@@ -2,13 +2,45 @@ import base64
 import binascii
 import curses
 import ipaddress
-from typing import Any, Optional, List
+import re
+from ui.colors import get_color
 
-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)
 
-def get_text_input(prompt: str) -> Optional[str]:
+        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):
     """Handles user input with wrapped text for long prompts."""
     height = 8
     width = 80
@@ -35,7 +67,7 @@ def get_text_input(prompt: str) -> Optional[str]:
 
     prompt_text = "Enter new value: "
     input_win.addstr(row + 1, margin, prompt_text, get_color("settings_default"))
-
+    
     input_win.refresh()
     curses.curs_set(1)
 
@@ -73,13 +105,11 @@ def get_text_input(prompt: str) -> Optional[str]:
         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"))
@@ -98,7 +128,7 @@ def get_text_input(prompt: str) -> Optional[str]:
     return user_input
 
 
-def get_admin_key_input(current_value: List[bytes]) -> Optional[List[str]]:
+def get_admin_key_input(current_value):
     def to_base64(byte_strings):
         """Convert byte values to Base64-encoded strings."""
         return [base64.b64encode(b).decode() for b in byte_strings]
@@ -138,9 +168,7 @@ def get_admin_key_input(current_value: List[bytes]) -> Optional[List[str]]:
         # 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
@@ -160,8 +188,8 @@ def get_admin_key_input(current_value: List[bytes]) -> Optional[List[str]]:
             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)
@@ -183,7 +211,8 @@ def get_admin_key_input(current_value: List[bytes]) -> Optional[List[str]]:
                 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
@@ -210,10 +239,8 @@ def get_repeated_input(current_value: List[str]) -> Optional[str]:
         # 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)
@@ -232,8 +259,8 @@ def get_repeated_input(current_value: List[str]) -> Optional[str]:
             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)
@@ -252,7 +279,7 @@ def get_repeated_input(current_value: List[str]) -> Optional[str]:
                 pass  # Ignore invalid character inputs
 
 
-def get_fixed32_input(current_value: int) -> int:
+def get_fixed32_input(current_value):
     cvalue = current_value
     current_value = str(ipaddress.IPv4Address(current_value))
     height = 10
@@ -285,7 +312,7 @@ def get_fixed32_input(current_value: int) -> int:
             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):
@@ -309,7 +336,7 @@ def get_fixed32_input(current_value: int) -> int:
                 pass  # Ignore invalid inputs
 
 
-def get_list_input(prompt: str, current_option: Optional[str], list_options: List[str]) -> Optional[str]:
+def get_list_input(prompt, current_option, list_options):
     """
     Displays a scrollable list of list_options for the user to choose from.
     """
@@ -342,19 +369,9 @@ def get_list_input(prompt: str, current_option: Optional[str], list_options: Lis
 
     # 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,
-    )
-
-    max_index = len(list_options) - 1
-    visible_height = list_win.getmaxyx()[0] - 5
-
-    draw_arrows(list_win, visible_height, max_index, [0], show_save_option=False)  # Initial call to draw arrows
+    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)
 
     while True:
         key = list_win.getch()
@@ -362,16 +379,50 @@ def get_list_input(prompt: str, current_option: Optional[str], list_options: Lis
         if key == curses.KEY_UP:
             old_selected_index = selected_index
             selected_index = max(0, selected_index - 1)
-            move_highlight(old_selected_index, list_options, list_win, list_pad, selected_index=selected_index)
+            move_highlight(old_selected_index, selected_index, list_options, list_win, list_pad)
         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, list_options, list_win, list_pad, selected_index=selected_index)
-        elif key == ord("\n"):  # Enter key
-            list_win.clear()
-            list_win.refresh()
+            move_highlight(old_selected_index, selected_index, list_options, list_win, list_pad)
+        elif key == ord('\n'):  # Enter key
             return list_options[selected_index]
         elif key == 27 or key == curses.KEY_LEFT:  # ESC or Left Arrow
-            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)
+
+    return scroll_offset  # Return updated scroll_offset to be stored externally

utilities/interfaces.py

@@ -0,0 +1,23 @@
+import logging
+import meshtastic.serial_interface, meshtastic.tcp_interface, meshtastic.ble_interface
+import 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)
+        else:
+            try:
+                return meshtastic.serial_interface.SerialInterface(args.port)
+            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:
+                return meshtastic.tcp_interface.TCPInterface("meshtastic.local")
+    
+    except Exception as ex:
+        logging.critical(f"Fatal error initializing interface: {ex}")
+    

utilities/save_to_radio.py

@@ -4,8 +4,7 @@ import logging
 import base64
 import time
 
-
-def save_changes(interface, modified_settings, menu_state):
+def save_changes(interface, menu_path, modified_settings):
     """
     Save changes to the device based on modified settings.
     :param interface: Meshtastic interface instance
@@ -16,16 +15,16 @@ def save_changes(interface, modified_settings, menu_state):
         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.")
@@ -43,29 +42,29 @@ def save_changes(interface, modified_settings, menu_state):
                     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_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 menu_path[1] ==  "Radio Settings" or menu_path[1] == "Module Settings":
+            config_category = 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_state.menu_path[1] == "User Settings":  # for user configs
+        elif menu_path[1] == "User Settings":  # for user configs
             config_category = "User Settings"
             long_name = modified_settings.get("longName")
             short_name = modified_settings.get("shortName")
@@ -74,26 +73,24 @@ def save_changes(interface, modified_settings, menu_state):
 
             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_state.menu_path[1] == "Channels":  # for channel configs
+        
+        elif menu_path[1] == "Channels":    # for channel configs
             config_category = "Channels"
 
             try:
-                channel = menu_state.menu_path[-1]
+                channel = 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
@@ -138,9 +135,7 @@ def save_changes(interface, modified_settings, menu_state):
                                     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:
@@ -156,9 +151,9 @@ def save_changes(interface, modified_settings, menu_state):
             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}")

utilities/utils.py

@@ -1,12 +1,11 @@
-import contact.globals as globals
+import globals
 import datetime
 from meshtastic.protobuf import config_pb2
-import contact.ui.default_config as config
-
+import 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
@@ -21,9 +20,7 @@ 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
@@ -34,38 +31,27 @@ def get_channels():
             if channel_name not in globals.all_messages:
                 globals.all_messages[channel_name] = []
 
-    return globals.channel_list
 
+    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)
-
-        # 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]
+        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]
         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:
@@ -73,23 +59,19 @@ 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 = ""
@@ -117,13 +99,11 @@ 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)
@@ -133,3 +113,4 @@ def get_time_ago(timestamp):
     if unit != "s":
         return f"{value} {unit} ago"
     return "now"
+