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": []
-        }
-    ]
-}

README.md

@@ -48,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/ui/ui_state.py

@@ -1,27 +0,0 @@
-class MenuState:
-    def __init__(self):
-        self.menu_index = []        # Row we left the previous menus
-        self.start_index = [0]      # Row to start the menu if it doesn't all fit
-        self.selected_index = 0     # Selected Row
-        self.current_menu = {}      # Contents of the current menu
-        self.menu_path = []         # Menu Path
-        self.show_save_option = False
-
-class NodeState:
-    def __init__(self):
-        self.interface = None
-        self.myNodeNum = 0
-
-
-
-        # self.lock = None
-        # self.display_log = False
-        # self.all_messages = {}
-        # self.channel_list = []
-        # self.notifications = []
-        # self.packet_buffer = []
-        # self.node_list = []
-        # self.selected_channel = 0
-        # self.selected_message = 0
-        # self.selected_node = 0
-        # self.current_window = 0

contact/ui/user_config.py

@@ -1,373 +0,0 @@
-import os
-import json
-import curses
-from contact.ui.colors import get_color, setup_colors, COLOR_MAP
-from contact.ui.default_config import format_json_single_line_arrays, loaded_config
-from contact.utilities.input_handlers import get_list_input
-
-width = 80
-save_option = "Save Changes"
-sensitive_settings = []
-
-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, menu_state):
-
-    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):
-    """
-    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)
-
-    return menu_win, menu_pad, options
-
-
-def move_highlight(old_idx, new_idx, options, menu_win, menu_pad, menu_state):
-    if old_idx == new_idx:  # No-op
-        return
-
-    max_index = len(options) + (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)
-
-    # Adjust menu_state.start_index only when moving out of visible range
-    if new_idx == max_index and menu_state.show_save_option:
-        pass
-    elif new_idx < menu_state.start_index[-1]:  # Moving above the visible area
-        menu_state.start_index[-1] = new_idx
-    elif new_idx >= menu_state.start_index[-1] + visible_height:  # Moving below the visible area
-        menu_state.start_index[-1] = new_idx - visible_height
-    pass
-
-    # Ensure menu_state.start_index is within bounds
-    menu_state.start_index[-1] = max(0, min(menu_state.start_index[-1], max_index - visible_height + 1))
-
-    # Clear old selection
-    if menu_state.show_save_option and old_idx == max_index:
-        menu_win.chgat(menu_win.getmaxyx()[0] - 2, (width - len(save_option)) // 2, len(save_option), get_color("settings_save"))
-    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 menu_state.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(menu_state.start_index[-1], 0,
-                     menu_win.getbegyx()[0] + 3, menu_win.getbegyx()[1] + 4,
-                     menu_win.getbegyx()[0] + 3 + visible_height, 
-                     menu_win.getbegyx()[1] + menu_win.getmaxyx()[1] - 4)
-
-    draw_arrows(menu_win, visible_height, max_index, menu_state)
-
-
-def draw_arrows(win, visible_height, max_index, menu_state):
-
-    mi = max_index - (2 if menu_state.show_save_option else 0) 
-
-    if visible_height < mi:
-        if menu_state.start_index[-1] > 0:
-            win.addstr(3, 2, "▲", get_color("settings_default"))
-        else:
-            win.addstr(3, 2, " ", get_color("settings_default"))
-
-        if mi - menu_state.start_index[-1] >= visible_height + (0 if menu_state.show_save_option else 1) :
-            win.addstr(visible_height + 3, 2, "▼", get_color("settings_default"))
-        else:
-            win.addstr(visible_height + 3, 2, " ", get_color("settings_default"))
-
-
-def json_editor(stdscr, menu_state):
-
-    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
-
-    # 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
-    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
-            move_highlight(old_selected_index, menu_state.selected_index, options, menu_win, menu_pad, menu_state)
-
-        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, menu_state.selected_index, options, menu_win, menu_pad, menu_state)
-
-        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, menu_state.selected_index, options, menu_win, menu_pad, menu_state)
-
-        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_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, 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):
-    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)

globals.py

@@ -1,4 +1,4 @@
-# interface = None
+interface = None
 lock = None
 display_log = False
 all_messages = {}
@@ -6,7 +6,7 @@ channel_list = []
 notifications = []
 packet_buffer = []
 node_list = []
-# myNodeNum = 0
+myNodeNum = 0
 selected_channel = 0
 selected_message = 0
 selected_node = 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."
@@ -115,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."
@@ -139,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

@@ -3,8 +3,7 @@
 '''
 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.
+V 1.2.2
 '''
 
 import contextlib
@@ -14,26 +13,21 @@ from pubsub import pub
 import sys
 import io
 import logging
-import subprocess
 import traceback
 import threading
 
-from contact.utilities.db_handler import init_nodedb, load_messages_from_db
-from contact.message_handlers.rx_handler import on_receive
-from contact.settings import set_region
-from contact.ui.contact_ui import main_ui
-from contact.ui.colors import setup_colors
-from contact.ui.splash import draw_splash
-import contact.ui.default_config as config
-from contact.utilities.arg_parser import setup_parser
-from contact.utilities.interfaces import initialize_interface
-from contact.utilities.input_handlers import get_list_input
-from contact.utilities.utils import get_channels, get_node_list, get_nodeNum
-
-import contact.globals as globals
-from contact.ui.ui_state import NodeState
-
-node_state = NodeState()
+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"
@@ -62,32 +56,27 @@ def main(stdscr):
             parser = setup_parser()
             args = parser.parse_args()
 
-            # Check if --settings was passed and run settings.py as a subprocess
-            if getattr(args, 'settings', False):
-                subprocess.run([sys.executable, "-m", "contact.settings"], check=True)
-                return
-
             logging.info("Initializing interface %s", args)
             with globals.lock:
-                node_state.interface = initialize_interface(args)
+                globals.interface = initialize_interface(args)
 
-                if node_state.interface.localNode.localConfig.lora.region == 0:
+                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(node_state)
-                        node_state.interface.close()
-                        node_state.interface = initialize_interface(args)
+                        set_region(globals.interface)
+                        globals.interface.close()
+                        globals.interface = initialize_interface(args)
 
                 logging.info("Interface initialized")
-                get_nodeNum(node_state)
+                globals.myNodeNum = get_nodeNum()
                 globals.channel_list = get_channels()
                 globals.node_list = get_node_list()
                 pub.subscribe(on_receive, 'meshtastic.receive')
-                init_nodedb(node_state)
-                load_messages_from_db(node_state)
+                init_nodedb()
+                load_messages_from_db()
                 logging.info("Starting main UI")
 
-            main_ui(stdscr, node_state)
+            main_ui(stdscr)
 
     except Exception as e:
         console_output = output_capture.getvalue()
@@ -96,7 +85,7 @@ def main(stdscr):
         logging.error("Console output before crash:\n%s", console_output)
         raise  # Re-raise only unexpected errors
 
-def start():
+if __name__ == "__main__":
     log_file = config.log_file_path
     log_f = open(log_file, "a", buffering=1)  # Enable line-buffering for immediate log writes
 
@@ -112,7 +101,4 @@ def start():
         except Exception as e:
             logging.error("Fatal error in curses wrapper: %s", e)
             logging.error("Traceback: %s", traceback.format_exc())
-            sys.exit(1)  # Exit with an error code
-
-if __name__ == "__main__":
-    start()
+            sys.exit(1)  # Exit with an error code

message_handlers/rx_handler.py

@@ -1,16 +1,16 @@
 import logging
 import time
-from contact.utilities.utils import refresh_node_list
+from utilities.utils import refresh_node_list
 from datetime import datetime
-from contact.ui.contact_ui import draw_packetlog_win, draw_node_list, draw_messages_window, draw_channel_list, add_notification
-from 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
 
 
 from datetime import datetime
 
-def on_receive(packet, node_state):
+def on_receive(packet, interface):
 
     with globals.lock:
         # Update packet log
@@ -20,7 +20,7 @@ def on_receive(packet, node_state):
             globals.packet_buffer = globals.packet_buffer[-20:]
             
         if globals.display_log:
-            draw_packetlog_win(node_state)
+            draw_packetlog_win()
         try:
             if 'decoded' not in packet:
                 return
@@ -32,7 +32,7 @@ def on_receive(packet, node_state):
 
             if packet['decoded']['portnum'] == 'NODEINFO_APP':
                 if "user" in packet['decoded'] and "longName" in packet['decoded']["user"]: 
-                    maybe_store_nodeinfo_in_db(packet, node_state)
+                    maybe_store_nodeinfo_in_db(packet)
 
             elif packet['decoded']['portnum'] == 'TEXT_MESSAGE_APP':
                 message_bytes = packet['decoded']['payload']
@@ -66,7 +66,7 @@ def on_receive(packet, node_state):
 
                 # Add received message to the messages list
                 message_from_id = packet['from']
-                message_from_string = get_name_from_database(message_from_id, node_state, type='short') + ":"
+                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]] = []
@@ -95,9 +95,9 @@ def on_receive(packet, node_state):
                 globals.all_messages[globals.channel_list[channel_number]].append((f"{config.message_prefix} {message_from_string} ", message_string))
 
                 if refresh_channels:
-                    draw_channel_list(node_state)
+                    draw_channel_list()
                 if refresh_messages:
-                    draw_messages_window(node_state, True)
+                    draw_messages_window(True)
 
                 save_message_to_db(globals.channel_list[channel_number], message_from_id, message_string)
 

message_handlers/tx_handler.py

@@ -3,16 +3,16 @@ 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
+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, node_state):
-    from contact.ui.contact_ui import draw_messages_window
+def onAckNak(packet):
+    from ui.curses_ui import draw_messages_window
     request = packet['decoded']['requestId']
     if(request not in ack_naks):
         return
@@ -35,15 +35,15 @@ def onAckNak(packet, node_state):
 
     globals.all_messages[acknak['channel']][acknak['messageIndex']] = (config.sent_message_prefix + confirm_string + ": ", message)
 
-    update_ack_nak(acknak['channel'], acknak['timestamp'], message, ack_type, node_state)
+    update_ack_nak(acknak['channel'], acknak['timestamp'], message, ack_type)
 
     channel_number = globals.channel_list.index(acknak['channel'])
     if globals.channel_list[channel_number] == globals.channel_list[globals.selected_channel]:
-        draw_messages_window(node_state)
+        draw_messages_window()
 
-def on_response_traceroute(packet, node_state):
+def on_response_traceroute(packet):
     """on response for trace route"""
-    from contact.ui.contact_ui import draw_channel_list, draw_messages_window, add_notification
+    from ui.curses_ui import draw_channel_list, draw_messages_window, add_notification
 
     refresh_channels = False
     refresh_messages = False
@@ -56,18 +56,18 @@ def on_response_traceroute(packet, node_state):
 
     msg_str = "Traceroute to:\n"
 
-    route_str = get_name_from_database(packet["to"], node_state, '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
         for idx, node_num in enumerate(msg_dict["route"]):
-            route_str += " --> " + (get_name_from_database(node_num, node_state, 'short') or f"{node_num:08x}") \
+            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"], node_state, 'short') or f"{packet['from']:08x}") \
+    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
@@ -77,15 +77,15 @@ def on_response_traceroute(packet, node_state):
     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"], node_state, '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
             for idx, node_num in enumerate(msg_dict["routeBack"]):
-                route_str += " --> " + (get_name_from_database(node_num, node_state, 'short') or f"{node_num:08x}") \
+                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"], node_state, 'short') or f"{packet['to']:08x}") \
+        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
@@ -94,7 +94,7 @@ def on_response_traceroute(packet, node_state):
         globals.channel_list.append(packet['from'])
         refresh_channels = True
 
-    if(is_chat_archived(packet['from']), node_state):
+    if(is_chat_archived(packet['from'])):
         update_node_info_in_db(packet['from'], chat_archived=False)
 
     channel_number = globals.channel_list.index(packet['from'])
@@ -105,21 +105,21 @@ def on_response_traceroute(packet, node_state):
         add_notification(channel_number)
         refresh_channels = True
 
-    message_from_string = get_name_from_database(packet['from'], node_state, 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))
 
     if refresh_channels:
-        draw_channel_list(node_state)
+        draw_channel_list()
     if refresh_messages:
-        draw_messages_window(node_state, True)
+        draw_messages_window(True)
     save_message_to_db(globals.channel_list[channel_number], packet['from'], msg_str)
 
 
-def send_message(message, node_state, destination=BROADCAST_NUM, channel=0):
-    myid = node_state.myNodeNum
+def send_message(message, destination=BROADCAST_NUM, channel=0):
+    myid = globals.myNodeNum
     send_on_channel = 0
     channel_id = globals.channel_list[channel]
     if isinstance(channel_id, int):
@@ -128,7 +128,7 @@ def send_message(message, node_state, destination=BROADCAST_NUM, channel=0):
     elif isinstance(channel_id, str):
         send_on_channel = channel
 
-    sent_message_data = node_state.interface.sendText(
+    sent_message_data = globals.interface.sendText(
         text=message,
         destinationId=destination,
         wantAck=True,
@@ -168,9 +168,9 @@ def send_message(message, node_state, destination=BROADCAST_NUM, channel=0):
 
     ack_naks[sent_message_data.id] = {'channel': channel_id, 'messageIndex': len(globals.all_messages[channel_id]) - 1, 'timestamp': timestamp}
 
-def send_traceroute(node_state):
+def send_traceroute():
     r = mesh_pb2.RouteDiscovery()
-    node_state.interface.sendData(
+    globals.interface.sendData(
         r,
         destinationId=globals.node_list[globals.selected_node],
         portNum=portnums_pb2.PortNum.TRACEROUTE_APP,

pyproject.toml

@@ -1,24 +0,0 @@
-[project]
-name = "contact"
-version = "1.3.2"
-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,13 +5,13 @@ 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):
@@ -25,17 +25,17 @@ def main(stdscr):
 
             parser = setup_parser()
             args = parser.parse_args()
-            node_state.interface = initialize_interface(args)
+            interface = initialize_interface(args)
 
-            if node_state.interface.localNode.localConfig.lora.region == 0:
+            if 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(node_state.interface)
-                    node_state.interface.close()
-                    node_state.interface = initialize_interface(args)
+                    set_region(interface)
+                    interface.close()
+                    interface = initialize_interface(args)
             stdscr.clear()
             stdscr.refresh()
-            settings_menu(stdscr, node_state)
+            settings_menu(stdscr, interface)
 
     except Exception as e:
         console_output = output_capture.getvalue()
@@ -52,9 +52,6 @@ logging.basicConfig( # Run `tail -f client.log` in another terminal to view live
 )
 
 if __name__ == "__main__":
-    from contact.ui.ui_state import NodeState
-    node_state = NodeState()
-
     log_file = config.log_file_path
     log_f = open(log_file, "a", buffering=1)  # Enable line-buffering for immediate log writes
 

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,

ui/control_ui.py

@@ -5,18 +5,14 @@ import os
 import re
 import sys
 
-from contact.utilities.save_to_radio import save_changes
-from contact.utilities.config_io import config_export, config_import
-from contact.utilities.input_handlers import get_repeated_input, get_text_input, get_fixed32_input, get_list_input, get_admin_key_input
-from contact.ui.menus import generate_menu_from_protobuf
-from contact.ui.colors import get_color
-from contact.ui.dialog import dialog
-from contact.utilities.control_utils import parse_ini_file, transform_menu_path
-from contact.ui.user_config import json_editor
-from contact.ui.ui_state import MenuState
-
-menu_state = MenuState()
-
+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
@@ -31,18 +27,20 @@ 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")
+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(menu_state):
-
+def display_menu(current_menu, menu_path, selected_index, show_save_option, help_text):
     min_help_window_height = 6
-    num_items = len(menu_state.current_menu) + (1 if menu_state.show_save_option else 0)
+    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 
@@ -62,18 +60,18 @@ def display_menu(menu_state):
     menu_win.border()
     menu_win.keypad(True)
 
-    menu_pad = curses.newpad(len(menu_state.current_menu) + 1, width - 8)
+    menu_pad = curses.newpad(len(current_menu) + 1, width - 8)
     menu_pad.bkgd(get_color("background"))
 
-    header = " > ".join(word.title() for word in menu_state.menu_path)
+    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_state.menu_path)
+    transformed_path = transform_menu_path(menu_path)
 
-    for idx, option in enumerate(menu_state.current_menu):
-        field_info = menu_state.current_menu[option]
+    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)
@@ -82,41 +80,35 @@ def display_menu(menu_state):
         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))
+            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 menu_state.show_save_option:
+    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=(menu_state.selected_index == len(menu_state.current_menu))))
+        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, transformed_path, menu_state)
+    draw_help_window(start_y, start_x, menu_height, max_help_lines, current_menu, selected_index, transformed_path)
 
     menu_win.refresh()
     menu_pad.refresh(
-        menu_state.start_index[-1], 0,
+        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
+        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
     )
 
-    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)
-
     return menu_win, menu_pad
 
-
-def draw_help_window(menu_start_y, menu_start_x, menu_height, max_help_lines, transformed_path, menu_state):
+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(menu_state.current_menu.keys())[menu_state.selected_index] if menu_state.current_menu else None
+    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)
@@ -159,6 +151,7 @@ def update_help_window(help_win, help_text, transformed_path, selected_option, m
     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."""
     
@@ -251,116 +244,94 @@ def get_wrapped_help_text(help_text, transformed_path, selected_option, width, m
     return wrapped_help
 
 
-def move_highlight(old_idx, options, menu_win, menu_pad, help_win, help_text, max_help_lines, menu_state):
-    if old_idx == menu_state.selected_index:  # No-op
+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 menu_state.show_save_option else 0) - 1
-    visible_height = menu_win.getmaxyx()[0] - 5 - (2 if menu_state.show_save_option else 0)
+    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 menu_state.selected_index == max_index and menu_state.show_save_option:
-        pass
-    elif menu_state.selected_index < menu_state.start_index[-1]:  # Moving above the visible area
-        menu_state.start_index[-1] = menu_state.selected_index
-    elif menu_state.selected_index >= menu_state.start_index[-1] + visible_height:  # Moving below the visible area
-        menu_state.start_index[-1] = menu_state.selected_index - visible_height
-    pass
+    # 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 menu_state.start_index is within bounds
-    menu_state.start_index[-1] = max(0, min(menu_state.start_index[-1], max_index - visible_height + 1))
+    # Ensure start_index is within bounds
+    start_index[-1] = max(0, min(start_index[-1], max_index - visible_height + 1))
 
     # Clear old selection
-    if menu_state.show_save_option and old_idx == max_index:
+    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 menu_state.show_save_option and menu_state.selected_index == max_index:
+    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(menu_state.selected_index, 0, menu_pad.getmaxyx()[1], get_color("settings_sensitive", reverse=True) if options[menu_state.selected_index] in sensitive_settings else get_color("settings_default", reverse=True))
+        menu_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(menu_state.start_index[-1], 0,
+    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)
+                     menu_win.getbegyx()[1] + menu_win.getmaxyx()[1] - 8)
 
     # Update help window
-    transformed_path = transform_menu_path(menu_state.menu_path)
-    selected_option = options[menu_state.selected_index] if menu_state.selected_index < len(options) else None
+    transformed_path = transform_menu_path(menu_path)
+    selected_option = options[new_idx] if new_idx < len(options) else None
     help_y = menu_win.getbegyx()[0] + menu_win.getmaxyx()[0]
     help_win = update_help_window(help_win, help_text, transformed_path, selected_option, max_help_lines, width, help_y, menu_win.getbegyx()[1])
 
-    draw_arrows(menu_win, visible_height, max_index, menu_state)
 
-
-def draw_arrows(win, visible_height, max_index, menu_state):
-
-    # vh = visible_height + (1 if show_save_option else 0)
-    mi = max_index - (2 if menu_state.show_save_option else 0) 
-
-    if visible_height < mi:
-        if menu_state.start_index[-1] > 0:
-            win.addstr(3, 2, "▲", get_color("settings_default"))
-        else:
-            win.addstr(3, 2, " ", get_color("settings_default"))
-
-        if mi - menu_state.start_index[-1] >= visible_height + (0 if menu_state.show_save_option else 1) :
-            win.addstr(visible_height + 3, 2, "▼", get_color("settings_default"))
-        else:
-            win.addstr(visible_height + 3, 2, " ", get_color("settings_default"))
-        
-
-def settings_menu(stdscr, node_state):
+def settings_menu(stdscr, interface):
     curses.update_lines_cols()
 
-    menu = generate_menu_from_protobuf(node_state)
-    menu_state.current_menu = menu["Main Menu"]
-    menu_state.menu_path = ["Main Menu"]
-
-
+    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
-    menu_state.show_save_option = False
+    show_save_option = False
 
     while True:
         if(need_redraw):
-            options = list(menu_state.current_menu.keys())
+            options = list(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)
+            show_save_option = (
+                len(menu_path) > 2 and ("Radio Settings" in menu_path or "Module Settings" in menu_path)
             ) or (
-                len(menu_state.menu_path) == 2 and "User Settings" in menu_state.menu_path 
+                len(menu_path) == 2 and "User Settings" in menu_path 
             ) or (
-                len(menu_state.menu_path) == 3 and "Channels" in menu_state.menu_path
+                len(menu_path) == 3 and "Channels" in menu_path
             )
 
             # Display the menu
-            menu_win, menu_pad = display_menu(menu_state)
+            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 menu_state.show_save_option else 0) - 1
+        max_index = len(options) + (1 if 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, help_win, help_text, max_help_lines, menu_state)
+            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 = 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, help_win, help_text, max_help_lines, menu_state)
+            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
@@ -372,36 +343,41 @@ def settings_menu(stdscr, node_state):
             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, help_win, help_text, max_help_lines, menu_state)
+        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
-            menu_state.start_index.append(0)
+            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))
+            # 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 menu_state.show_save_option and menu_state.selected_index == len(options):
-                save_changes(node_state, modified_settings, menu_state)
+            # 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_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
+                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[menu_state.selected_index]
+            selected_option = options[selected_index]
 
             if selected_option == "Exit":
                 break
@@ -410,27 +386,27 @@ def settings_menu(stdscr, node_state):
                 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()
+                    start_index.pop()
                     continue  # Go back to the menu
                 if not filename.lower().endswith(".yaml"):
                     filename += ".yaml"
 
                 try:
-                    config_text = config_export(node_state)
-                    yaml_file_path = os.path.join(config_folder, filename)
+                    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.")
-                            menu_state.start_index.pop()
+                            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()
+                    start_index.pop()
                     continue
                 except PermissionError:
                     logging.error(f"Permission denied: Unable to write to {yaml_file_path}")
@@ -438,17 +414,18 @@ def settings_menu(stdscr, node_state):
                     logging.error(f"OS error while saving config: {e}")
                 except Exception as e:
                     logging.error(f"Unexpected error: {e}")
-                menu_state.start_index.pop()
+                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(config_folder) or not any(os.listdir(config_folder)):
+                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(config_folder) if os.path.isfile(os.path.join(config_folder, f))]
+                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:
@@ -457,76 +434,70 @@ def settings_menu(stdscr, node_state):
 
                 filename = get_list_input("Choose a config file", None, file_list)
                 if filename:
-                    file_path = os.path.join(config_folder, 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(node_state, file_path)
-                menu_state.start_index.pop()
+                        config_import(interface, file_path)
+                start_index.pop()
                 continue
 
             elif selected_option == "Config URL":
-                current_value = node_state.interface.localNode.getURL()
+                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":
-                        node_state.interface.localNode.setURL(new_value)
+                        interface.localNode.setURL(new_value)
                         logging.info(f"New Config URL sent to node")
-                menu_state.start_index.pop()
+                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":
-                    node_state.interface.localNode.reboot()
+                    interface.localNode.reboot()
                     logging.info(f"Node Reboot Requested by menu")
-                menu_state.start_index.pop()
+                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":
-                    node_state.interface.localNode.resetNodeDb()
+                    interface.localNode.resetNodeDb()
                     logging.info(f"Node DB Reset Requested by menu")
-                menu_state.start_index.pop()
+                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":
-                    node_state.interface.localNode.shutdown()
+                    interface.localNode.shutdown()
                     logging.info(f"Node Shutdown Requested by menu")
-                menu_state.start_index.pop()
+                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":
-                    node_state.interface.localNode.factoryReset()
+                    interface.localNode.factoryReset()
                     logging.info(f"Factory Reset Requested by menu")
-                menu_state.start_index.pop()
+                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
+                json_editor(stdscr)  # Open the App Settings menu
                 continue
                 # need_redraw = True
                 
-            field_info = menu_state.current_menu.get(selected_option)
+            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_state.menu_path)
+                transformed_path = transform_menu_path(menu_path)
                 full_key = '.'.join(transformed_path + [selected_option])
 
                 # Fetch human-readable name from field_mapping
@@ -536,70 +507,70 @@ def settings_menu(stdscr, node_state):
                     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)
+                        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)
+                        current_menu[selected_option] = (field, new_value)
 
-                    for option, (field, value) in menu_state.current_menu.items():
+                    for option, (field, value) in current_menu.items():
                         modified_settings[option] = value
 
-                    menu_state.start_index.pop()
+                    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)
+                    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]
+                        if option in current_menu:
+                            modified_settings[option] = current_menu[option][1]
 
-                    menu_state.start_index.pop()
+                    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()
+                    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
-                    menu_state.start_index.pop()
+                    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()
+                    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()
+                    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()
+                    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()
+                    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()
+                    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()
+                    start_index.pop()
                 
-                for key in menu_state.menu_path[3:]:  # Skip "Main Menu"
+                for key in menu_path[3:]:  # Skip "Main Menu"
                     modified_settings = modified_settings.setdefault(key, {})
 
                 # Add the new value to the appropriate level
@@ -610,12 +581,12 @@ def settings_menu(stdscr, node_state):
                     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)
+                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
+                current_menu = current_menu[selected_option]
+                menu_path.append(selected_option)
+                menu_index.append(selected_index)
+                selected_index = 0
 
 
         elif key == curses.KEY_LEFT:
@@ -625,30 +596,30 @@ def settings_menu(stdscr, node_state):
             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))
+            # 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_state.menu_path) < 2:
+            if len(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()
+            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(node_state):
-    node = node_state.interface.getNode('^local')
+def set_region(interface):
+    node = interface.getNode('^local')
     device_config = node.localConfig
     lora_descriptor = device_config.lora.DESCRIPTOR
 

ui/curses_ui.py

@@ -1,19 +1,17 @@
 import curses
 import textwrap
-import time
 import logging
 import traceback
-from contact.utilities.utils import get_channels, get_readable_duration, get_time_ago, refresh_node_list
-from contact.settings import settings_menu
-from contact.message_handlers.tx_handler import send_message, send_traceroute
-from contact.ui.colors import setup_colors, get_color
-from contact.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
+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
 
-def handle_resize(stdscr, firstrun, node_state):
+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
@@ -80,17 +78,17 @@ def handle_resize(stdscr, firstrun, node_state):
     curses.curs_set(1)
 
     try:
-        draw_function_win(node_state)
-        draw_channel_list(node_state)
-        draw_messages_window(node_state, True)
-        draw_node_list(node_state)
+        draw_function_win()
+        draw_channel_list()
+        draw_messages_window(True)
+        draw_node_list()
     except:
         # Resize events can come faster than we can re-draw, which can cause a curses error.
         # In this case we'll see another curses.KEY_RESIZE in our key handler and draw again later.
         pass
 
 
-def main_ui(stdscr, node_state):
+def main_ui(stdscr):
     global input_text
     input_text = ""
     stdscr.keypad(True)
@@ -111,7 +109,7 @@ def main_ui(stdscr, node_state):
             elif globals.current_window == 1:
                 scroll_messages(-1)
             elif globals.current_window == 2:
-                scroll_nodes(-1, node_state)
+                scroll_nodes(-1)
 
         elif char == curses.KEY_DOWN:
             if globals.current_window == 0:
@@ -119,11 +117,11 @@ def main_ui(stdscr, node_state):
             elif globals.current_window == 1:
                 scroll_messages(1)
             elif globals.current_window == 2:
-                scroll_nodes(1, node_state)
+                scroll_nodes(1)
 
         elif char == curses.KEY_HOME:
             if globals.current_window == 0:
-                select_channel(0, node_state)
+                select_channel(0)
             elif globals.current_window == 1:
                 globals.selected_message = 0
                 refresh_pad(1)
@@ -132,7 +130,7 @@ def main_ui(stdscr, node_state):
 
         elif char == curses.KEY_END:
             if globals.current_window == 0:
-                select_channel(len(globals.channel_list) - 1, node_state)
+                select_channel(len(globals.channel_list) - 1)
             elif globals.current_window == 1:
                 msg_line_count = messages_pad.getmaxyx()[0]
                 globals.selected_message = max(msg_line_count - get_msg_window_lines(), 0)
@@ -142,7 +140,7 @@ def main_ui(stdscr, node_state):
 
         elif char == curses.KEY_PPAGE:
             if globals.current_window == 0:
-                select_channel(globals.selected_channel - (channel_win.getmaxyx()[0] - 2), node_state) # 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)
@@ -151,7 +149,7 @@ def main_ui(stdscr, node_state):
 
         elif char == curses.KEY_NPAGE:
             if globals.current_window == 0:
-                select_channel(globals.selected_channel + (channel_win.getmaxyx()[0] - 2), node_state) # 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())
@@ -169,7 +167,7 @@ def main_ui(stdscr, node_state):
                 channel_win.attrset(get_color("window_frame"))
                 channel_win.box()
                 channel_win.refresh()
-                highlight_line(False, 0, globals.selected_channel, node_state)
+                highlight_line(False, 0, globals.selected_channel)
                 refresh_pad(0)
             if old_window == 1:
                 messages_win.attrset(get_color("window_frame"))
@@ -177,11 +175,11 @@ def main_ui(stdscr, node_state):
                 messages_win.refresh()
                 refresh_pad(1)
             elif old_window == 2:
-                draw_function_win(node_state)
+                draw_function_win()
                 nodes_win.attrset(get_color("window_frame"))
                 nodes_win.box()
                 nodes_win.refresh()
-                highlight_line(False, 2, globals.selected_node, node_state)
+                highlight_line(False, 2, globals.selected_node)
                 refresh_pad(2)
 
             if globals.current_window == 0:
@@ -189,7 +187,7 @@ def main_ui(stdscr, node_state):
                 channel_win.box()
                 channel_win.attrset(get_color("window_frame"))
                 channel_win.refresh()
-                highlight_line(True, 0, globals.selected_channel, node_state)
+                highlight_line(True, 0, globals.selected_channel)
                 refresh_pad(0)
             elif globals.current_window == 1:
                 messages_win.attrset(get_color("window_frame_selected"))
@@ -198,12 +196,12 @@ def main_ui(stdscr, node_state):
                 messages_win.refresh()
                 refresh_pad(1)
             elif globals.current_window == 2:
-                draw_function_win(node_state)
+                draw_function_win()
                 nodes_win.attrset(get_color("window_frame_selected"))
                 nodes_win.box()
                 nodes_win.attrset(get_color("window_frame"))
                 nodes_win.refresh()
-                highlight_line(True, 2, globals.selected_node, node_state)
+                highlight_line(True, 2, globals.selected_node)
                 refresh_pad(2)
 
         # Check for Esc
@@ -212,9 +210,9 @@ def main_ui(stdscr, node_state):
 
         # Check for Ctrl + t
         elif char == chr(20):
-            send_traceroute(node_state)
+            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)
 
@@ -229,20 +227,20 @@ def main_ui(stdscr, node_state):
 
                 globals.selected_channel = globals.channel_list.index(node_list[globals.selected_node])
 
-                if(is_chat_archived(globals.channel_list[globals.selected_channel], node_state)):
+                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
                 globals.current_window = 0
 
-                draw_node_list(node_state)
-                draw_channel_list(node_state)
-                draw_messages_window(node_state, True)
+                draw_node_list()
+                draw_channel_list()
+                draw_messages_window(True)
 
             elif len(input_text) > 0:
                 # Enter key pressed, send user input as message
-                send_message(input_text, node_state, channel=globals.selected_channel)
-                draw_messages_window(node_state, True)
+                send_message(input_text, channel=globals.selected_channel)
+                draw_messages_window(True)
 
                 # Clear entry window and reset input text
                 input_text = ""
@@ -259,7 +257,7 @@ def main_ui(stdscr, node_state):
             
         elif char == "`": # ` Launch the settings interface
             curses.curs_set(0)
-            settings_menu(stdscr, node_state.interface)
+            settings_menu(stdscr, globals.interface)
             curses.curs_set(1)
             refresh_node_list()
             handle_resize(stdscr, False)
@@ -268,11 +266,11 @@ def main_ui(stdscr, node_state):
             # Display packet log
             if globals.display_log is False:
                 globals.display_log = True
-                draw_messages_window(node_state, True)
+                draw_messages_window(True)
             else:
                 globals.display_log = False
                 packetlog_win.erase()
-                draw_messages_window(node_state, True)
+                draw_messages_window(True)
 
         elif char == curses.KEY_RESIZE:
             input_text = ""
@@ -291,83 +289,14 @@ def main_ui(stdscr, node_state):
 
                     del globals.channel_list[globals.selected_channel]
                     globals.selected_channel = min(globals.selected_channel, len(globals.channel_list) - 1)
-                    select_channel(globals.selected_channel, node_state)
-                    draw_channel_list(node_state)
-                    draw_messages_window(node_state)
+                    select_channel(globals.selected_channel)
+                    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], node_state)} from nodedb?", "No", ["Yes", "No"])
-                if confirmation == "Yes":
-                    node_state.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(node_state.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(node_state.interface.nodes[hexid])
-
-                    globals.node_list.pop(globals.selected_node)
-
-                    draw_messages_window(node_state)
-                    draw_node_list(node_state)
-                else:
-                    draw_messages_window(node_state)
-                curses.curs_set(1)
-                continue
-
-        # ^/
         elif char == chr(31):
             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 = node_state.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?", node_state, None, ["Yes", "No"])
-                    if confirmation == "Yes":
-                        node_state.interface.localNode.setFavorite(globals.node_list[globals.selected_node])
-                        # Maybe we shouldn't be modifying the nodedb, but maybe it should update itself
-                        node_state.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?", node_state, None, ["Yes", "No"])
-                    if confirmation == "Yes":
-                        node_state.interface.localNode.removeFavorite(globals.node_list[globals.selected_node])
-                        # Maybe we shouldn't be modifying the nodedb, but maybe it should update itself
-                        node_state.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 = node_state.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?", node_state, "No", ["Yes", "No"])
-                    if confirmation == "Yes":
-                        node_state.interface.localNode.setIgnored(globals.node_list[globals.selected_node])
-                        node_state.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?", node_state, "No", ["Yes", "No"])
-                    if confirmation == "Yes":
-                        node_state.interface.localNode.removeIgnored(globals.node_list[globals.selected_node])
-                        node_state.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)):
@@ -377,7 +306,7 @@ def main_ui(stdscr, node_state):
 
 
 
-def draw_channel_list(node_state):
+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
@@ -388,9 +317,9 @@ def draw_channel_list(node_state):
     for channel in globals.channel_list:
         # Convert node number to long name if it's an integer
         if isinstance(channel, int):
-            if is_chat_archived(channel, node_state):
+            if is_chat_archived(channel):
                 continue
-            channel_name = get_name_from_database(channel, node_state, type='long')
+            channel_name = get_name_from_database(channel, type='long')
             if channel_name is None:
                 continue
             channel = channel_name
@@ -418,7 +347,7 @@ def draw_channel_list(node_state):
 
     refresh_pad(0)
 
-def draw_messages_window(node_state, scroll_to_bottom = False):
+def draw_messages_window(scroll_to_bottom = False):
     """Update the messages window based on the selected channel and scroll position."""
     messages_pad.erase()
 
@@ -459,9 +388,9 @@ def draw_messages_window(node_state, scroll_to_bottom = False):
 
     refresh_pad(1)
 
-    draw_packetlog_win(node_state)
+    draw_packetlog_win()
 
-def draw_node_list(node_state):
+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
@@ -479,15 +408,10 @@ def draw_node_list(node_state):
         logging.error("Traceback: %s", traceback.format_exc())
 
     for i, node_num in enumerate(globals.node_list):
-        node = node_state.interface.nodesByNum[node_num]
+        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, node_state, '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))
+        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()
@@ -497,25 +421,25 @@ def draw_node_list(node_state):
     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, node_state):
+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(node_state, True)
+    draw_messages_window(True)
 
     # For now just re-draw channel list when clearing notifications, we can probably make this more efficient
     if globals.selected_channel in globals.notifications:
         remove_notification(globals.selected_channel)
-        draw_channel_list(node_state)
+        draw_channel_list()
         return
-    highlight_line(False, 0, old_selected_channel, node_state)
-    highlight_line(True, 0, globals.selected_channel, node_state)
+    highlight_line(False, 0, old_selected_channel)
+    highlight_line(True, 0, globals.selected_channel)
     refresh_pad(0)
 
-def scroll_channels(direction, node_state):
+def scroll_channels(direction):
     new_selected_channel = globals.selected_channel + direction
 
     if new_selected_channel < 0:
@@ -523,7 +447,7 @@ def scroll_channels(direction, node_state):
     elif new_selected_channel >= len(globals.channel_list):
         new_selected_channel = 0
 
-    select_channel(new_selected_channel, node_state)
+    select_channel(new_selected_channel)
 
 def scroll_messages(direction):
     globals.selected_message += direction
@@ -533,17 +457,17 @@ def scroll_messages(direction):
 
     refresh_pad(1)
 
-def select_node(idx, node_state):
+def select_node(idx):
     old_selected_node = globals.selected_node
     globals.selected_node = max(0, min(idx, len(globals.node_list) - 1))
 
-    highlight_line(False, 2, old_selected_node, node_state)
-    highlight_line(True, 2, globals.selected_node, node_state)
+    highlight_line(False, 2, old_selected_node)
+    highlight_line(True, 2, globals.selected_node)
     refresh_pad(2)
 
-    draw_function_win(node_state)
+    draw_function_win()
 
-def scroll_nodes(direction, node_state):
+def scroll_nodes(direction):
     new_selected_node = globals.selected_node + direction
 
     if new_selected_node < 0:
@@ -551,9 +475,9 @@ def scroll_nodes(direction, node_state):
     elif new_selected_node >= len(globals.node_list):
         new_selected_node = 0
 
-    select_node(new_selected_node, node_state)
+    select_node(new_selected_node)
 
-def draw_packetlog_win(node_state):
+def draw_packetlog_win():
 
     columns = [10,10,15,30]
     span = 0
@@ -574,10 +498,10 @@ def draw_packetlog_win(node_state):
                 break
             
             # Format each field
-            from_id = get_name_from_database(packet['from'], node_state, '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'], node_state, 'short').ljust(columns[1])
+                else get_name_from_database(packet['to'], 'short').ljust(columns[1])
             )
             if 'decoded' in packet:
                 port = packet['decoded']['portnum'].ljust(columns[2])
@@ -598,9 +522,9 @@ def draw_packetlog_win(node_state):
         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):
     start_idx = globals.selected_node
@@ -645,10 +569,10 @@ def search(win):
 
     entry_win.erase()
 
-def draw_node_details(node_state):
+def draw_node_details():
     node = None
     try:
-        node = node_state.interface.nodesByNum[globals.node_list[globals.selected_node]]
+        node = globals.interface.nodesByNum[globals.node_list[globals.selected_node]]
     except KeyError:
         return
 
@@ -694,7 +618,7 @@ def draw_node_details(node_state):
     draw_centered_text_field(function_win, nodestr, 0, get_color("commands"))
 
 def draw_help():
-    cmds = ["↑→↓← = Select", "    ENTER = Send", "    ` = Settings", "    ^P = Packet Log", "    ESC = Quit", "    ^t = Traceroute", "    ^d = Archive Chat", "    ^f = Favorite", "    ^g = Ignore"]
+    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):
@@ -702,9 +626,9 @@ def draw_help():
 
     draw_centered_text_field(function_win, function_str, 0, get_color("commands"))
 
-def draw_function_win(node_state):
+def draw_function_win():
     if(globals.current_window == 2):
-        draw_node_details(node_state)
+        draw_node_details()
     else:
         draw_help()
 
@@ -746,20 +670,11 @@ def refresh_pad(window):
                         box.getbegyx()[0] + 1, box.getbegyx()[1] + 1,
                         box.getbegyx()[0] + lines, box.getbegyx()[1] + box.getmaxyx()[1] - 2)
 
-def highlight_line(highlight, window, line, node_state):
+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 = node_state.interface.nodesByNum[node_num]
-        if 'isFavorite' in node and node['isFavorite']:
-            color = get_color("node_favorite")
-        if 'isIgnored' in node and node['isIgnored']:
-            color = get_color("node_ignored")
-
     if(window == 0):
         pad = channel_pad
         color = get_color("channel_selected" if (line == globals.selected_channel and highlight == False) else "channel_list")
@@ -788,4 +703,4 @@ def draw_centered_text_field(win, text, y_offset, color):
 
 def draw_debug(value):
     function_win.addstr(1, 1, f"debug: {value}    ")
-    function_win.refresh()
+    function_win.refresh()

ui/default_config.py

@@ -65,9 +65,7 @@ def initialize_config():
         "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"],
@@ -91,9 +89,7 @@ def initialize_config():
         "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"],
@@ -119,9 +115,7 @@ def initialize_config():
         "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,

ui/dialog.py

@@ -1,5 +1,5 @@
 import curses
-from contact.ui.colors import get_color
+from ui.colors import get_color
 
 def dialog(stdscr, title, message):
     height, width = stdscr.getmaxyx()

ui/splash.py

@@ -1,5 +1,5 @@
 import curses
-from contact.ui.colors import get_color
+from ui.colors import get_color
 
 def draw_splash(stdscr):
     curses.curs_set(0)

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

@@ -33,14 +33,5 @@ def setup_parser():
         default=None,
         const="any"
     )
-    parser.add_argument(
-        "--settings",
-        "--set",
-        "--control",
-        "-c",
-        help="Launch directly into the settings",
-        action="store_true"
-    )
-
 
     return parser

utilities/config_io.py

@@ -123,24 +123,24 @@ def setPref(config, comp_name, raw_val) -> bool:
 
 
 
-def config_import(node_state, filename):
+def config_import(interface, filename):
     with open(filename, encoding="utf8") as file:
         configuration = yaml.safe_load(file)
         closeNow = True
 
-        node_state.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
-            node_state.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']}"
             )
             waitForAckNak = True
-            node_state.interface.getNode('^local', False).setOwner(
+            interface.getNode('^local', False).setOwner(
                 long_name=None, short_name=configuration["owner_short"]
             )
 
@@ -149,23 +149,23 @@ def config_import(node_state, filename):
                 f"Setting device owner short to {configuration['ownerShort']}"
             )
             waitForAckNak = True
-            node_state.interface.getNode('^local', False).setOwner(
+            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']}")
-            node_state.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']}")
-            node_state.interface.getNode('^local').setURL(configuration["channelUrl"])
+            interface.getNode('^local').setURL(configuration["channelUrl"])
 
         if "location" in configuration:
             alt = 0
             lat = 0.0
             lon = 0.0
-            localConfig = node_state.interface.localNode.localConfig
+            localConfig = interface.localNode.localConfig
 
             if "alt" in configuration["location"]:
                 alt = int(configuration["location"]["alt"] or 0)
@@ -177,43 +177,43 @@ def config_import(node_state, filename):
                 lon = float(configuration["location"]["lon"] or 0)
                 logging.info(f"Fixing longitude at {lon} degrees")
             logging.info("Setting device position")
-            node_state.interface.localNode.setFixedPosition(lat, lon, alt)
+            interface.localNode.setFixedPosition(lat, lon, alt)
 
         if "config" in configuration:
-            localConfig = node_state.interface.getNode('^local').localConfig
+            localConfig = interface.getNode('^local').localConfig
             for section in configuration["config"]:
                 traverseConfig(
                     section, configuration["config"][section], localConfig
                 )
-                node_state.interface.getNode('^local').writeConfig(
+                interface.getNode('^local').writeConfig(
                     camel_to_snake(section)
                 )
 
         if "module_config" in configuration:
-            moduleConfig = node_state.interface.getNode('^local').moduleConfig
+            moduleConfig = interface.getNode('^local').moduleConfig
             for section in configuration["module_config"]:
                 traverseConfig(
                     section,
                     configuration["module_config"][section],
                     moduleConfig,
                 )
-                node_state.interface.getNode('^local').writeConfig(
+                interface.getNode('^local').writeConfig(
                     camel_to_snake(section)
                 )
 
-        node_state.interface.getNode('^local', False).commitSettingsTransaction()
+        interface.getNode('^local', False).commitSettingsTransaction()
         logging.info("Writing modified configuration to device")
 
 
 
-def config_export(node_state) -> str:
+def config_export(interface) -> str:
     """used in --export-config"""
     configObj = {}
 
-    owner = node_state.interface.getLongName()
-    owner_short = node_state.interface.getShortName()
-    channel_url = node_state.interface.localNode.getURL()
-    myinfo = node_state.interface.getMyNodeInfo()
+    owner = interface.getLongName()
+    owner_short = interface.getShortName()
+    channel_url = interface.localNode.getURL()
+    myinfo = interface.getMyNodeInfo()
     pos = myinfo.get("position")
     lat = None
     lon = None
@@ -238,7 +238,7 @@ def config_export(node_state) -> str:
         if alt:
             configObj["location"]["alt"] = alt
 
-    config = MessageToDict(node_state.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 = {}
@@ -261,7 +261,7 @@ def config_export(node_state) -> str:
         else:
             configObj["config"] = config
 
-    module_config = MessageToDict(node_state.interface.localNode.moduleConfig)
+    module_config = MessageToDict(interface.localNode.moduleConfig)
     if module_config:
         # Convert inner keys to correct snake/camelCase
         prefs = {}

utilities/db_handler.py

@@ -1,17 +1,42 @@
 import sqlite3
 import time
 import logging
+import re
 from datetime import datetime
 
-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, node_state):
-    # Construct the table name
-    table_name = f"{str(node_state.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 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):
@@ -27,7 +52,7 @@ def save_message_to_db(channel, user_id, message_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())
 
@@ -47,9 +72,9 @@ def save_message_to_db(channel, user_id, message_text):
         logging.error(f"Unexpected error in save_message_to_db: {e}")
 
 
-def update_ack_nak(channel, timestamp, message, ack, node_state):
+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)}
@@ -59,7 +84,7 @@ def update_ack_nak(channel, timestamp, message, ack, node_state):
                       message_text = ?
             """
 
-            db_cursor.execute(update_query, (ack, str(node_state.myNodeNum), timestamp, message))
+            db_cursor.execute(update_query, (ack, str(globals.myNodeNum), timestamp, message))
             db_connection.commit()
 
     except sqlite3.Error as e:
@@ -69,14 +94,14 @@ def update_ack_nak(channel, timestamp, message, ack, node_state):
         logging.error(f"Unexpected error in update_ack_nak: {e}")
 
 
-def load_messages_from_db(node_state):
+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 ?"
-            db_cursor.execute(query, (f"{str(node_state.myNodeNum)}_%_messages",))
+            db_cursor.execute(query, (f"{str(globals.myNodeNum)}_%_messages",))
             tables = [row[0] for row in db_cursor.fetchall()]
 
             # Iterate through each table and fetch its messages
@@ -123,10 +148,10 @@ def load_messages_from_db(node_state):
                         elif ack_type == "Nak":
                             ack_str = config.nak_str
 
-                        if user_id == str(node_state.myNodeNum):
+                        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), node_state,'short')}: ", message)
+                            formatted_message = (f"{config.message_prefix} {get_name_from_database(int(user_id), 'short')}: ", message)
                         
                         hourly_messages[hour].append(formatted_message)
 
@@ -142,14 +167,14 @@ def load_messages_from_db(node_state):
         logging.error(f"SQLite error in load_messages_from_db: {e}")
 
 
-def init_nodedb(node_state):
+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
 
-        ensure_node_table_exists(node_state)  # Ensure the table exists before insertion
+        ensure_node_table_exists()  # Ensure the table exists before insertion
         nodes_snapshot = list(globals.interface.nodes.values())
 
         # Insert or update all nodes
@@ -172,7 +197,7 @@ def init_nodedb(node_state):
         logging.error(f"Unexpected error in init_nodedb: {e}")
 
 
-def maybe_store_nodeinfo_in_db(packet, node_state):
+def maybe_store_nodeinfo_in_db(packet):
     """Save nodeinfo unless that record is already there, updating if necessary."""
     try:
         user_id = packet['from']
@@ -183,21 +208,23 @@ def maybe_store_nodeinfo_in_db(packet, node_state):
         role = packet['decoded']['user'].get('role', 'CLIENT')
         public_key = packet['decoded']['user'].get('publicKey', '')
 
-        update_node_info_in_db(node_state, user_id, long_name, short_name, hw_model, is_licensed, role, public_key)
+        update_node_info_in_db(user_id, long_name, short_name, hw_model, is_licensed, role, public_key)
 
     except sqlite3.Error as e:
         logging.error(f"SQLite error in maybe_store_nodeinfo_in_db: {e}")
     except Exception as e:
         logging.error(f"Unexpected error in maybe_store_nodeinfo_in_db: {e}")
 
-def update_node_info_in_db(node_state, user_id, long_name=None, short_name=None, hw_model=None, is_licensed=None, role=None, public_key=None, chat_archived=None):
+
+def update_node_info_in_db(user_id, 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(node_state)  # Ensure the table exists before any operation
+        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'"{node_state.myNodeNum}_nodedb"'  # Quote in case of numeric names
+            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})')]
             if "chat_archived" not in table_columns:
@@ -219,26 +246,18 @@ def update_node_info_in_db(node_state, user_id, long_name=None, short_name=None,
                 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
+            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()
@@ -249,9 +268,9 @@ def update_node_info_in_db(node_state, user_id, long_name=None, short_name=None,
         logging.error(f"Unexpected error in update_node_info_in_db: {e}")
 
 
-def ensure_node_table_exists(node_state):
+def ensure_node_table_exists():
     """Ensure the node database table exists."""
-    table_name = f'"{node_state.myNodeNum}_nodedb"'  # Quote for safety
+    table_name = f'"{globals.myNodeNum}_nodedb"'  # Quote for safety
     schema = '''
         user_id TEXT PRIMARY KEY,
         long_name TEXT,
@@ -268,7 +287,7 @@ def ensure_node_table_exists(node_state):
 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)
@@ -279,31 +298,32 @@ def ensure_table_exists(table_name, schema):
         logging.error(f"Unexpected error in ensure_table_exists({table_name}): {e}")
 
 
-def get_name_from_database(user_id,  node_state, type="long"):
-    """
-    Retrieve a user's name (long or short) from the node database.
-    
-    :param user_id: The user ID to look up.
-    :param type: "long" for long name, "short" for short name.
-    :return: The retrieved name or the hex of the user id
-    """
+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]
+
     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}"'
 
-            # Construct table name
-            table_name = f"{str(node_state.myNodeNum)}_nodedb"
-            nodeinfo_table = f'"{table_name}"'  # Quote table name for safety
-            
-            # Determine the correct column to fetch
-            column_name = "long_name" if type == "long" else "short_name"
-
-            # 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}")
@@ -312,12 +332,14 @@ def get_name_from_database(user_id,  node_state, type="long"):
     except Exception as e:
         logging.error(f"Unexpected error in get_name_from_database: {e}")
         return "Unknown"
+    
 
-def is_chat_archived(user_id, node_state):
+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(node_state.myNodeNum)}_nodedb"
+            table_name = f"{str(globals.myNodeNum)}_nodedb"
             nodeinfo_table = f'"{table_name}"'
             query = f"SELECT chat_archived FROM {nodeinfo_table} WHERE user_id = ?"
             db_cursor.execute(query, (user_id,))
@@ -327,9 +349,8 @@ def is_chat_archived(user_id, node_state):
 
     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

@@ -3,7 +3,7 @@ import binascii
 import curses
 import ipaddress
 import re
-from contact.ui.colors import get_color
+from ui.colors import get_color
 
 def wrap_text(text, wrap_width):
     """Wraps text while preserving spaces and breaking long words."""
@@ -372,11 +372,6 @@ def get_list_input(prompt, current_option, list_options):
     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)
 
     while True:
         key = list_win.getch()
@@ -390,12 +385,8 @@ def get_list_input(prompt, current_option, list_options):
             selected_index = min(len(list_options) - 1, selected_index + 1)
             move_highlight(old_selected_index, selected_index, list_options, list_win, list_pad)
         elif key == ord('\n'):  # Enter key
-            list_win.clear()
-            list_win.refresh()
             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
 
 
@@ -433,22 +424,5 @@ def move_highlight(old_idx, new_idx, options, list_win, list_pad):
                      list_win.getbegyx()[0] + 3, list_win.getbegyx()[1] + 4,
                      list_win.getbegyx()[0] + 3 + visible_height, 
                      list_win.getbegyx()[1] + list_win.getmaxyx()[1] - 4)
-    
-    draw_arrows(list_win, visible_height, max_index, scroll_offset)
 
-    return scroll_offset  # Return updated scroll_offset to be stored externally
-
-
-def draw_arrows(win, visible_height, max_index, start_index):
-
-    if visible_height < max_index:
-        if start_index > 0:
-            win.addstr(3, 2, "▲", get_color("settings_default"))
-        else:
-            win.addstr(3, 2, " ", get_color("settings_default"))
-
-        if max_index - start_index > visible_height:
-            win.addstr(visible_height + 3, 2, "▼", get_color("settings_default"))
-        else:
-            win.addstr(visible_height + 3, 2, " ", get_color("settings_default"))
-        
+    return scroll_offset  # Return updated scroll_offset to be stored externally

utilities/interfaces.py

@@ -1,6 +1,6 @@
 import logging
 import meshtastic.serial_interface, meshtastic.tcp_interface, meshtastic.ble_interface
-import contact.globals as globals
+import globals
 
 def initialize_interface(args):
     try:

utilities/save_to_radio.py

@@ -4,7 +4,7 @@ import logging
 import base64
 import time
 
-def save_changes(node_state, 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,7 +16,7 @@ def save_changes(node_state, modified_settings, menu_state):
             logging.info("No changes to save. modified_settings is empty.")
             return
         
-        node = node_state.interface.getNode('^local')
+        node = interface.getNode('^local')
         admin_key_backup = None
         if 'admin_key' in modified_settings:
             # Get reference to security config
@@ -52,19 +52,19 @@ def save_changes(node_state, modified_settings, menu_state):
             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))
 
-                node_state.interface.localNode.setFixedPosition(lat, lon, alt)
+                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")
@@ -77,11 +77,11 @@ def save_changes(node_state, modified_settings, menu_state):
 
             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

utilities/utils.py

@@ -1,7 +1,7 @@
-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."""
@@ -47,15 +47,7 @@ def get_node_list():
                 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]
         return [my_node_num] + node_list  # Ensuring your node is always first
     return []
@@ -67,9 +59,10 @@ def refresh_node_list():
         return True
     return False
 
-def get_nodeNum(node_state):
-    myinfo = node_state.interface.getMyNodeInfo()
-    node_state.myNodeNum = myinfo['num']
+def get_nodeNum():
+    myinfo = globals.interface.getMyNodeInfo()
+    myNodeNum = myinfo['num']
+    return myNodeNum
 
 def decimal_to_hex(decimal_number):
     return f"!{decimal_number:08x}"