reinit after region set

* more excuses

* none isn't better than nothing

* more checks

* typo

* refactor

* less is more

* grasping at straws

* more global

* back up

* db snapshot

* try a threading lock

* fix conflict

* lock it down

* sir locks a lot

* sir locks a lilttle less

.gitignore

@@ -1,7 +1,10 @@
 venv/
 .venv/
 __pycache__/
+node-configs/
 client.db
 .DS_Store
 client.log
 settings.log
+config.json
+default_config.log

README.md

@@ -1,13 +1,41 @@
 ## Contact - A Console UI for Meshtastic
-Powered by Meshtastic.org
+### (Formerly Curses Client for Meshtastic)
 
-<img width="846" alt="Screenshot_2024-03-29_at_4 00 29_PM" src="https://github.com/pdxlocations/meshtastic-curses-client/assets/117498748/e99533b7-5c0c-463d-8d5f-6e3cccaeced7">
+#### Powered by Meshtastic.org
 
+This Python curses client for Meshtastic is a terminal-based client designed to manage device settings, enable mesh chat communication, and handle configuration backups and restores.
+
+
+<img width="846" alt="Contact - Main UI Screenshot" src="https://github.com/user-attachments/assets/d2996bfb-2c6d-46a8-b820-92a9143375f4">
 
 <br><br>
-Settings can be accessed within the client or can be run standalone
+The settings dialogue can be accessed within the client or may be run standalone to configure your node by launching `settings.py`
 
-<img width="509" alt="Screenshot 2024-04-15 at 3 39 12 PM" src="https://github.com/pdxlocations/meshtastic-curses-client/assets/117498748/37bc57db-fe2d-4ba4-adc8-679b4cb642f9">
+<img width="441" alt="Contact - Settings Dialogue" src="https://github.com/user-attachments/assets/dd47f52a-d4d8-4e40-8001-9ea53d87f816" />
+
+## Message Persistence 
+
+All messages will saved in a SQLite DB and restored upon relaunch of the app.  You may delete `client.db` if you wish to erase all stored messages and node data.  If multiple nodes are used, each will independently store data in the database, but the data will not be shared or viewable between nodes.
+
+## Client Configuration
+
+By navigating to Settings -> App Settings, you may customize your UI's icons, colors, and more!
+
+## Commands
+
+- `↑→↓←` = Navigate around the UI.
+- `ENTER` = Send a message typed in the Input Window, or with the Node List highlighted, select a node to DM
+-  `` ` `` = Open the Settings dialogue
+- `CTRL` + `p` = Hide/show a log of raw received packets.
+- `CTRL` + `t` = With the Node List highlighted, send a traceroute to the selected node 
+- `CTRL` + `d` = With the Channel List hightlighted, archive a chat to reduce UI clutter. Messages will be saved in the db and repopulate if you send or receive a DM from this user.
+- `ESC` = Exit out of the Settings Dialogue, or Quit the application if settings are not displayed.
+
+### Search
+- Press `CTRL` + `/` while the nodes or channels window is highlighted to start search
+- Type text to search as you type, first matching item will be selected, starting at current selected index
+- Press Tab to find next match starting from the current index - search wraps around if necessary
+- Press Esc or Enter to exit search mode
 
 ## Arguments
 
@@ -18,7 +46,7 @@ You can pass the following arguments to the client:
 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.
+- `--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.
 
 If no connection arguments are specified, the client will attempt a serial connection and then a TCP connection to localhost.
@@ -29,3 +57,8 @@ If no connection arguments are specified, the client will attempt a serial conne
 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
+python main.py -t
+```

db_handler.py

@@ -1,9 +1,11 @@
 import sqlite3
-import globals
 import time
+import logging
 from datetime import datetime
 
-from utilities.utils import get_name_from_number
+from utilities.utils import decimal_to_hex
+import default_config as config
+import globals
 
 def get_table_name(channel):
     # Construct the table name
@@ -11,26 +13,22 @@ def get_table_name(channel):
     quoted_table_name = f'"{table_name}"'  # Quote the table name becuase we begin with numerics and contain spaces
     return quoted_table_name
 
+
 def save_message_to_db(channel, user_id, message_text):
     """Save messages to the database, ensuring the table exists."""
     try:
-        with sqlite3.connect(globals.db_file_path) as db_connection:
+        quoted_table_name = get_table_name(channel)
+
+        schema = '''
+            user_id TEXT,
+            message_text TEXT,
+            timestamp INTEGER,
+            ack_type TEXT
+        '''
+        ensure_table_exists(quoted_table_name, schema)
+
+        with sqlite3.connect(config.db_file_path) as db_connection:
             db_cursor = db_connection.cursor()
-
-            quoted_table_name = get_table_name(channel)
-
-            # Ensure the table exists
-            create_table_query = f'''
-                CREATE TABLE IF NOT EXISTS {quoted_table_name} (
-                    user_id TEXT,
-                    message_text TEXT,
-                    timestamp INTEGER,
-                    ack_type TEXT
-                )
-            '''
-
-            db_cursor.execute(create_table_query)
-
             timestamp = int(time.time())
 
             # Insert the message
@@ -44,14 +42,14 @@ def save_message_to_db(channel, user_id, message_text):
             return timestamp
 
     except sqlite3.Error as e:
-        print(f"SQLite error in save_message_to_db: {e}")
-
+        logging.error(f"SQLite error in save_message_to_db: {e}")
     except Exception as e:
-        print(f"Unexpected error in save_message_to_db: {e}")
+        logging.error(f"Unexpected error in save_message_to_db: {e}")
+
 
 def update_ack_nak(channel, timestamp, message, ack):
     try:
-        with sqlite3.connect(globals.db_file_path) as db_connection:
+        with sqlite3.connect(config.db_file_path) as db_connection:
             db_cursor = db_connection.cursor()
             update_query = f"""
                 UPDATE {get_table_name(channel)}
@@ -65,21 +63,18 @@ def update_ack_nak(channel, timestamp, message, ack):
             db_connection.commit()
 
     except sqlite3.Error as e:
-        print(f"SQLite error in update_ack_nak: {e}")
+        logging.error(f"SQLite error in update_ack_nak: {e}")
 
     except Exception as e:
-        print(f"Unexpected error in update_ack_nak: {e}")
+        logging.error(f"Unexpected error in update_ack_nak: {e}")
 
 
-from datetime import datetime
-
 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(globals.db_file_path) as db_connection:
+        with sqlite3.connect(config.db_file_path) as db_connection:
             db_cursor = db_connection.cursor()
 
-            # Retrieve all table names that match the pattern
             query = "SELECT name FROM sqlite_master WHERE type='table' AND name LIKE ?"
             db_cursor.execute(query, (f"{str(globals.myNodeNum)}_%_messages",))
             tables = [row[0] for row in db_cursor.fetchall()]
@@ -102,11 +97,11 @@ def load_messages_from_db():
                     # Extract the channel name from the table name
                     channel = table_name.split("_")[1]
                     
-                    # Convert the channel to an integer if it's numeric, otherwise keep it as a string
+                    # Convert the channel to an integer if it's numeric, otherwise keep it as a string (nodenum vs channel name)
                     channel = int(channel) if channel.isdigit() else channel
                     
                     # Add the channel to globals.channel_list if not already present
-                    if channel not in globals.channel_list:
+                    if channel not in globals.channel_list and not is_chat_archived(channel):
                         globals.channel_list.append(channel)
 
                     # Ensure the channel exists in globals.all_messages
@@ -120,18 +115,18 @@ def load_messages_from_db():
                         if hour not in hourly_messages:
                             hourly_messages[hour] = []
                         
-                        ack_str = globals.ack_unknown_str
+                        ack_str = config.ack_unknown_str
                         if ack_type == "Implicit":
-                            ack_str = globals.ack_implicit_str
+                            ack_str = config.ack_implicit_str
                         elif ack_type == "Ack":
-                            ack_str = globals.ack_str
+                            ack_str = config.ack_str
                         elif ack_type == "Nak":
-                            ack_str = globals.nak_str
+                            ack_str = config.nak_str
 
                         if user_id == str(globals.myNodeNum):
-                            formatted_message = (f"{globals.sent_message_prefix}{ack_str}: ", message)
+                            formatted_message = (f"{config.sent_message_prefix}{ack_str}: ", message)
                         else:
-                            formatted_message = (f"{globals.message_prefix} {get_name_from_number(int(user_id), 'short')}: ", message)
+                            formatted_message = (f"{config.message_prefix} {get_name_from_database(int(user_id), 'short')}: ", message)
                         
                         hourly_messages[hour].append(formatted_message)
 
@@ -141,145 +136,194 @@ def load_messages_from_db():
                         globals.all_messages[channel].extend(messages)
 
                 except sqlite3.Error as e:
-                    print(f"SQLite error while loading messages from table '{table_name}': {e}")
+                    logging.error(f"SQLite error while loading messages from table '{table_name}': {e}")
 
     except sqlite3.Error as e:
-        print(f"SQLite error in load_messages_from_db: {e}")
+        logging.error(f"SQLite error in load_messages_from_db: {e}")
 
 
 def init_nodedb():
     """Initialize the node database and update it with nodes from the interface."""
+    
     try:
-        with sqlite3.connect(globals.db_file_path) as db_connection:
+        if not globals.interface.nodes:
+            return  # No nodes to initialize
+
+        ensure_node_table_exists()  # Ensure the table exists before insertion
+        nodes_snapshot = list(globals.interface.nodes.values())
+
+        # Insert or update all nodes
+        for node in nodes_snapshot:
+            update_node_info_in_db(
+                user_id=node['num'],
+                long_name=node['user'].get('longName', ''),
+                short_name=node['user'].get('shortName', ''),
+                hw_model=node['user'].get('hwModel', ''),
+                is_licensed=node['user'].get('isLicensed', '0'),
+                role=node['user'].get('role', 'CLIENT'),
+                public_key=node['user'].get('publicKey', '')
+            )
+
+        logging.info("Node database initialized successfully.")
+
+    except sqlite3.Error as e:
+        logging.error(f"SQLite error in init_nodedb: {e}")
+    except Exception as e:
+        logging.error(f"Unexpected error in init_nodedb: {e}")
+
+
+def maybe_store_nodeinfo_in_db(packet):
+    """Save nodeinfo unless that record is already there, updating if necessary."""
+    try:
+        user_id = packet['from']
+        long_name = packet['decoded']['user']['longName']
+        short_name = packet['decoded']['user']['shortName']
+        hw_model = packet['decoded']['user']['hwModel']
+        is_licensed = packet['decoded']['user'].get('isLicensed', '0')
+        role = packet['decoded']['user'].get('role', 'CLIENT')
+        public_key = packet['decoded']['user'].get('publicKey', '')
+
+        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(user_id, long_name=None, short_name=None, hw_model=None, is_licensed=None, role=None, public_key=None, chat_archived=None):
+    """Update or insert node information into the database, preserving unchanged fields."""
+    try:
+        ensure_node_table_exists()  # Ensure the table exists before any operation
+
+        with sqlite3.connect(config.db_file_path) as db_connection:
             db_cursor = db_connection.cursor()
+            table_name = f'"{globals.myNodeNum}_nodedb"'  # Quote in case of numeric names
 
-            # Table name construction
-            table_name = f"{str(globals.myNodeNum)}_nodedb"
-            nodeinfo_table = f'"{table_name}"'  # Quote the table name because it might begin with numerics
 
-            # Create the table if it doesn't exist
-            create_table_query = f'''
-                CREATE TABLE IF NOT EXISTS {nodeinfo_table} (
-                    user_id TEXT PRIMARY KEY,
-                    long_name TEXT,
-                    short_name TEXT,
-                    hw_model TEXT,
-                    is_licensed TEXT,
-                    role TEXT,
-                    public_key TEXT
-                )
+            table_columns = [i[1] for i in db_cursor.execute(f'PRAGMA table_info({table_name})')]
+            if "chat_archived" not in table_columns:
+                update_table_query = f"ALTER TABLE {table_name} ADD COLUMN chat_archived INTEGER"
+                db_cursor.execute(update_table_query)
+
+            # Fetch existing values to preserve unchanged fields
+            db_cursor.execute(f'SELECT * FROM {table_name} WHERE user_id = ?', (user_id,))
+            existing_record = db_cursor.fetchone()
+
+            if existing_record:
+                existing_long_name, existing_short_name, existing_hw_model, existing_is_licensed, existing_role, existing_public_key, existing_chat_archived = existing_record[1:]
+
+                long_name = long_name if long_name is not None else existing_long_name
+                short_name = short_name if short_name is not None else existing_short_name
+                hw_model = hw_model if hw_model is not None else existing_hw_model
+                is_licensed = is_licensed if is_licensed is not None else existing_is_licensed
+                role = role if role is not None else existing_role
+                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
+
+            # Upsert logic
+            upsert_query = f'''
+                INSERT INTO {table_name} (user_id, long_name, short_name, hw_model, is_licensed, role, public_key, chat_archived)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?)
+                ON CONFLICT(user_id) DO UPDATE SET
+                    long_name = excluded.long_name,
+                    short_name = excluded.short_name,
+                    hw_model = excluded.hw_model,
+                    is_licensed = excluded.is_licensed,
+                    role = excluded.role,
+                    public_key = excluded.public_key,
+                    chat_archived = excluded.chat_archived
             '''
-            db_cursor.execute(create_table_query)
-
-            # Iterate over nodes and insert them into the database
-            if globals.interface.nodes:
-                for node in globals.interface.nodes.values():
-                    role = node['user'].get('role', 'CLIENT')
-                    is_licensed = node['user'].get('isLicensed', '0')
-                    public_key = node['user'].get('publicKey', '')
-
-                    insert_query = f'''
-                        INSERT OR IGNORE INTO {nodeinfo_table} (user_id, long_name, short_name, hw_model, is_licensed, role, public_key)
-                        VALUES (?, ?, ?, ?, ?, ?, ?)
-                    '''
-
-                    db_cursor.execute(insert_query, (
-                        node['num'],
-                        node['user']['longName'],
-                        node['user']['shortName'],
-                        node['user']['hwModel'],
-                        is_licensed,
-                        role,
-                        public_key
-                    ))
-                    
+            db_cursor.execute(upsert_query, (user_id, long_name, short_name, hw_model, is_licensed, role, public_key, chat_archived))
             db_connection.commit()
 
     except sqlite3.Error as e:
-        print(f"SQLite error in init_nodedb: {e}")
+        logging.error(f"SQLite error in update_node_info_in_db: {e}")
     except Exception as e:
-        print(f"Unexpected error in init_nodedb: {e}")
+        logging.error(f"Unexpected error in update_node_info_in_db: {e}")
 
-def maybe_store_nodeinfo_in_db(packet):
-    """Save nodeinfo unless that record is already there."""
+
+def ensure_node_table_exists():
+    """Ensure the node database table exists."""
+    table_name = f'"{globals.myNodeNum}_nodedb"'  # Quote for safety
+    schema = '''
+        user_id TEXT PRIMARY KEY,
+        long_name TEXT,
+        short_name TEXT,
+        hw_model TEXT,
+        is_licensed TEXT,
+        role TEXT,
+        public_key TEXT,
+        chat_archived INTEGER
+    '''
+    ensure_table_exists(table_name, schema)
+
+
+def ensure_table_exists(table_name, schema):
+    """Ensure the given table exists in the database."""
     try:
-        with sqlite3.connect(globals.db_file_path) as db_connection:
+        with sqlite3.connect(config.db_file_path) 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)
+            db_connection.commit()
+    except sqlite3.Error as e:
+        logging.error(f"SQLite error in ensure_table_exists({table_name}): {e}")
+    except Exception as e:
+        logging.error(f"Unexpected error in ensure_table_exists({table_name}): {e}")
 
-            table_name = f"{str(globals.myNodeNum)}_nodedb"
-            nodeinfo_table = f'"{table_name}"'  # Quote the table name becuase we might begin with numerics
+
+def get_name_from_database(user_id, 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
+    """
+    try:
+        with sqlite3.connect(config.db_file_path) as db_connection:
             db_cursor = db_connection.cursor()
 
-            # Check if a record with the same user_id already exists
-            existing_record = db_cursor.execute(f'SELECT * FROM {nodeinfo_table} WHERE user_id=?', (packet['from'],)).fetchone()
+            # Construct table name
+            table_name = f"{str(globals.myNodeNum)}_nodedb"
+            nodeinfo_table = f'"{table_name}"'  # Quote table name for safety
+            
+            # Determine the correct column to fetch
+            column_name = "long_name" if type == "long" else "short_name"
 
-            if existing_record is None:
-                role = packet['decoded']['user'].get('role', 'CLIENT')
-                is_licensed = packet['decoded']['user'].get('isLicensed', '0')
-                public_key = packet['decoded']['user'].get('publicKey', '')
-
-                # No existing record, insert the new record
-                insert_query = f'''
-                    INSERT INTO {nodeinfo_table} (user_id, long_name, short_name, hw_model, is_licensed, role, public_key)
-                    VALUES (?, ?, ?, ?, ?, ?, ?)
-                '''
-
-                db_cursor.execute(insert_query, (
-                    packet['from'], 
-                    packet['decoded']['user']['longName'], 
-                    packet['decoded']['user']['shortName'], 
-                    packet['decoded']['user']['hwModel'], 
-                    is_licensed, 
-                    role, 
-                    public_key
-                ))
-
-                db_connection.commit() 
-
-            else:
-                # Check if values are different, update if necessary
-                # Extract existing values
-                existing_long_name = existing_record[1]
-                existing_short_name = existing_record[2]
-                existing_is_licensed = existing_record[4]
-                existing_role = existing_record[5]
-                existing_public_key = existing_record[6]
-
-                # Extract new values from the packet
-                new_long_name = packet['decoded']['user']['longName']
-                new_short_name = packet['decoded']['user']['shortName']
-                new_is_licensed = packet['decoded']['user'].get('isLicensed', '0')
-                new_role = packet['decoded']['user'].get('role', 'CLIENT')
-                new_public_key = packet['decoded']['user'].get('publicKey', '')
-
-                # Check for any differences
-                if (
-                    existing_long_name != new_long_name or
-                    existing_short_name != new_short_name or
-                    existing_is_licensed != new_is_licensed or
-                    existing_role != new_role or
-                    existing_public_key != new_public_key
-                ):
-                    # Perform necessary updates
-                    update_query = f'''
-                        UPDATE {nodeinfo_table}
-                        SET long_name = ?, short_name = ?, is_licensed = ?,  role = ?, public_key = ?
-                        WHERE user_id = ?
-                    '''
-                    db_cursor.execute(update_query, (
-                        new_long_name, 
-                        new_short_name, 
-                        new_is_licensed, 
-                        new_role, 
-                        new_public_key, 
-                        packet['from']
-                    ))
-
-                db_connection.commit()
-
-                    # TODO display new node name in nodelist
+            # Query the database
+            query = f"SELECT {column_name} FROM {nodeinfo_table} WHERE user_id = ?"
+            db_cursor.execute(query, (user_id,))
+            result = db_cursor.fetchone()
 
+            return result[0] if result else decimal_to_hex(user_id)
 
     except sqlite3.Error as e:
-        print(f"SQLite error in maybe_store_nodeinfo_in_db: {e}")
-    finally:
-        db_connection.close()
+        logging.error(f"SQLite error in get_name_from_database: {e}")
+        return "Unknown"
+
+    except Exception as e:
+        logging.error(f"Unexpected error in get_name_from_database: {e}")
+        return "Unknown"
+
+def is_chat_archived(user_id):
+    try:
+        with sqlite3.connect(config.db_file_path) as db_connection:
+            db_cursor = db_connection.cursor()
+            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,))
+            result = db_cursor.fetchone()
+
+            return result[0] if result else 0
+
+    except sqlite3.Error as e:
+        logging.error(f"SQLite error in is_chat_archived: {e}")
+        return "Unknown"
+
+    except Exception as e:
+        logging.error(f"Unexpected error in is_chat_archived: {e}")
+        return "Unknown"
+

default_config.py

@@ -0,0 +1,193 @@
+import logging
+import json
+import os
+
+def format_json_single_line_arrays(data, indent=4):
+    """
+    Formats JSON with arrays on a single line while keeping other elements properly indented.
+    """
+    def format_value(value, current_indent):
+        if isinstance(value, dict):
+            items = []
+            for key, val in value.items():
+                items.append(
+                    f'{" " * current_indent}"{key}": {format_value(val, current_indent + indent)}'
+                )
+            return "{\n" + ",\n".join(items) + f"\n{' ' * (current_indent - indent)}}}"
+        elif isinstance(value, list):
+            return f"[{', '.join(json.dumps(el, ensure_ascii=False) for el in value)}]"
+        else:
+            return json.dumps(value, ensure_ascii=False)
+
+    return format_value(data, indent)
+
+# Recursive function to check and update nested dictionaries
+def update_dict(default, actual):
+    updated = False
+    for key, value in default.items():
+        if key not in actual:
+            actual[key] = value
+            updated = True
+        elif isinstance(value, dict):
+            # Recursively check nested dictionaries
+            updated = update_dict(value, actual[key]) or updated
+    return updated
+
+def initialize_config():
+    app_directory = os.path.dirname(os.path.abspath(__file__))
+    json_file_path = os.path.join(app_directory, "config.json")
+
+    COLOR_CONFIG_DARK = {
+        "default": ["white", "black"],
+        "background": [" ", "black"],
+        "splash_logo": ["green", "black"],
+        "splash_text": ["white", "black"],
+        "input": ["white", "black"],
+        "node_list": ["white", "black"],
+        "channel_list": ["white", "black"],
+        "channel_selected": ["green", "black"],
+        "rx_messages": ["cyan", "black"],
+        "tx_messages": ["green", "black"],
+        "timestamps": ["white", "black"],
+        "commands": ["white", "black"],
+        "window_frame": ["white", "black"],
+        "window_frame_selected": ["green", "black"],
+        "log_header": ["blue", "black"],
+        "log": ["green", "black"],
+        "settings_default": ["white", "black"],
+        "settings_sensitive": ["red", "black"],
+        "settings_save": ["green", "black"],
+        "settings_breadcrumbs": ["white", "black"]
+    }
+
+    COLOR_CONFIG_LIGHT = {
+        "default": ["black", "white"],
+        "background": [" ", "white"],
+        "splash_logo": ["green", "white"],
+        "splash_text": ["black", "white"],
+        "input": ["black", "white"],
+        "node_list": ["black", "white"],
+        "channel_list": ["black", "white"],
+        "channel_selected": ["green", "white"],
+        "rx_messages": ["cyan", "white"],
+        "tx_messages": ["green", "white"],
+        "timestamps": ["black", "white"],
+        "commands": ["black", "white"],
+        "window_frame": ["black", "white"],
+        "window_frame_selected": ["green", "white"],
+        "log_header": ["black", "white"],
+        "log": ["blue", "white"],
+        "settings_default": ["black", "white"],
+        "settings_sensitive": ["red", "white"],
+        "settings_save": ["green", "white"],
+        "settings_breadcrumbs": ["black", "white"]
+    }
+    COLOR_CONFIG_GREEN = {
+        "default": ["green", "black"],
+        "background": [" ", "black"],
+        "splash_logo": ["green", "black"],
+        "splash_text": ["green", "black"],
+        "input": ["green", "black"],
+        "node_list": ["green", "black"],
+        "channel_list": ["green", "black"],
+        "channel_selected": ["cyan", "black"],
+        "rx_messages": ["green", "black"],
+        "tx_messages": ["green", "black"],
+        "timestamps": ["green", "black"],
+        "commands": ["green", "black"],
+        "window_frame": ["green", "black"],
+        "window_frame_selected": ["cyan", "black"],
+        "log_header": ["green", "black"],
+        "log": ["green", "black"],
+        "settings_default": ["green", "black"],
+        "settings_sensitive": ["green", "black"],
+        "settings_save": ["green", "black"],
+        "settings_breadcrumbs": ["green", "black"]
+    }
+
+    default_config_variables = {
+        "db_file_path": os.path.join(app_directory, "client.db"),
+        "log_file_path": os.path.join(app_directory, "client.log"),
+        "message_prefix": ">>",
+        "sent_message_prefix": ">> Sent",
+        "notification_symbol": "*",
+        "ack_implicit_str": "[◌]",
+        "ack_str": "[✓]",
+        "nak_str": "[x]",
+        "ack_unknown_str": "[…]",
+        "node_sort": "lastHeard",
+        "theme": "dark",
+        "COLOR_CONFIG_DARK": COLOR_CONFIG_DARK,
+        "COLOR_CONFIG_LIGHT": COLOR_CONFIG_LIGHT,
+        "COLOR_CONFIG_GREEN": COLOR_CONFIG_GREEN
+    }
+
+    if not os.path.exists(json_file_path):
+        with open(json_file_path, "w", encoding="utf-8") as json_file:
+            formatted_json = format_json_single_line_arrays(default_config_variables)
+            json_file.write(formatted_json)
+
+    # Ensure all default variables exist in the JSON file
+    with open(json_file_path, "r", encoding="utf-8") as json_file:
+        loaded_config = json.load(json_file)
+
+    # Check and add missing variables
+    updated = update_dict(default_config_variables, loaded_config)
+
+    # Update the JSON file if any variables were missing
+    if updated:
+            formatted_json = format_json_single_line_arrays(loaded_config)
+            with open(json_file_path, "w", encoding="utf-8") as json_file:
+                json_file.write(formatted_json)
+            logging.info(f"JSON file updated with missing default variables and COLOR_CONFIG items.")
+
+    return loaded_config
+
+def assign_config_variables(loaded_config):
+    # Assign values to local variables
+    
+    global db_file_path, log_file_path, message_prefix, sent_message_prefix
+    global notification_symbol, ack_implicit_str, ack_str, nak_str, ack_unknown_str
+    global theme, COLOR_CONFIG
+    global node_sort
+
+    db_file_path = loaded_config["db_file_path"]
+    log_file_path = loaded_config["log_file_path"]
+    message_prefix = loaded_config["message_prefix"]
+    sent_message_prefix = loaded_config["sent_message_prefix"]
+    notification_symbol = loaded_config["notification_symbol"]
+    ack_implicit_str = loaded_config["ack_implicit_str"]
+    ack_str = loaded_config["ack_str"]
+    nak_str = loaded_config["nak_str"]
+    ack_unknown_str = loaded_config["ack_unknown_str"]
+    theme = loaded_config["theme"]
+    if theme == "dark":
+        COLOR_CONFIG = loaded_config["COLOR_CONFIG_DARK"]
+    elif theme == "light":
+        COLOR_CONFIG = loaded_config["COLOR_CONFIG_LIGHT"]
+    elif theme == "green":
+        COLOR_CONFIG = loaded_config["COLOR_CONFIG_GREEN"]
+    node_sort = loaded_config["node_sort"]
+
+
+# Call the function when the script is imported
+loaded_config = initialize_config()
+assign_config_variables(loaded_config)
+
+if __name__ == "__main__":
+    logging.basicConfig(
+    filename="default_config.log",
+    level=logging.INFO,  # DEBUG, INFO, WARNING, ERROR, CRITICAL)
+    format="%(asctime)s - %(levelname)s - %(message)s"
+    )
+    print("\nLoaded Configuration:")
+    print(f"Database File Path: {db_file_path}")
+    print(f"Log File Path: {log_file_path}")
+    print(f"Message Prefix: {message_prefix}")
+    print(f"Sent Message Prefix: {sent_message_prefix}")
+    print(f"Notification Symbol: {notification_symbol}")
+    print(f"ACK Implicit String: {ack_implicit_str}")
+    print(f"ACK String: {ack_str}")
+    print(f"NAK String: {nak_str}")
+    print(f"ACK Unknown String: {ack_unknown_str}")
+    print(f"Color Config: {COLOR_CONFIG}")

globals.py

@@ -1,12 +1,8 @@
-import os
-
-# App Variables
-app_directory = os.path.dirname(os.path.abspath(__file__))
 interface = None
 display_log = False
 all_messages = {}
 channel_list = []
-notifications = set()
+notifications = []
 packet_buffer = []
 node_list = []
 myNodeNum = 0
@@ -14,14 +10,4 @@ selected_channel = 0
 selected_message = 0
 selected_node = 0
 current_window = 0
-
-# User Configurable
-db_file_path = os.path.join(app_directory, "client.db")
-log_file_path = os.path.join(app_directory, "client.log")
-message_prefix = ">>"
-sent_message_prefix = message_prefix + " Sent"
-notification_symbol = "*"
-ack_implicit_str = "[◌]"
-ack_str = "[✓]"
-nak_str = "[x]"
-ack_unknown_str = "[…]"
+lock = None

input_handlers.py

@@ -1,7 +1,8 @@
 import curses
 import ipaddress
+from ui.colors import get_color
 
-def get_user_input(prompt):
+def get_text_input(prompt):
     # Calculate the dynamic height and width for the input window
     height = 7  # Fixed height for input prompt
     width = 60
@@ -10,74 +11,49 @@ def get_user_input(prompt):
 
     # Create a new window for user input
     input_win = curses.newwin(height, width, start_y, start_x)
+    input_win.bkgd(get_color("background"))
+    input_win.attrset(get_color("window_frame"))
     input_win.border()
 
     # Display the prompt
-    input_win.addstr(1, 2, prompt, curses.A_BOLD)
-    input_win.addstr(3, 2, "Enter value: ")
+    input_win.addstr(1, 2, prompt, get_color("settings_default", bold=True))
+    input_win.addstr(3, 2, "Enter value: ", get_color("settings_default"))
     input_win.refresh()
 
+    # Check if "shortName" is in the prompt, and set max length accordingly
+    max_length = 4 if "shortName" in prompt else None
+
     curses.curs_set(1)
 
     user_input = ""
+    input_position = (3, 15)  # Tuple for row and column
+    row, col = input_position  # Unpack tuple
     while True:
-        key = input_win.getch(3, 15 + len(user_input))  # Adjust cursor position dynamically
-        if key == 27 or key == curses.KEY_LEFT:  # ESC or Left Arrow
+        key = input_win.get_wch(row, col + len(user_input))  # Adjust cursor position dynamically
+        if key == chr(27) or key == curses.KEY_LEFT:  # ESC or Left Arrow
             curses.curs_set(0)
             return None  # Exit without returning a value
-        elif key == ord('\n'):  # Enter key
+        elif key in (chr(curses.KEY_ENTER), chr(10), chr(13)):
             break
-        elif key == curses.KEY_BACKSPACE or key == 127:  # Backspace
+        elif key in (curses.KEY_BACKSPACE, chr(127)):  # Backspace
             user_input = user_input[:-1]
-            input_win.addstr(3, 15, " " * (len(user_input) + 1))  # Clear the line
-            input_win.addstr(3, 15, user_input)
-        else:
-            user_input += chr(key)
-            input_win.addstr(3, 15, user_input)
+            input_win.addstr(row, col, " " * (len(user_input) + 1), get_color("settings_default"))  # Clear the line
+            input_win.addstr(row, col, user_input, get_color("settings_default"))
+        elif max_length is None or len(user_input) < max_length:  # Enforce max length if applicable
+            # Append typed character to input text
+            if(isinstance(key, str)):
+                user_input += key
+            else:
+                user_input += chr(key)
+            input_win.addstr(3, 15, user_input, get_color("settings_default"))
 
     curses.curs_set(0)
 
     # Clear the input window
-    input_win.clear()
+    input_win.erase()
     input_win.refresh()
     return user_input
 
-def get_bool_selection(message, current_value):
-    message = "Select True or False:" if None else message
-    cvalue = current_value
-    options = ["True", "False"]
-    selected_index = 0 if current_value == "True" else 1
-
-    height = 7
-    width = 60
-    start_y = (curses.LINES - height) // 2
-    start_x = (curses.COLS - width) // 2
-
-    bool_win = curses.newwin(height, width, start_y, start_x)
-    bool_win.keypad(True)
-
-    while True:
-        bool_win.clear()
-        bool_win.border()
-        bool_win.addstr(1, 2, message, curses.A_BOLD)
-
-        for idx, option in enumerate(options):
-            if idx == selected_index:
-                bool_win.addstr(idx + 3, 4, option, curses.A_REVERSE)
-            else:
-                bool_win.addstr(idx + 3, 4, option)
-
-        bool_win.refresh()
-        key = bool_win.getch()
-
-        if key == curses.KEY_UP:
-            selected_index = max(0, selected_index - 1)
-        elif key == curses.KEY_DOWN:
-            selected_index = min(len(options) - 1, selected_index + 1)
-        elif key == ord('\n'):  # Enter key
-            return options[selected_index]
-        elif key == 27 or key == curses.KEY_LEFT:  # ESC or Left Arrow
-            return cvalue
 
 def get_repeated_input(current_value):
     cvalue = current_value
@@ -87,6 +63,8 @@ def get_repeated_input(current_value):
     start_x = (curses.COLS - width) // 2
 
     repeated_win = curses.newwin(height, width, start_y, start_x)
+    repeated_win.bkgd(get_color("background"))
+    repeated_win.attrset(get_color("window_frame"))
     repeated_win.keypad(True)  # Enable keypad for special keys
 
     curses.echo()
@@ -94,11 +72,11 @@ def get_repeated_input(current_value):
     user_input = ""
 
     while True:
-        repeated_win.clear()
+        repeated_win.erase()
         repeated_win.border()
-        repeated_win.addstr(1, 2, "Enter comma-separated values:", curses.A_BOLD)
-        repeated_win.addstr(3, 2, f"Current: {', '.join(map(str, current_value))}")
-        repeated_win.addstr(5, 2, f"New value: {user_input}")
+        repeated_win.addstr(1, 2, "Enter comma-separated values:", get_color("settings_default", bold=True))
+        repeated_win.addstr(3, 2, f"Current: {', '.join(map(str, current_value))}", get_color("settings_default"))
+        repeated_win.addstr(5, 2, f"New value: {user_input}", get_color("settings_default"))
         repeated_win.refresh()
 
         key = repeated_win.getch()
@@ -119,40 +97,6 @@ def get_repeated_input(current_value):
             except ValueError:
                 pass  # Ignore invalid character inputs
 
-def get_enum_input(options, current_value):
-    selected_index = options.index(current_value) if current_value in options else 0
-
-    height = min(len(options) + 4, curses.LINES - 2)
-    width = 60
-    start_y = (curses.LINES - height) // 2
-    start_x = (curses.COLS - width) // 2
-
-    enum_win = curses.newwin(height, width, start_y, start_x)
-    enum_win.keypad(True)
-
-    while True:
-        enum_win.clear()
-        enum_win.border()
-        enum_win.addstr(1, 2, "Select an option:", curses.A_BOLD)
-
-        for idx, option in enumerate(options):
-            if idx == selected_index:
-                enum_win.addstr(idx + 2, 4, option, curses.A_REVERSE)
-            else:
-                enum_win.addstr(idx + 2, 4, option)
-
-        enum_win.refresh()
-        key = enum_win.getch()
-
-        if key == curses.KEY_UP:
-            selected_index = max(0, selected_index - 1)
-        elif key == curses.KEY_DOWN:
-            selected_index = min(len(options) - 1, selected_index + 1)
-        elif key == ord('\n'):  # Enter key
-            return options[selected_index]
-        elif key == 27 or key == curses.KEY_LEFT:  # ESC or Left Arrow
-            return current_value
-        
 
 def get_fixed32_input(current_value):
     cvalue = current_value
@@ -163,6 +107,8 @@ def get_fixed32_input(current_value):
     start_x = (curses.COLS - width) // 2
 
     fixed32_win = curses.newwin(height, width, start_y, start_x)
+    fixed32_win.bkgd(get_color("background"))
+    fixed32_win.attrset(get_color("window_frame"))
     fixed32_win.keypad(True)
 
     curses.echo()
@@ -170,7 +116,7 @@ def get_fixed32_input(current_value):
     user_input = ""
 
     while True:
-        fixed32_win.clear()
+        fixed32_win.erase()
         fixed32_win.border()
         fixed32_win.addstr(1, 2, "Enter an IP address (xxx.xxx.xxx.xxx):", curses.A_BOLD)
         fixed32_win.addstr(3, 2, f"Current: {current_value}")
@@ -204,4 +150,76 @@ def get_fixed32_input(current_value):
                 if char.isdigit() or char == ".":
                     user_input += char  # Append only valid characters (digits or dots)
             except ValueError:
-                pass  # Ignore invalid inputs
+                pass  # Ignore invalid inputs
+
+
+def get_list_input(prompt, current_option, list_options):
+    """
+    Displays a scrollable list of list_options for the user to choose from.
+    """
+    selected_index = list_options.index(current_option) if current_option in list_options else 0
+
+    height = min(len(list_options) + 5, curses.LINES - 2)
+    width = 60
+    start_y = (curses.LINES - height) // 2
+    start_x = (curses.COLS - width) // 2
+
+    list_win = curses.newwin(height, width, start_y, start_x)
+    list_win.bkgd(get_color("background"))
+    list_win.attrset(get_color("window_frame"))
+    list_win.keypad(True)
+
+    list_pad = curses.newpad(len(list_options) + 1, width - 8)
+    list_pad.bkgd(get_color("background"))
+
+    # Render header
+    list_win.erase()
+    list_win.border()
+    list_win.addstr(1, 2, prompt, get_color("settings_default", bold=True))
+
+    # Render options on the pad
+    for idx, color in enumerate(list_options):
+        if idx == selected_index:
+            list_pad.addstr(idx, 0, color.ljust(width - 8), get_color("settings_default", reverse=True))
+        else:
+            list_pad.addstr(idx, 0, color.ljust(width - 8), get_color("settings_default"))
+
+    # Initial refresh
+    list_win.refresh()
+    list_pad.refresh(0, 0,
+                    list_win.getbegyx()[0] + 3, list_win.getbegyx()[1] + 4,
+                    list_win.getbegyx()[0] + list_win.getmaxyx()[0] - 2, list_win.getbegyx()[1] + list_win.getmaxyx()[1] - 4)
+
+    while True:
+        key = list_win.getch()
+
+        if key == curses.KEY_UP:
+            old_selected_index = selected_index
+            selected_index = max(0, selected_index - 1)
+            move_highlight(old_selected_index, selected_index, list_options, list_win, list_pad)
+        elif key == curses.KEY_DOWN:
+            old_selected_index = selected_index
+            selected_index = min(len(list_options) - 1, selected_index + 1)
+            move_highlight(old_selected_index, selected_index, list_options, list_win, list_pad)
+        elif key == ord('\n'):  # Enter key
+            return list_options[selected_index]
+        elif key == 27 or key == curses.KEY_LEFT:  # ESC or Left Arrow
+            return current_option
+
+
+def move_highlight(old_idx, new_idx, options, list_win, list_pad):
+    if old_idx == new_idx:
+        return # no-op
+
+    list_pad.chgat(old_idx, 0, list_pad.getmaxyx()[1], get_color("settings_default"))
+    list_pad.chgat(new_idx, 0, list_pad.getmaxyx()[1], get_color("settings_default", reverse = True))
+
+    list_win.refresh()
+
+    start_index = max(0, new_idx - (list_win.getmaxyx()[0] - 4))
+
+    list_win.refresh()
+    list_pad.refresh(start_index, 0,
+                     list_win.getbegyx()[0] + 3, list_win.getbegyx()[1] + 4,
+                     list_win.getbegyx()[0] + list_win.getmaxyx()[0] - 2, list_win.getbegyx()[1] + 4 + list_win.getmaxyx()[1] - 4)
+    

main.py

@@ -3,7 +3,7 @@
 '''
 Contact - A Console UI for Meshtastic by http://github.com/pdxlocations
 Powered by Meshtastic.org
-V 1.0.3
+V 1.2.1
 '''
 
 import curses
@@ -11,40 +11,62 @@ from pubsub import pub
 import os
 import logging
 import traceback
+import threading
 
 from utilities.arg_parser import setup_parser
 from utilities.interfaces import initialize_interface
 from message_handlers.rx_handler import on_receive
 from ui.curses_ui import main_ui, draw_splash
+from input_handlers import get_list_input
 from utilities.utils import get_channels, get_node_list, get_nodeNum
+from settings import set_region
 from db_handler import init_nodedb, load_messages_from_db
+import default_config as config
 import globals
 
-# Set environment variables for ncurses compatibility
+import os
+
+# Set ncurses compatibility settings
 os.environ["NCURSES_NO_UTF8_ACS"] = "1"
-os.environ["TERM"] = "screen"
 os.environ["LANG"] = "C.UTF-8"
+os.environ.setdefault("TERM", "xterm-256color")
+if os.environ.get("COLORTERM") == "gnome-terminal":
+    os.environ["TERM"] = "xterm-256color"
 
 # Configure logging
 # Run `tail -f client.log` in another terminal to view live
 logging.basicConfig(
-    filename=globals.log_file_path,
+    filename=config.log_file_path,
     level=logging.INFO,  # DEBUG, INFO, WARNING, ERROR, CRITICAL)
     format="%(asctime)s - %(levelname)s - %(message)s"
 )
 
+globals.lock = threading.Lock()
+
 def main(stdscr):
     try:
         draw_splash(stdscr)
         parser = setup_parser()
         args = parser.parse_args()
-        globals.interface = initialize_interface(args)
-        globals.myNodeNum = get_nodeNum()
-        globals.channel_list = get_channels()
-        globals.node_list = get_node_list()
-        pub.subscribe(on_receive, 'meshtastic.receive')
-        init_nodedb()
-        load_messages_from_db()
+
+        logging.info("Initializing interface %s", args)
+        with globals.lock: 
+            globals.interface = initialize_interface(args)
+            if globals.interface.localNode.localConfig.lora.region == 0:
+                confirmation = get_list_input("Your region is UNSET.  Set it now?", "Yes",  ["Yes", "No"])
+                if confirmation == "Yes":
+                    set_region()
+                    globals.interface.close()
+                    globals.interface = initialize_interface(args)
+            logging.info("Interface initialized")
+            globals.myNodeNum = get_nodeNum()
+            globals.channel_list = get_channels()
+            globals.node_list = get_node_list()
+            pub.subscribe(on_receive, 'meshtastic.receive')
+            init_nodedb()
+            load_messages_from_db()
+            logging.info("Starting main UI")
+            
         main_ui(stdscr)
     except Exception as e:
         logging.error("An error occurred: %s", e)

message_handlers/rx_handler.py

@@ -1,101 +1,105 @@
-from meshtastic import BROADCAST_NUM
-from utilities.utils import get_node_list, decimal_to_hex, get_name_from_number
-import globals
+import logging
+import time
+from utilities.utils import refresh_node_list
+from datetime import datetime
 from ui.curses_ui import draw_packetlog_win, draw_node_list, draw_messages_window, draw_channel_list, add_notification
-from db_handler import save_message_to_db, maybe_store_nodeinfo_in_db
+from db_handler import save_message_to_db, maybe_store_nodeinfo_in_db, get_name_from_database, update_node_info_in_db
+import default_config as config
+import globals
 
 
 from datetime import datetime
 
 def on_receive(packet, interface):
-    global nodes_win
 
-    # Update packet log
-    globals.packet_buffer.append(packet)
-    if len(globals.packet_buffer) > 20:
-        # Trim buffer to 20 packets
-        globals.packet_buffer = globals.packet_buffer[-20:]
-        
-    if globals.display_log:
-        draw_packetlog_win()
-    try:
-        if 'decoded' not in packet:
-            return
+    with globals.lock:
+        # Update packet log
+        globals.packet_buffer.append(packet)
+        if len(globals.packet_buffer) > 20:
+            # Trim buffer to 20 packets
+            globals.packet_buffer = globals.packet_buffer[-20:]
+            
+        if globals.display_log:
+            draw_packetlog_win()
+        try:
+            if 'decoded' not in packet:
+                return
 
-        # Assume any incoming packet could update the last seen time for a node
-        new_node_list = get_node_list()
-        if new_node_list != globals.node_list:
-            globals.node_list = new_node_list
-            draw_node_list()
+            # Assume any incoming packet could update the last seen time for a node
+            changed = refresh_node_list()
+            if(changed):
+                draw_node_list()
 
-        if packet['decoded']['portnum'] == 'NODEINFO_APP':
-            if "user" in packet['decoded'] and "longName" in packet['decoded']["user"]: 
-                maybe_store_nodeinfo_in_db(packet)
+            if packet['decoded']['portnum'] == 'NODEINFO_APP':
+                if "user" in packet['decoded'] and "longName" in packet['decoded']["user"]: 
+                    maybe_store_nodeinfo_in_db(packet)
 
-        elif packet['decoded']['portnum'] == 'TEXT_MESSAGE_APP':
-            message_bytes = packet['decoded']['payload']
-            message_string = message_bytes.decode('utf-8')
+            elif packet['decoded']['portnum'] == 'TEXT_MESSAGE_APP':
+                message_bytes = packet['decoded']['payload']
+                message_string = message_bytes.decode('utf-8')
 
-            refresh_channels = False
-            refresh_messages = False
+                refresh_channels = False
+                refresh_messages = False
 
-            if packet.get('channel'):
-                channel_number = packet['channel']
-            else:
-                channel_number = 0
-
-            if packet['to'] == globals.myNodeNum:
-                if packet['from'] in globals.channel_list:
-                    pass
+                if packet.get('channel'):
+                    channel_number = packet['channel']
                 else:
-                    globals.channel_list.append(packet['from'])
-                    globals.all_messages[packet['from']] = []
+                    channel_number = 0
+
+                if packet['to'] == globals.myNodeNum:
+                    if packet['from'] in globals.channel_list:
+                        pass
+                    else:
+                        globals.channel_list.append(packet['from'])
+                        if(packet['from'] not in globals.all_messages):
+                            globals.all_messages[packet['from']] = []
+                        update_node_info_in_db(packet['from'], chat_archived=False)
+                        refresh_channels = True
+
+                    channel_number = globals.channel_list.index(packet['from'])
+
+                if globals.channel_list[channel_number] != globals.channel_list[globals.selected_channel]:
+                    add_notification(channel_number)
                     refresh_channels = True
+                else:
+                    refresh_messages = True
 
-                channel_number = globals.channel_list.index(packet['from'])
+                # Add received message to the messages list
+                message_from_id = packet['from']
+                message_from_string = get_name_from_database(message_from_id, type='short') + ":"
 
-            if globals.channel_list[channel_number] != globals.channel_list[globals.selected_channel]:
-                add_notification(channel_number)
-                refresh_channels = True
-            else:
-                refresh_messages = True
+                if globals.channel_list[channel_number] not in globals.all_messages:
+                    globals.all_messages[globals.channel_list[channel_number]] = []
 
-            # Add received message to the messages list
-            message_from_id = packet['from']
-            message_from_string = get_name_from_number(message_from_id, type='short') + ":"
+                # Timestamp handling
+                current_timestamp = time.time() 
+                current_hour = datetime.fromtimestamp(current_timestamp).strftime('%Y-%m-%d %H:00')
 
-            if globals.channel_list[channel_number] not in globals.all_messages:
-                globals.all_messages[globals.channel_list[channel_number]] = []
-
-            # Timestamp handling
-            current_timestamp = int(packet['rxTime'])  # Use the packet's rxTime for timestamp
-            current_hour = datetime.fromtimestamp(current_timestamp).strftime('%Y-%m-%d %H:00')
-
-            # Retrieve the last timestamp if available
-            channel_messages = globals.all_messages[globals.channel_list[channel_number]]
-            if channel_messages:
-                # Check the last entry for a timestamp
-                for entry in reversed(channel_messages):
-                    if entry[0].startswith("--"):
-                        last_hour = entry[0].strip("- ").strip()
-                        break
+                # Retrieve the last timestamp if available
+                channel_messages = globals.all_messages[globals.channel_list[channel_number]]
+                if channel_messages:
+                    # Check the last entry for a timestamp
+                    for entry in reversed(channel_messages):
+                        if entry[0].startswith("--"):
+                            last_hour = entry[0].strip("- ").strip()
+                            break
+                    else:
+                        last_hour = None
                 else:
                     last_hour = None
-            else:
-                last_hour = None
 
-            # Add a new timestamp if it's a new hour
-            if last_hour != current_hour:
-                globals.all_messages[globals.channel_list[channel_number]].append((f"-- {current_hour} --", ""))
+                # Add a new timestamp if it's a new hour
+                if last_hour != current_hour:
+                    globals.all_messages[globals.channel_list[channel_number]].append((f"-- {current_hour} --", ""))
 
-            globals.all_messages[globals.channel_list[channel_number]].append((f"{globals.message_prefix} {message_from_string} ", message_string))
+                globals.all_messages[globals.channel_list[channel_number]].append((f"{config.message_prefix} {message_from_string} ", message_string))
 
-            if refresh_channels:
-                draw_channel_list()
-            if refresh_messages:
-                draw_messages_window(True)
+                if refresh_channels:
+                    draw_channel_list()
+                if refresh_messages:
+                    draw_messages_window(True)
 
-            save_message_to_db(globals.channel_list[channel_number], message_from_id, message_string)
+                save_message_to_db(globals.channel_list[channel_number], message_from_id, message_string)
 
-    except KeyError as e:
-        print(f"Error processing packet: {e}")
+        except KeyError as e:
+            logging.error(f"Error processing packet: {e}")

message_handlers/tx_handler.py

@@ -1,10 +1,11 @@
 from datetime import datetime
-from meshtastic import BROADCAST_NUM
-from db_handler import save_message_to_db, update_ack_nak
-from meshtastic.protobuf import mesh_pb2, portnums_pb2
-from utilities.utils import get_name_from_number
-import globals
 import google.protobuf.json_format
+from meshtastic import BROADCAST_NUM
+from meshtastic.protobuf import mesh_pb2, portnums_pb2
+
+from db_handler import save_message_to_db, update_ack_nak, get_name_from_database, is_chat_archived, update_node_info_in_db
+import default_config as config
+import globals
 
 ack_naks = {}
 
@@ -23,16 +24,16 @@ def onAckNak(packet):
     ack_type = None
     if(packet['decoded']['routing']['errorReason'] == "NONE"):
         if(packet['from'] == globals.myNodeNum): # Ack "from" ourself means implicit ACK
-            confirm_string = globals.ack_implicit_str
+            confirm_string = config.ack_implicit_str
             ack_type = "Implicit"
         else:
-            confirm_string = globals.ack_str
+            confirm_string = config.ack_str
             ack_type = "Ack"
     else:
-        confirm_string = globals.nak_str
+        confirm_string = config.nak_str
         ack_type = "Nak"
 
-    globals.all_messages[acknak['channel']][acknak['messageIndex']] = (globals.sent_message_prefix + confirm_string + ": ", message)
+    globals.all_messages[acknak['channel']][acknak['messageIndex']] = (config.sent_message_prefix + confirm_string + ": ", message)
 
     update_ack_nak(acknak['channel'], acknak['timestamp'], message, ack_type)
 
@@ -55,18 +56,18 @@ def on_response_traceroute(packet):
 
     msg_str = "Traceroute to:\n"
 
-    route_str = get_name_from_number(packet["to"], 'short') or f"{packet['to']:08x}" # Start with destination of response
+    route_str = get_name_from_database(packet["to"], 'short') or f"{packet['to']:08x}" # Start with destination of response
 
     # SNR list should have one more entry than the route, as the final destination adds its SNR also
     lenTowards = 0 if "route" not in msg_dict else len(msg_dict["route"])
     snrTowardsValid = "snrTowards" in msg_dict and len(msg_dict["snrTowards"]) == lenTowards + 1
     if lenTowards > 0: # Loop through hops in route and add SNR if available
         for idx, node_num in enumerate(msg_dict["route"]):
-            route_str += " --> " + (get_name_from_number(node_num, '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_number(packet["from"], '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
@@ -76,15 +77,15 @@ def on_response_traceroute(packet):
     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_number(packet["from"], 'short') or f"{packet['from']:08x}" # Start with origin of response
+        route_str = get_name_from_database(packet["from"], 'short') or f"{packet['from']:08x}" # Start with origin of response
 
         if lenBack > 0: # Loop through hops in routeBack and add SNR if available
             for idx, node_num in enumerate(msg_dict["routeBack"]):
-                route_str += " --> " + (get_name_from_number(node_num, '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_number(packet["to"], '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
@@ -93,6 +94,9 @@ def on_response_traceroute(packet):
         globals.channel_list.append(packet['from'])
         refresh_channels = True
 
+    if(is_chat_archived(packet['from'])):
+        update_node_info_in_db(packet['from'], chat_archived=False)
+
     channel_number = globals.channel_list.index(packet['from'])
 
     if globals.channel_list[channel_number] == globals.channel_list[globals.selected_channel]:
@@ -101,11 +105,11 @@ def on_response_traceroute(packet):
         add_notification(channel_number)
         refresh_channels = True
 
-    message_from_string = get_name_from_number(packet['from'], type='short') + ":\n"
+    message_from_string = get_name_from_database(packet['from'], type='short') + ":\n"
 
     if globals.channel_list[channel_number] not in globals.all_messages:
         globals.all_messages[globals.channel_list[channel_number]] = []
-    globals.all_messages[globals.channel_list[channel_number]].append((f"{globals.message_prefix} {message_from_string}", msg_str))
+    globals.all_messages[globals.channel_list[channel_number]].append((f"{config.message_prefix} {message_from_string}", msg_str))
 
     if refresh_channels:
         draw_channel_list()
@@ -158,7 +162,7 @@ def send_message(message, destination=BROADCAST_NUM, channel=0):
     if last_hour != current_hour:
         globals.all_messages[channel_id].append((f"-- {current_hour} --", ""))
 
-    globals.all_messages[channel_id].append((globals.sent_message_prefix + globals.ack_unknown_str + ": ", message))
+    globals.all_messages[channel_id].append((config.sent_message_prefix + config.ack_unknown_str + ": ", message))
 
     timestamp = save_message_to_db(channel_id, myid, message)
 

save_to_radio.py

@@ -2,24 +2,8 @@ from meshtastic.protobuf import channel_pb2
 from google.protobuf.message import Message
 import logging
 import base64
-
-def settings_reboot(interface):
-    interface.localNode.reboot()
-
-def settings_reset_nodedb(interface):
-    interface.localNode.resetNodeDb()
-
-def settings_shutdown(interface):
-    interface.localNode.shutdown()
-
-def settings_factory_reset(interface):
-    interface.localNode.factoryReset()
-
-def settings_set_owner(interface, long_name=None, short_name=None, is_licensed=False):
-    if isinstance(is_licensed, str):
-        is_licensed = is_licensed.lower() == 'true'
-    interface.localNode.setOwner(long_name, short_name, is_licensed)
-
+from db_handler import update_node_info_in_db
+import globals
 
 def save_changes(interface, menu_path, modified_settings):
     """
@@ -38,13 +22,29 @@ def save_changes(interface, menu_path, modified_settings):
         if menu_path[1] ==  "Radio Settings" or menu_path[1] == "Module Settings":
             config_category = menu_path[2].lower() # for radio and module configs
 
-        elif menu_path[1] == "User Settings": # for user configs
-            config_category = "User Settings" 
+            if {'latitude', 'longitude', 'altitude'} & modified_settings.keys():
+                lat = float(modified_settings.get('latitude', 0.0))
+                lon = float(modified_settings.get('longitude', 0.0))
+                alt = int(modified_settings.get('altitude', 0))
+
+                interface.localNode.setFixedPosition(lat, lon, alt)
+                logging.info(f"Updated {config_category} with Latitude: {lat} and Longitude {lon} and Altitude {alt}")
+                return
+
+        elif menu_path[1] == "User Settings":  # for user configs
+            config_category = "User Settings"
             long_name = modified_settings.get("longName")
             short_name = modified_settings.get("shortName")
             is_licensed = modified_settings.get("isLicensed")
+            is_licensed = is_licensed == "True" or is_licensed is True  # Normalize boolean
+
             node.setOwner(long_name, short_name, is_licensed)
-            logging.info(f"Updated {config_category} with Long Name: {long_name} and Short Name {short_name} and Licensed Mode {is_licensed}")
+
+            # Update only the changed fields and preserve others
+            update_node_info_in_db(globals.myNodeNum, long_name=long_name, short_name=short_name, is_licensed=is_licensed)
+
+            logging.info(f"Updated {config_category} with Long Name: {long_name}, Short Name: {short_name}, Licensed Mode: {is_licensed}")
+
             return
         
         elif menu_path[1] == "Channels":    # for channel configs
@@ -52,7 +52,7 @@ def save_changes(interface, menu_path, modified_settings):
 
             try:
                 channel = menu_path[-1]
-                channel_num = int(channel.split()[-1])
+                channel_num = int(channel.split()[-1]) - 1
             except (IndexError, ValueError) as e:
                 channel_num = None
 

settings.py

@@ -1,35 +1,46 @@
 import curses
 import logging
+import os
 
-from save_to_radio import settings_factory_reset, settings_reboot, settings_reset_nodedb, settings_shutdown, save_changes
+from save_to_radio import save_changes
+from utilities.config_io import config_export, config_import
+from input_handlers import get_repeated_input, get_text_input, get_fixed32_input, get_list_input
 from ui.menus import generate_menu_from_protobuf
-from input_handlers import get_bool_selection, get_repeated_input, get_user_input, get_enum_input, get_fixed32_input
-from ui.colors import setup_colors
+from ui.colors import setup_colors, get_color
 from utilities.arg_parser import setup_parser
 from utilities.interfaces import initialize_interface
+from ui.dialog import dialog
+from user_config import json_editor
 import globals
 
+width = 60
+save_option = "Save Changes"
+sensitive_settings = ["Reboot", "Reset Node DB", "Shutdown", "Factory Reset"]
+
 def display_menu(current_menu, menu_path, selected_index, show_save_option):
-    global menu_win
 
     # Calculate the dynamic height based on the number of menu items
     num_items = len(current_menu) + (1 if show_save_option else 0)  # Add 1 for the "Save Changes" option if applicable
     height = min(curses.LINES - 2, num_items + 5)  # Ensure the menu fits within the terminal height
-    width = 60
     start_y = (curses.LINES - height) // 2
     start_x = (curses.COLS - width) // 2
 
     # Create a new curses window with dynamic dimensions
     menu_win = curses.newwin(height, width, start_y, start_x)
-    menu_win.clear()
+    menu_win.erase()
+    menu_win.bkgd(get_color("background"))
+    menu_win.attrset(get_color("window_frame"))
     menu_win.border()
     menu_win.keypad(True)
 
+    menu_pad = curses.newpad(len(current_menu) + 1, width - 8)
+    menu_pad.bkgd(get_color("background"))
+
     # Display the current menu path as a header
     header = " > ".join(word.title() for word in menu_path)
     if len(header) > width - 4:
         header = header[:width - 7] + "..."
-    menu_win.addstr(1, 2, header, curses.A_BOLD)
+    menu_win.addstr(1, 2, header, get_color("settings_breadcrumbs", bold=True))
 
     # Display the menu options
     for idx, option in enumerate(current_menu):
@@ -40,60 +51,105 @@ def display_menu(current_menu, menu_path, selected_index, show_save_option):
 
         try:
             # Use red color for "Reboot" or "Shutdown"
-            color = curses.color_pair(5) if option in ["Reboot", "Reset Node DB", "Shutdown", "Factory Reset"] else curses.color_pair(1)
-
-            if idx == selected_index:
-                menu_win.addstr(idx + 3, 4, f"{display_option:<{width // 2 - 2}} {display_value}", curses.A_REVERSE | color)
-            else:
-                menu_win.addstr(idx + 3, 4, f"{display_option:<{width // 2 - 2}} {display_value}", color)
+            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
 
     # Show save option if applicable
     if show_save_option:
-        save_option = "Save Changes"
         save_position = height - 2
-        if selected_index == len(current_menu):
-            menu_win.addstr(save_position, (width - len(save_option)) // 2, save_option, curses.color_pair(2) | curses.A_REVERSE)
-        else:
-            menu_win.addstr(save_position, (width - len(save_option)) // 2, save_option, curses.color_pair(2))
+        menu_win.addstr(save_position, (width - len(save_option)) // 2, save_option, get_color("settings_save", reverse = (selected_index == len(current_menu))))
+
+    menu_win.refresh()
+    menu_pad.refresh(0, 0,
+                     menu_win.getbegyx()[0] + 3, menu_win.getbegyx()[1] + 4,
+                     menu_win.getbegyx()[0] + 3 + menu_win.getmaxyx()[0] - 5 - (2 if show_save_option else 0), menu_win.getbegyx()[1] + menu_win.getmaxyx()[1] - 8)
+    
+    return menu_win, menu_pad
+
+
+def move_highlight(old_idx, new_idx, options, show_save_option, menu_win, menu_pad):
+
+    if(old_idx == new_idx): # no-op
+        return
+
+    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)) // 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"))
+
+    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)) // 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()
 
+    start_index = max(0, new_idx - (menu_win.getmaxyx()[0] - 5 - (2 if show_save_option else 0)) - (1 if show_save_option and new_idx == max_index else 0))  # Leave room for borders
+    menu_pad.refresh(start_index, 0,
+                     menu_win.getbegyx()[0] + 3, menu_win.getbegyx()[1] + 4,
+                     menu_win.getbegyx()[0] + 3 + menu_win.getmaxyx()[0] - 5 - (2 if show_save_option else 0), menu_win.getbegyx()[1] + menu_win.getmaxyx()[1] - 8)
+
 def settings_menu(stdscr, interface):
+    curses.update_lines_cols()
 
     menu = generate_menu_from_protobuf(interface)
     current_menu = menu["Main Menu"]
     menu_path = ["Main Menu"]
+    menu_index = []
     selected_index = 0
     modified_settings = {}
     
+    need_redraw = True
+    show_save_option = False
+
     while True:
-        options = list(current_menu.keys())
+        if(need_redraw):
+            options = list(current_menu.keys())
 
-        show_save_option = (
-            len(menu_path) > 2 and ("Radio Settings" in menu_path or "Module Settings" in menu_path)
-        ) or (
-            len(menu_path) == 2 and "User Settings" in menu_path 
-        ) or (
-            len(menu_path) == 3 and "Channels" in menu_path
-        )
+            show_save_option = (
+                len(menu_path) > 2 and ("Radio Settings" in menu_path or "Module Settings" in menu_path)
+            ) or (
+                len(menu_path) == 2 and "User Settings" in menu_path 
+            ) or (
+                len(menu_path) == 3 and "Channels" in menu_path
+            )
 
-        # Display the menu
-        display_menu(current_menu, menu_path, selected_index, show_save_option)
+            # Display the menu
+            menu_win, menu_pad = display_menu(current_menu, menu_path, selected_index, show_save_option)
+
+            need_redraw = False
 
         # Capture user input
         key = menu_win.getch()
 
+        max_index = len(options) + (1 if show_save_option else 0) - 1
+
         if key == curses.KEY_UP:
-            selected_index = max(0, selected_index - 1)
+            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)
             
         elif key == curses.KEY_DOWN:
-            max_index = len(options) + (1 if show_save_option else 0) - 1
-            selected_index = min(max_index, selected_index + 1)
+            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)
+
+        elif key == curses.KEY_RESIZE:
+            need_redraw = True
+            curses.update_lines_cols()
+
+        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)
 
         elif key == curses.KEY_RIGHT or key == ord('\n'):
-            menu_win.clear()
+            need_redraw = True
+            menu_win.erase()
             menu_win.refresh()
             if show_save_option and selected_index == len(options):
                 save_changes(interface, menu_path, modified_settings)
@@ -113,73 +169,144 @@ def settings_menu(stdscr, interface):
 
             if selected_option == "Exit":
                 break
+
+
+            elif selected_option == "Export Config":
+                filename = get_text_input("Enter a filename for the config file")
+
+                if not filename:
+                    logging.warning("Export aborted: No filename provided.")
+                    continue  # Go back to the menu
+
+                if not filename.lower().endswith(".yaml"):
+                    filename += ".yaml"
+
+                try:
+                    config_text = config_export(globals.interface)
+                    app_directory = os.path.dirname(os.path.abspath(__file__))
+                    config_folder = "node-configs"
+                    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 == "Yes":
+                            logging.info("Export cancelled: User chose not to overwrite.")
+                            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}")
+                    break
+                except PermissionError:
+                    logging.error(f"Permission denied: Unable to write to {yaml_file_path}")
+                except OSError as e:
+                    logging.error(f"OS error while saving config: {e}")
+                except Exception as e:
+                    logging.error(f"Unexpected error: {e}")
+                continue
+
+            elif selected_option == "Load Config":
+                app_directory = os.path.dirname(os.path.abspath(__file__))
+                config_folder = "node-configs"
+                folder_path = os.path.join(app_directory, config_folder)
+                file_list = [f for f in os.listdir(folder_path) if os.path.isfile(os.path.join(folder_path, f))]
+                filename = get_list_input("Choose a config file", None, file_list)
+                if filename:
+                    file_path = os.path.join(app_directory, config_folder, filename)
+                    overwrite = get_list_input(f"Are you sure you want to load {filename}?", None,  ["Yes", "No"])
+                    if overwrite == "Yes":
+                        config_import(globals.interface, file_path)
+                    break
+                continue
+
             elif selected_option == "Reboot":
-                confirmation = get_bool_selection("Are you sure you want to Reboot?", 0)
-                if confirmation == "True":
-                    settings_reboot(interface)
+                confirmation = get_list_input("Are you sure you want to Reboot?", None,  ["Yes", "No"])
+                if confirmation == "Yes":
+                    interface.localNode.reboot()
                     logging.info(f"Node Reboot Requested by menu")
                     break
+                continue
             elif selected_option == "Reset Node DB":
-                confirmation = get_bool_selection("Are you sure you want to Reset Node DB?", 0)
-                if confirmation == "True":
-                    settings_reset_nodedb(interface)
+                confirmation = get_list_input("Are you sure you want to Reset Node DB?", None,  ["Yes", "No"])
+                if confirmation == "Yes":
+                    interface.localNode.resetNodeDb()
                     logging.info(f"Node DB Reset Requested by menu")
                     break
+                continue
             elif selected_option == "Shutdown":
-                confirmation = get_bool_selection("Are you sure you want to Shutdown?", 0)
-                if confirmation == "True":
-                    settings_shutdown(interface)
+                confirmation = get_list_input("Are you sure you want to Shutdown?", None, ["Yes", "No"])
+                if confirmation == "Yes":
+                    interface.localNode.shutdown()
                     logging.info(f"Node Shutdown Requested by menu")
                     break
+                continue
             elif selected_option == "Factory Reset":
-                confirmation = get_bool_selection("Are you sure you want to Factory Reset?", 0)
-                if confirmation == "True":
-                    settings_factory_reset(interface)
+                confirmation = get_list_input("Are you sure you want to Factory Reset?", None,  ["Yes", "No"])
+                if confirmation == "Yes":
+                    interface.localNode.factoryReset()
                     logging.info(f"Factory Reset Requested by menu")
                     break
-
+                continue
+            elif selected_option == "App Settings":
+                menu_win.clear()
+                menu_win.refresh()
+                json_editor(stdscr)  # Open the App Settings menu
+                continue
+                # need_redraw = True
+                
             field_info = current_menu.get(selected_option)
             if isinstance(field_info, tuple):
                 field, current_value = field_info
 
                 if selected_option in ['longName', 'shortName', 'isLicensed']:
                     if selected_option in ['longName', 'shortName']:
-                        new_value = get_user_input(f"Current value for {selected_option}: {current_value}")
+                        new_value = get_text_input(f"Current value for {selected_option}: {current_value}")
+                        new_value = current_value if new_value is None else new_value
                         current_menu[selected_option] = (field, new_value)
 
                     elif selected_option == 'isLicensed':
-                        new_value = get_bool_selection(f"Current value for {selected_option}: {current_value}", str(current_value))
+                        new_value = get_list_input(f"Current value for {selected_option}: {current_value}", str(current_value),  ["True", "False"])
                         new_value = new_value == "True"
                         current_menu[selected_option] = (field, new_value)
 
                     for option, (field, value) in current_menu.items():
                         modified_settings[option] = value
 
+                elif selected_option in ['latitude', 'longitude', 'altitude']:
+                    new_value = get_text_input(f"Current value for {selected_option}: {current_value}")
+                    new_value = current_value if new_value is None else new_value
+                    current_menu[selected_option] = (field, new_value)
+
+                    for option in ['latitude', 'longitude', 'altitude']:
+                        if option in current_menu:
+                            modified_settings[option] = current_menu[option][1]
+
                 elif field.type == 8:  # Handle boolean type
-                    new_value = get_bool_selection(selected_option, str(current_value))
-                    new_value = new_value == "True"
+                    new_value = get_list_input(selected_option, str(current_value),  ["True", "False"])
+                    new_value = new_value == "True" or new_value is True
 
                 elif field.label == field.LABEL_REPEATED:  # Handle repeated field
                     new_value = get_repeated_input(current_value)
                     new_value = current_value if new_value is None else [int(item) for item in new_value]
 
                 elif field.enum_type:  # Enum field
-                    enum_options = [v.name for v in field.enum_type.values]
-                    new_value = get_enum_input(enum_options, current_value)
+                    enum_options = {v.name: v.number for v in field.enum_type.values}
+                    new_value_name = get_list_input(selected_option, current_value, list(enum_options.keys()))
+                    new_value = enum_options.get(new_value_name, current_value)
 
                 elif field.type == 7: # Field type 7 corresponds to FIXED32
                     new_value = get_fixed32_input(current_value)
 
                 elif field.type == 13: # Field type 13 corresponds to UINT32
-                    new_value = get_user_input(f"Current value for {selected_option}: {current_value}")
+                    new_value = get_text_input(f"Current value for {selected_option}: {current_value}")
                     new_value = current_value if new_value is None else int(new_value)
 
                 elif field.type == 2: # Field type 13 corresponds to INT64
-                    new_value = get_user_input(f"Current value for {selected_option}: {current_value}")
+                    new_value = get_text_input(f"Current value for {selected_option}: {current_value}")
                     new_value = current_value if new_value is None else float(new_value)
 
                 else:  # Handle other field types
-                    new_value = get_user_input(f"Current value for {selected_option}: {current_value}")
+                    new_value = get_text_input(f"Current value for {selected_option}: {current_value}")
                     new_value = current_value if new_value is None else new_value
                 
                 for key in menu_path[3:]:  # Skip "Main Menu"
@@ -188,18 +315,26 @@ def settings_menu(stdscr, interface):
                 # Add the new value to the appropriate level
                 modified_settings[selected_option] = new_value
 
+                # Convert enum string to int
+                if field and field.enum_type:
+                    enum_value_descriptor = field.enum_type.values_by_number.get(new_value)
+                    new_value = enum_value_descriptor.name if enum_value_descriptor else new_value
+
                 current_menu[selected_option] = (field, new_value)
             else:
                 current_menu = current_menu[selected_option]
                 menu_path.append(selected_option)
+                menu_index.append(selected_index)
                 selected_index = 0
 
         elif key == curses.KEY_LEFT:
+            need_redraw = True
 
-            menu_win.clear()
+            menu_win.erase()
             menu_win.refresh()
 
-            modified_settings.clear()
+            if len(menu_path) < 2:
+                modified_settings.clear()
 
             # Navigate back to the previous menu
             if len(menu_path) > 1:
@@ -207,13 +342,32 @@ def settings_menu(stdscr, interface):
                 current_menu = menu["Main Menu"]
                 for step in menu_path[1:]:
                     current_menu = current_menu.get(step, {})
-                selected_index = 0
+                selected_index = menu_index.pop()
 
         elif key == 27:  # Escape key
-            menu_win.clear()
+            menu_win.erase()
             menu_win.refresh()
             break
 
+def set_region():
+    node = globals.interface.getNode('^local')
+    device_config = node.localConfig
+    lora_descriptor = device_config.lora.DESCRIPTOR
+
+    # Get the enum mapping of region names to their numerical values
+    region_enum = lora_descriptor.fields_by_name["region"].enum_type
+    region_name_to_number = {v.name: v.number for v in region_enum.values}
+
+    regions = list(region_name_to_number.keys())
+
+    new_region_name = get_list_input('Select your region:', 'UNSET', regions)
+
+    # Convert region name to corresponding enum number
+    new_region_number = region_name_to_number.get(new_region_name, 0)  # Default to 0 if not found
+
+    node.localConfig.lora.region = new_region_number
+    node.writeConfig("lora")
+    
 
 def main(stdscr):
     logging.basicConfig( # Run `tail -f client.log` in another terminal to view live
@@ -232,4 +386,4 @@ def main(stdscr):
     settings_menu(stdscr, globals.interface)
 
 if __name__ == "__main__":
-    curses.wrapper(main)
+    curses.wrapper(main)

ui/colors.py

@@ -1,9 +1,43 @@
 import curses
+import default_config as config
 
-def setup_colors():
+COLOR_MAP = {
+    "black": curses.COLOR_BLACK,
+    "red": curses.COLOR_RED,
+    "green": curses.COLOR_GREEN,
+    "yellow": curses.COLOR_YELLOW,
+    "blue": curses.COLOR_BLUE,
+    "magenta": curses.COLOR_MAGENTA,
+    "cyan": curses.COLOR_CYAN,
+    "white": curses.COLOR_WHITE
+}
+
+def setup_colors(reinit=False):
+    """
+    Initialize curses color pairs based on the COLOR_CONFIG.
+    """
     curses.start_color()
-    curses.init_pair(1, curses.COLOR_WHITE, curses.COLOR_BLACK)
-    curses.init_pair(2, curses.COLOR_GREEN, curses.COLOR_BLACK) 
-    curses.init_pair(3, curses.COLOR_CYAN, curses.COLOR_BLACK)
-    curses.init_pair(4, curses.COLOR_YELLOW, curses.COLOR_BLACK)
-    curses.init_pair(5, curses.COLOR_RED, curses.COLOR_BLACK)
+    if reinit:
+        conf = config.initialize_config()
+        config.assign_config_variables(conf)
+
+    for idx, (category, (fg_name, bg_name)) in enumerate(config.COLOR_CONFIG.items(), start=1):
+        fg = COLOR_MAP.get(fg_name.lower(), curses.COLOR_WHITE)
+        bg = COLOR_MAP.get(bg_name.lower(), curses.COLOR_BLACK)
+        curses.init_pair(idx, fg, bg)
+        config.COLOR_CONFIG[category] = idx
+    print()
+
+
+def get_color(category, bold=False, reverse=False, underline=False):
+    """
+    Retrieve a curses color pair with optional attributes.
+    """
+    color = curses.color_pair(config.COLOR_CONFIG[category])
+    if bold:
+        color |= curses.A_BOLD
+    if reverse:
+        color |= curses.A_REVERSE
+    if underline:
+        color |= curses.A_UNDERLINE
+    return color

ui/dialog.py

@@ -1,4 +1,5 @@
 import curses
+from ui.colors import get_color
 
 def dialog(stdscr, title, message):
     height, width = stdscr.getmaxyx()
@@ -15,17 +16,19 @@ def dialog(stdscr, title, message):
 
     # Create dialog window
     win = curses.newwin(dialog_height, dialog_width, y, x)
+    win.bkgd(get_color("background"))
+    win.attrset(get_color("window_frame"))
     win.border(0)
 
     # Add title
-    win.addstr(0, 2, title)
+    win.addstr(0, 2, title, get_color("settings_default"))
 
     # Add message
     for i, l in enumerate(message_lines):
-        win.addstr(2 + i, 2, l)
+        win.addstr(2 + i, 2, l, get_color("settings_default"))
 
     # Add button
-    win.addstr(dialog_height - 2, (dialog_width - 4) // 2, " Ok ", curses.color_pair(1)  | curses.A_REVERSE)
+    win.addstr(dialog_height - 2, (dialog_width - 4) // 2, " Ok ", get_color("settings_default", reverse=True))
 
     # Refresh dialog window
     win.refresh()
@@ -35,6 +38,6 @@ def dialog(stdscr, title, message):
         char = win.getch()
         # Close dialog with enter, space, or esc
         if char in(curses.KEY_ENTER, 10, 13, 32, 27):
-            win.clear()
+            win.erase()
             win.refresh()
             return

ui/menus.py

@@ -1,6 +1,8 @@
+from collections import OrderedDict
 from meshtastic.protobuf import config_pb2, module_config_pb2, channel_pb2
-from save_to_radio import settings_reboot, settings_factory_reset, settings_reset_nodedb, settings_shutdown
-import logging, traceback
+import logging
+import base64
+
 
 def extract_fields(message_instance, current_config=None):
     if isinstance(current_config, dict):  # Handle dictionaries
@@ -12,9 +14,9 @@ def extract_fields(message_instance, current_config=None):
     menu = {}
     fields = message_instance.DESCRIPTOR.fields
     for field in fields:
-        if field.name in {"sessionkey", "channel_num", "id"}:  # Skip certain fields
+        if field.name in {"sessionkey", "channel_num", "id", "ignore_incoming"}:  # Skip certain fields
             continue
-        
+
         if field.message_type:  # Nested message
             nested_instance = getattr(message_instance, field.name)
             nested_config = getattr(current_config, field.name, None) if current_config else None
@@ -33,24 +35,12 @@ def extract_fields(message_instance, current_config=None):
         else:  # Handle other field types
             current_value = getattr(current_config, field.name, "Not Set") if current_config else "Not Set"
             menu[field.name] = (field, current_value)
-    
     return menu
 
-
 def generate_menu_from_protobuf(interface):
 # Function to generate the menu structure from protobuf messages
     menu_structure = {"Main Menu": {}}
 
-    # Add Radio Settings
-    radio = config_pb2.Config()
-    current_radio_config = interface.localNode.localConfig if interface else None
-    menu_structure["Main Menu"]["Radio Settings"] = extract_fields(radio, current_radio_config)
-
-    # Add Module Settings
-    module = module_config_pb2.ModuleConfig()
-    current_module_config = interface.localNode.moduleConfig if interface else None
-    menu_structure["Main Menu"]["Module Settings"] = extract_fields(module, current_module_config)
-
     # Add User Settings
     current_node_info = interface.getMyNodeInfo() if interface else None
 
@@ -64,7 +54,6 @@ def generate_menu_from_protobuf(interface):
                 "shortName": (None, current_user_config.get("shortName", "Not Set")),
                 "isLicensed": (None, current_user_config.get("isLicensed", "False"))
             }
-
         else:
             logging.info("User settings not found in Node Info")
             menu_structure["Main Menu"]["User Settings"] = "No user settings available"
@@ -80,13 +69,54 @@ def generate_menu_from_protobuf(interface):
             current_channel = interface.localNode.getChannelByChannelIndex(i)
             if current_channel:
                 channel_config = extract_fields(channel, current_channel.settings)
+                # Convert 'psk' field to Base64
+                channel_config["psk"] = (channel_config["psk"][0], base64.b64encode(channel_config["psk"][1]).decode('utf-8'))
                 menu_structure["Main Menu"]["Channels"][f"Channel {i + 1}"] = channel_config
 
+    # Add Radio Settings
+    radio = config_pb2.Config()
+    current_radio_config = interface.localNode.localConfig if interface else None
+    menu_structure["Main Menu"]["Radio Settings"] = extract_fields(radio, current_radio_config)
+
+    # Add Lat/Lon/Alt
+    position_data = {
+        "latitude": (None, current_node_info["position"].get("latitude", 0.0)),
+        "longitude": (None, current_node_info["position"].get("longitude", 0.0)),
+        "altitude": (None, current_node_info["position"].get("altitude", 0))
+    }
+
+    # Get existing position menu items
+    existing_position_menu = menu_structure["Main Menu"]["Radio Settings"].get("position", {})
+
+    # Create an ordered position menu with Lat/Lon/Alt inserted in the middle
+    ordered_position_menu = OrderedDict()
+
+    for key, value in existing_position_menu.items():
+        if key == "fixed_position":  # Insert before or after a specific key
+            ordered_position_menu[key] = value
+            ordered_position_menu.update(position_data)  # Insert Lat/Lon/Alt **right here**
+        else:
+            ordered_position_menu[key] = value
+
+    # Update the menu with the new order
+    menu_structure["Main Menu"]["Radio Settings"]["position"] = ordered_position_menu
+
+
+    # Add Module Settings
+    module = module_config_pb2.ModuleConfig()
+    current_module_config = interface.localNode.moduleConfig if interface else None
+    menu_structure["Main Menu"]["Module Settings"] = extract_fields(module, current_module_config)
+
+    # Add App Settings
+    menu_structure["Main Menu"]["App Settings"] = {"Open": "app_settings"}
+
     # Add additional settings options
-    menu_structure["Main Menu"]["Reboot"] = settings_reboot
-    menu_structure["Main Menu"]["Reset Node DB"] = settings_reset_nodedb
-    menu_structure["Main Menu"]["Shutdown"] = settings_shutdown
-    menu_structure["Main Menu"]["Factory Reset"] = settings_factory_reset
+    menu_structure["Main Menu"]["Export Config"] = None
+    menu_structure["Main Menu"]["Load Config"] = None
+    menu_structure["Main Menu"]["Reboot"] = None
+    menu_structure["Main Menu"]["Reset Node DB"] = None
+    menu_structure["Main Menu"]["Shutdown"] = None
+    menu_structure["Main Menu"]["Factory Reset"] = None
 
     # Add Exit option
     menu_structure["Main Menu"]["Exit"] = None

user_config.py

@@ -0,0 +1,321 @@
+import os
+import json
+import curses
+from ui.colors import get_color, setup_colors, COLOR_MAP
+from default_config import format_json_single_line_arrays, loaded_config
+from 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/config_io.py

@@ -0,0 +1,281 @@
+
+import yaml
+import logging
+from typing import List
+from google.protobuf.json_format import MessageToDict
+from meshtastic import BROADCAST_ADDR, mt_config
+from meshtastic.util import camel_to_snake, snake_to_camel, fromStr
+
+# defs are from meshtastic/python/main
+
+def traverseConfig(config_root, config, interface_config) -> bool:
+    """Iterate through current config level preferences and either traverse deeper if preference is a dict or set preference"""
+    snake_name = camel_to_snake(config_root)
+    for pref in config:
+        pref_name = f"{snake_name}.{pref}"
+        if isinstance(config[pref], dict):
+            traverseConfig(pref_name, config[pref], interface_config)
+        else:
+            setPref(interface_config, pref_name, config[pref])
+
+    return True
+
+def splitCompoundName(comp_name: str) -> List[str]:
+    """Split compound (dot separated) preference name into parts"""
+    name: List[str] = comp_name.split(".")
+    if len(name) < 2:
+        name[0] = comp_name
+        name.append(comp_name)
+    return name
+
+def setPref(config, comp_name, raw_val) -> bool:
+    """Set a channel or preferences value"""
+
+    name = splitCompoundName(comp_name)
+
+    snake_name = camel_to_snake(name[-1])
+    camel_name = snake_to_camel(name[-1])
+    uni_name = camel_name if mt_config.camel_case else snake_name
+    logging.debug(f"snake_name:{snake_name}")
+    logging.debug(f"camel_name:{camel_name}")
+
+    objDesc = config.DESCRIPTOR
+    config_part = config
+    config_type = objDesc.fields_by_name.get(name[0])
+    if config_type and config_type.message_type is not None:
+        for name_part in name[1:-1]:
+            part_snake_name = camel_to_snake((name_part))
+            config_part = getattr(config, config_type.name)
+            config_type = config_type.message_type.fields_by_name.get(part_snake_name)
+    pref = None
+    if config_type and config_type.message_type is not None:
+        pref = config_type.message_type.fields_by_name.get(snake_name)
+    # Others like ChannelSettings are standalone
+    elif config_type:
+        pref = config_type
+
+    if (not pref) or (not config_type):
+        return False
+
+    if isinstance(raw_val, str):
+        val = fromStr(raw_val)
+    else:
+        val = raw_val
+    logging.debug(f"valStr:{raw_val} val:{val}")
+
+    if snake_name == "wifi_psk" and len(str(raw_val)) < 8:
+        logging.info(f"Warning: network.wifi_psk must be 8 or more characters.")
+        return False
+
+    enumType = pref.enum_type
+    # pylint: disable=C0123
+    if enumType and type(val) == str:
+        # We've failed so far to convert this string into an enum, try to find it by reflection
+        e = enumType.values_by_name.get(val)
+        if e:
+            val = e.number
+        else:
+            logging.info(
+                f"{name[0]}.{uni_name} does not have an enum called {val}, so you can not set it."
+            )
+            logging.info(f"Choices in sorted order are:")
+            names = []
+            for f in enumType.values:
+                # Note: We must use the value of the enum (regardless if camel or snake case)
+                names.append(f"{f.name}")
+            for temp_name in sorted(names):
+                logging.info(f"    {temp_name}")
+            return False
+
+    # repeating fields need to be handled with append, not setattr
+    if pref.label != pref.LABEL_REPEATED:
+        try:
+            if config_type.message_type is not None:
+                config_values = getattr(config_part, config_type.name)
+                setattr(config_values, pref.name, val)
+            else:
+                setattr(config_part, snake_name, val)
+        except TypeError:
+            # The setter didn't like our arg type guess try again as a string
+            config_values = getattr(config_part, config_type.name)
+            setattr(config_values, pref.name, str(val))
+    elif type(val) == list:
+        new_vals = [fromStr(x) for x in val]
+        config_values = getattr(config, config_type.name)
+        getattr(config_values, pref.name)[:] = new_vals
+    else:
+        config_values = getattr(config, config_type.name)
+        if val == 0:
+            # clear values
+            logging.info(f"Clearing {pref.name} list")
+            del getattr(config_values, pref.name)[:]
+        else:
+            logging.info(f"Adding '{raw_val}' to the {pref.name} list")
+            cur_vals = [x for x in getattr(config_values, pref.name) if x not in [0, "", b""]]
+            cur_vals.append(val)
+            getattr(config_values, pref.name)[:] = cur_vals
+        return True
+
+    prefix = f"{'.'.join(name[0:-1])}." if config_type.message_type is not None else ""
+    logging.info(f"Set {prefix}{uni_name} to {raw_val}")
+
+    return True
+
+
+
+def config_import(interface, filename):
+    with open(filename, encoding="utf8") as file:
+        configuration = yaml.safe_load(file)
+        closeNow = True
+
+        interface.getNode('^local', False).beginSettingsTransaction()
+
+        if "owner" in configuration:
+            logging.info(f"Setting device owner to {configuration['owner']}")
+            waitForAckNak = True
+            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
+            interface.getNode('^local', False).setOwner(
+                long_name=None, short_name=configuration["owner_short"]
+            )
+
+        if "ownerShort" in configuration:
+            logging.info(
+                f"Setting device owner short to {configuration['ownerShort']}"
+            )
+            waitForAckNak = True
+            interface.getNode('^local', False).setOwner(
+                long_name=None, short_name=configuration["ownerShort"]
+            )
+
+        if "channel_url" in configuration:
+            logging.info(f"Setting channel url to {configuration['channel_url']}")
+            interface.getNode('^local').setURL(configuration["channel_url"])
+
+        if "channelUrl" in configuration:
+            logging.info(f"Setting channel url to {configuration['channelUrl']}")
+            interface.getNode('^local').setURL(configuration["channelUrl"])
+
+        if "location" in configuration:
+            alt = 0
+            lat = 0.0
+            lon = 0.0
+            localConfig = interface.localNode.localConfig
+
+            if "alt" in configuration["location"]:
+                alt = int(configuration["location"]["alt"] or 0)
+                logging.info(f"Fixing altitude at {alt} meters")
+            if "lat" in configuration["location"]:
+                lat = float(configuration["location"]["lat"] or 0)
+                logging.info(f"Fixing latitude at {lat} degrees")
+            if "lon" in configuration["location"]:
+                lon = float(configuration["location"]["lon"] or 0)
+                logging.info(f"Fixing longitude at {lon} degrees")
+            logging.info("Setting device position")
+            interface.localNode.setFixedPosition(lat, lon, alt)
+
+        if "config" in configuration:
+            localConfig = interface.getNode('^local').localConfig
+            for section in configuration["config"]:
+                traverseConfig(
+                    section, configuration["config"][section], localConfig
+                )
+                interface.getNode('^local').writeConfig(
+                    camel_to_snake(section)
+                )
+
+        if "module_config" in configuration:
+            moduleConfig = interface.getNode('^local').moduleConfig
+            for section in configuration["module_config"]:
+                traverseConfig(
+                    section,
+                    configuration["module_config"][section],
+                    moduleConfig,
+                )
+                interface.getNode('^local').writeConfig(
+                    camel_to_snake(section)
+                )
+
+        interface.getNode('^local', False).commitSettingsTransaction()
+        logging.info("Writing modified configuration to device")
+
+
+
+def config_export(interface) -> str:
+    """used in --export-config"""
+    configObj = {}
+
+    owner = interface.getLongName()
+    owner_short = interface.getShortName()
+    channel_url = interface.localNode.getURL()
+    myinfo = interface.getMyNodeInfo()
+    pos = myinfo.get("position")
+    lat = None
+    lon = None
+    alt = None
+    if pos:
+        lat = pos.get("latitude")
+        lon = pos.get("longitude")
+        alt = pos.get("altitude")
+
+    if owner:
+        configObj["owner"] = owner
+    if owner_short:
+        configObj["owner_short"] = owner_short
+    if channel_url:
+        if mt_config.camel_case:
+            configObj["channelUrl"] = channel_url
+        else:
+            configObj["channel_url"] = channel_url
+    # lat and lon don't make much sense without the other (so fill with 0s), and alt isn't meaningful without both
+    if lat or lon:
+        configObj["location"] = {"lat": lat or float(0), "lon": lon or float(0)}
+        if alt:
+            configObj["location"]["alt"] = alt
+
+    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 = {}
+        for pref in config:
+            if mt_config.camel_case:
+                prefs[snake_to_camel(pref)] = config[pref]
+            else:
+                prefs[pref] = config[pref]
+            # mark base64 encoded fields as such
+            if pref == "security":
+                if 'privateKey' in prefs[pref]:
+                    prefs[pref]['privateKey'] = 'base64:' + prefs[pref]['privateKey']
+                if 'publicKey' in prefs[pref]:
+                    prefs[pref]['publicKey'] = 'base64:' + prefs[pref]['publicKey']
+                if 'adminKey' in prefs[pref]:
+                    for i in range(len(prefs[pref]['adminKey'])):
+                        prefs[pref]['adminKey'][i] = 'base64:' + prefs[pref]['adminKey'][i]
+        if mt_config.camel_case:
+            configObj["config"] = config		#Identical command here and 2 lines below?
+        else:
+            configObj["config"] = config
+
+    module_config = MessageToDict(interface.localNode.moduleConfig)
+    if module_config:
+        # Convert inner keys to correct snake/camelCase
+        prefs = {}
+        for pref in module_config:
+            if len(module_config[pref]) > 0:
+                prefs[pref] = module_config[pref]
+        if mt_config.camel_case:
+            configObj["module_config"] = prefs
+        else:
+            configObj["module_config"] = prefs
+
+    config_txt = "# start of Meshtastic configure yaml\n"		#checkme - "config" (now changed to config_out)
+                                                                        #was used as a string here and a Dictionary above
+    config_txt += yaml.dump(configObj)
+
+    # logging.info(config_txt)
+    return config_txt

utilities/interfaces.py

@@ -1,17 +1,23 @@
-import meshtastic.serial_interface
-import meshtastic.tcp_interface
-import meshtastic.ble_interface
+import logging
+import meshtastic.serial_interface, meshtastic.tcp_interface, meshtastic.ble_interface
 import globals
 
 def initialize_interface(args):
-    if args.ble:
-        return meshtastic.ble_interface.BLEInterface(args.ble if args.ble != "any" else None)
-    elif args.host:
-        return meshtastic.tcp_interface.TCPInterface(args.host)
-    else:
-        try:
-            return meshtastic.serial_interface.SerialInterface(args.port)
-        except PermissionError as ex:
-            print("You probably need to add yourself to the `dialout` group to use a serial connection.")
-        if globals.interface.devPath is None:
-            return meshtastic.tcp_interface.TCPInterface("meshtastic.local")
+    try:
+        if args.ble:
+            return meshtastic.ble_interface.BLEInterface(args.ble if args.ble != "any" else None)
+        elif args.host:
+            return meshtastic.tcp_interface.TCPInterface(args.host)
+        else:
+            try:
+                return meshtastic.serial_interface.SerialInterface(args.port)
+            except PermissionError as ex:
+                logging.error(f"You probably need to add yourself to the `dialout` group to use a serial connection. {ex}")
+            except Exception as ex:
+                logging.error(f"Unexpected error initializing interface: {ex}")
+            if globals.interface.devPath is None:
+                return meshtastic.tcp_interface.TCPInterface("meshtastic.local")
+    
+    except Exception as ex:
+        logging.critical(f"Fatal error initializing interface: {ex}")
+    

utilities/utils.py

@@ -1,6 +1,7 @@
 import globals
+import datetime
 from meshtastic.protobuf import config_pb2
-import re
+import default_config as config
 
 def get_channels():
     """Retrieve channels from the node and update globals.channel_list and globals.all_messages."""
@@ -35,13 +36,29 @@ def get_channels():
 
 def get_node_list():
     if globals.interface.nodes:
-        sorted_nodes = sorted(
-            globals.interface.nodes.values(),
-            key = lambda node: (node['lastHeard'] if ('lastHeard' in node and isinstance(node['lastHeard'], int)) else 0),
-            reverse = True)
-        return [node['num'] for node in sorted_nodes]
+        my_node_num = globals.myNodeNum
+
+        def node_sort(node):
+            if(config.node_sort == 'lastHeard'):
+                return -node['lastHeard'] if ('lastHeard' in node and isinstance(node['lastHeard'], int)) else 0
+            elif(config.node_sort == "name"):
+                return node['user']['longName']
+            elif(config.node_sort == "hops"):
+                return node['hopsAway'] if 'hopsAway' in node else 100
+            else:
+                return node
+        sorted_nodes = sorted(globals.interface.nodes.values(), key = node_sort)
+        node_list = [node['num'] for node in sorted_nodes if node['num'] != my_node_num]
+        return [my_node_num] + node_list  # Ensuring your node is always first
     return []
 
+def refresh_node_list():
+    new_node_list = get_node_list()
+    if new_node_list != globals.node_list:
+        globals.node_list = new_node_list
+        return True
+    return False
+
 def get_nodeNum():
     myinfo = globals.interface.getMyNodeInfo()
     myNodeNum = myinfo['num']
@@ -55,17 +72,45 @@ def convert_to_camel_case(string):
     camel_case_string = ''.join(word.capitalize() for word in words)
     return camel_case_string
 
-def get_name_from_number(number, type='long'):
-    name = ""
-    nodes_snapshot = list(globals.interface.nodes.values())
-    
-    for node in nodes_snapshot:
-        if number == node['num']:
-            if type == 'long':
-                return node['user']['longName']
-            elif type == 'short':
-                return node['user']['shortName']
-            else:
-                pass
-    # If no match is found, use the ID as a string
-    return str(decimal_to_hex(number))
+def get_time_val_units(time_delta):
+    value = 0
+    unit = ""
+
+    if time_delta.days > 365:
+        value = time_delta.days // 365
+        unit = "y"
+    elif time_delta.days > 30:
+        value = time_delta.days // 30
+        unit = "mon"
+    elif time_delta.days > 7:
+        value = time_delta.days // 7
+        unit = "w"
+    elif time_delta.days > 0:
+        value = time_delta.days
+        unit = "d"
+    elif time_delta.seconds > 3600:
+        value = time_delta.seconds // 3600
+        unit = "h"
+    elif time_delta.seconds > 60:
+        value = time_delta.seconds // 60
+        unit = "min"
+    else:
+        value = time_delta.seconds
+        unit = "s"
+    return (value, unit)
+
+def get_readable_duration(seconds):
+    delta = datetime.timedelta(seconds = seconds)
+    val, units = get_time_val_units(delta)
+    return f"{val} {units}"
+
+def get_time_ago(timestamp):
+    now = datetime.datetime.now()
+    dt = datetime.datetime.fromtimestamp(timestamp)
+    delta = now - dt
+
+    value, unit = get_time_val_units(delta)
+    if unit != "s":
+        return f"{value} {unit} ago"
+    return "now"
+