add reporting service back in

let me know if errors

INSTALL.md

@@ -196,4 +196,27 @@ From your project root, run one of the following commands:
 
 - The script requires a Python virtual environment (`venv`) to be present in the project directory.
 - If `venv` is missing, the script will exit with an error message.
-- Always provide an argument (`mesh`, `pong`, `html`, `html5`, or `add`) to specify what you want to launch.
+- Always provide an argument (`mesh`, `pong`, `html`, `html5`, or `add`) to specify what you want to launch.
+
+## Troubleshooting
+
+### Permissions Issues
+
+If you encounter errors related to file or directory permissions (e.g., "Permission denied" or services failing to start):
+
+- Ensure you are running installation scripts with sufficient privileges (use `sudo` if needed).
+- The `logs`, `data`, and `config.ini` files must be owned by the user running the bot (often `meshbot` or your current user).
+- You can manually reset permissions using the provided script:
+
+  ```sh
+  sudo bash etc/set-permissions.sh meshbot
+  ```
+
+- If you moved the project directory, re-run the permissions script to update ownership.
+
+- For systemd service issues, check logs with:
+  ```sh
+  sudo journalctl -u mesh_bot.service
+  ```
+
+If problems persist, double-check that the user specified in your service files matches the owner of the project files and directories.

README.md

@@ -41,10 +41,11 @@ Mesh Bot is a feature-rich Python bot designed to enhance your [Meshtastic](http
 
 ### Interactive AI and Data Lookup
 - **Weather, Earthquake, River, and Tide Data**: Get local alerts and info from NOAA/USGS; uses Open-Meteo for areas outside NOAA coverage.
-- **Wikipedia Search**: Retrieve summaries from Wikipedia.
+- **Wikipedia Search**: Retrieve summaries from Wikipedia and Kiwix
 - **OpenWebUI, Ollama LLM Integration**: Query the [Ollama](https://github.com/ollama/ollama/tree/main/docs) AI for advanced responses. Supports RAG (Retrieval Augmented Generation) with Wikipedia/Kiwix context and [OpenWebUI](https://github.com/open-webui/open-webui) integration for enhanced AI capabilities. [LLM Readme](modules/llm.md)
 - **Satellite Passes**: Find upcoming satellite passes for your location.
 - **GeoMeasuring Tools**: Calculate distances and midpoints using collected GPS data; supports Fox & Hound direction finding.
+- **RSS & News Feeds**: Receive news and data from multiple sources directly on the mesh.
 
 ### Proximity Alerts
 - **Location-Based Alerts**: Get notified when members arrive at a configured latitude/longitude—ideal for campsites, geo-fences, or remote locations. Optionally, trigger scripts, send emails, or automate actions (e.g., change node config, turn on lights, or drop an `alert.txt` file to start a survey or game).
@@ -52,12 +53,25 @@ Mesh Bot is a feature-rich Python bot designed to enhance your [Meshtastic](http
 - **High Flying Alerts**: Receive notifications when nodes with high altitude are detected on the mesh.
 - **Voice/Command Triggers**: Activate bot functions using keywords or voice commands (see [Voice Commands](#voice-commands-vox) for "Hey Chirpy!" support).
 
+### EAS Alerts
+- **FEMA iPAWS/EAS Alerts**: Receive Emergency Alerts from FEMA via API on internet-connected nodes.
+- **NOAA EAS Alerts**: Get Emergency Alerts from NOAA via API.
+- **USGS Volcano Alerts**: Receive volcano alerts from USGS via API.
+- **NINA Alerts (Germany)**: Receive emergency alerts from the xrepository.de feed for Germany.
+- **Offline EAS Alerts**: Report EAS alerts over the mesh using external tools, even without internet.
+
+### File Monitor Alerts
+- **File Monitoring**: Watch a text file for changes and broadcast updates to the mesh channel.
+- **News File Access**: Retrieve the contents of a news file on request; supports multiple news sources or files.
+- **Shell Command Access**: Execute shell commands via DM with replay protection (admin only).
+
 #### Radio Frequency Monitoring
 - **SNR RF Activity Alerts**: Monitor radio frequencies and receive alerts when high SNR (Signal-to-Noise Ratio) activity is detected.
 - **Hamlib Integration**: Use Hamlib (rigctld) to monitor the S meter on a connected radio.
 - **Speech-to-Text Broadcasting**: Convert received audio to text using [Vosk](https://alphacephei.com/vosk/models) and broadcast it to the mesh.
 - **WSJT-X Integration**: Monitor WSJT-X (FT8, FT4, WSPR, etc.) decode messages and forward them to the mesh network with optional callsign filtering.
 - **JS8Call Integration**: Monitor JS8Call messages and forward them to the mesh network with optional callsign filtering.
+- **Meshages TTS**: The bot can speak mesh messages aloud using [KittenTTS](https://github.com/KittenML/KittenTTS). Enable this feature to have important alerts and messages read out loud on your device—ideal for hands-free operation or accessibility. See [radio.md](modules/radio.md) for setup instructions.
 
 ### Asset Tracking, Check-In/Check-Out, and Inventory Management
 Advanced check-in/check-out and asset tracking for people and equipment—ideal for accountability, safety monitoring, and logistics (e.g., Radio-Net, FEMA, trailhead groups). Admin approval workflows, GPS location capture, and overdue alerts. The integrated inventory and point-of-sale (POS) system enables item management, sales tracking, cart-based transactions, and daily reporting, for swaps, emergency supply management, and field operations, maker-places.
@@ -79,21 +93,8 @@ Advanced check-in/check-out and asset tracking for people and equipment—ideal
 - **User Feedback**: Users participate via DM; responses are logged for review.
 - **Reporting**: Retrieve survey results with `survey report` or `survey report <surveyname>`.
 
-### EAS Alerts
-- **FEMA iPAWS/EAS Alerts**: Receive Emergency Alerts from FEMA via API on internet-connected nodes.
-- **NOAA EAS Alerts**: Get Emergency Alerts from NOAA via API.
-- **USGS Volcano Alerts**: Receive volcano alerts from USGS via API.
-- **Offline EAS Alerts**: Report EAS alerts over the mesh using external tools, even without internet.
-- **NINA Alerts (Germany)**: Receive emergency alerts from the xrepository.de feed for Germany.
-
-### File Monitor Alerts
-- **File Monitoring**: Watch a text file for changes and broadcast updates to the mesh channel.
-- **News File Access**: Retrieve the contents of a news file on request; supports multiple news sources or files.
-- **Shell Command Access**: Execute shell commands via DM with replay protection (admin only).
-
 ### Data Reporting
 - **HTML Reports**: Visualize bot traffic and data flows with a built-in HTML generator. See [data reporting](logs/README.md) for details.
-- **RSS & News Feeds**: Receive news and data from multiple sources directly on the mesh.
 
 ### Robust Message Handling
 - **Automatic Message Chunking**: Messages over 160 characters are automatically split to ensure reliable delivery across multiple hops.

config.template

@@ -62,6 +62,12 @@ rssFeedURL = http://www.hackaday.com/rss.xml,http://rss.slashdot.org/Slashdot/sl
 rssFeedNames = default,slashdot,mesh
 rssMaxItems = 3
 rssTruncate = 100
+# enable or disable the headline command which uses NewsAPI.org key at https://newsapi.org/register
+enableNewsAPI = False
+newsAPI_KEY = 
+newsAPIregion = us
+# could also be 'relevancy' or 'popularity' or 'publishedAt'
+sort_by = relevancy
 
 # enable or disable the wikipedia search module
 wikipedia = True
@@ -203,13 +209,27 @@ useMetric = False
 # repeaterList lookup location (rbook / artsci / False)
 repeaterLookup = rbook
 
+# Satalite Pass Prediction
+# Register for free API https://www.n2yo.com/login/ personal data page at bottom 'Are you developer?'
+n2yoAPIKey = 
+# NORAD list https://www.n2yo.com/satellites/
+satList = 25544,7530
+
+# use Open-Meteo API for weather data not NOAA useful for non US locations
+UseMeteoWxAPI = False
+
 # NOAA weather forecast days
 NOAAforecastDuration = 3
 # number of weather alerts to display
 NOAAalertCount = 2
 
-# use Open-Meteo API for weather data not NOAA useful for non US locations
-UseMeteoWxAPI = False
+# NOAA Weather EAS Alert Broadcast
+wxAlertBroadcastEnabled = False
+#  Enable Ignore any message that includes following word list
+ignoreEASenable = False
+ignoreEASwords = test,advisory
+# Add extra location to the weather alert
+enableExtraLocationWx = False
 
 # NOAA Coastal Data Enable NOAA Coastal Waters Forecasts and Tide
 coastalEnabled = False
@@ -225,52 +245,40 @@ coastalForecastDays = 3
 # for multiple rivers use comma separated list e.g. 12484500,14105700
 riverList = 
 
-# NOAA EAS Alert Broadcast
-wxAlertBroadcastEnabled = False
-#  Enable Ignore any message that includes following word list
-ignoreEASenable = False
-ignoreEASwords = test,advisory
-# EAS Alert Broadcast Channels
-wxAlertBroadcastCh = 2
-# Add extra location to the weather alert
-enableExtraLocationWx = False
-
-# Goverment Alert Broadcast defaults to FEMA IPAWS
-eAlertBroadcastEnabled = False
+# USA FEMA IPAWS alerts
+ipawsAlertEnabled = True
 # comma separated list of FIPS codes to trigger local alert. find your FIPS codes at https://en.wikipedia.org/wiki/Federal_Information_Processing_Standard_state_code
 myFIPSList = 57,58,53
 # find your SAME https://www.weather.gov/nwr/counties comma separated list of SAME code to further refine local alert.
 mySAMEList = 053029,053073
-# Goverment Alert Broadcast Channels
-eAlertBroadcastCh = 2
 #  Enable Ignore, headline that includes following word list
 ignoreFEMAenable = True
 ignoreFEMAwords = test,exercise
 
 # USGS Volcano alerts Enable USGS Volcano Alert Broadcast
 volcanoAlertBroadcastEnabled = False
-volcanoAlertBroadcastCh = 2
 # Enable Ignore any message that includes following word list
 ignoreUSGSEnable = False
 ignoreUSGSWords = test,advisory
 
-# Use DE Alert Broadcast Data
+# Use Germany/DE Alert Broadcast Data
 enableDEalerts = False
 # comma separated list of regional codes trigger local alert.
 # find your regional codet at https://www.xrepository.de/api/xrepository/urn:de:bund:destatis:bevoelkerungsstatistik:schluessel:rs_2021-07-31/download/Regionalschl_ssel_2021-07-31.json
 myRegionalKeysDE = 110000000000,120510000000
 
-# Satalite Pass Prediction
-# Register for free API https://www.n2yo.com/login/ personal data page at bottom 'Are you developer?'
-n2yoAPIKey = 
-# NORAD list https://www.n2yo.com/satellites/
-satList = 25544,7530
+# Alerts are sent to the emergency_handler interface and channel duplicate messages are send here if set
+eAlertBroadcastCh = 
 
 # CheckList Checkin/Checkout
 [checklist]
 enabled = False
 checklist_db = data/checklist.db
 reverse_in_out = False
+# Auto approve new checklists
+auto_approve = True
+# Check-in reminder interval is 5min
+# Checkin broadcast interface and channel is emergency_handler interface and channel
 
 # Inventory and Point of Sale System
 [inventory]
@@ -355,6 +363,10 @@ voxTrapList = chirpy
 # allow use of 'weather' and 'joke' commands via VOX
 voxEnableCmd = True
 
+# Meshages Text-to-Speech (TTS) for incoming messages and DM
+meshagesTTS = False
+ttsChannels = 2
+
 # WSJT-X UDP monitoring - listens for decode messages from WSJT-X, FT8/FT4/WSPR etc.
 wsjtxDetectionEnabled = False
 # UDP address and port where WSJT-X broadcasts (default: 127.0.0.1:2237)

etc/mesh_bot.tmp

@@ -22,7 +22,7 @@ Environment=SSL_CERT_FILE=/etc/ssl/certs/ca-certificates.crt
 Environment=PYTHONUNBUFFERED=1
 
 Restart=on-failure
-Type=notify #try simple if any problems
+
 
 [Install]
 WantedBy=default.target

etc/mesh_bot_reporting.tmp

@@ -23,7 +23,6 @@ ExecStop=pkill -f report_generator5.py
 Environment=PYTHONUNBUFFERED=1
 
 Restart=on-failure
-Type=notify #try simple if any problems
 
 [Install]
 WantedBy=timers.target

etc/pong_bot.tmp

@@ -22,7 +22,6 @@ Environment=SSL_CERT_FILE=/etc/ssl/certs/ca-certificates.crt
 Environment=PYTHONUNBUFFERED=1
 
 Restart=on-failure
-Type=notify #try simple if any problems
 
 [Install]
 WantedBy=default.target

install.sh

@@ -285,15 +285,6 @@ sudo usermod -a -G tty "$whoami"
 sudo usermod -a -G bluetooth "$whoami"
 echo "Added user $whoami to dialout, tty, and bluetooth groups"
 
-sudo chown -R "$whoami:$whoami" "$program_path/logs"
-sudo chown -R "$whoami:$whoami" "$program_path/data"
-sudo chown "$whoami:$whoami" "$program_path/config.ini"
-sudo chmod 640 "$program_path/config.ini"
-echo "Permissions set for meshbot on config.ini"
-sudo chmod 750 "$program_path/logs"
-sudo chmod 750 "$program_path/data"
-echo "Permissions set for meshbot on logs and data directories"
-
 # check and see if some sort of NTP is running
 if ! systemctl is-active --quiet ntp.service && \
    ! systemctl is-active --quiet systemd-timesyncd.service && \
@@ -321,17 +312,17 @@ if [[ $(echo "${bot}" | grep -i "^m") ]]; then
 fi
 
 # install mesh_bot_reporting timer to run daily at 4:20 am
-# echo ""
-# echo "Installing mesh_bot_reporting.timer to run mesh_bot_reporting daily at 4:20 am..."
-# sudo cp etc/mesh_bot_reporting.service /etc/systemd/system/
-# sudo cp etc/mesh_bot_reporting.timer /etc/systemd/system/
-# sudo systemctl daemon-reload
-# sudo systemctl enable mesh_bot_reporting.timer
-# sudo systemctl start mesh_bot_reporting.timer
-# echo "mesh_bot_reporting.timer installed and enabled"
-# echo "Check timer status with: systemctl status mesh_bot_reporting.timer"
-# echo "List all timers with: systemctl list-timers"
-# echo ""
+echo ""
+echo "Installing mesh_bot_reporting.timer to run mesh_bot_reporting daily at 4:20 am..."
+sudo cp etc/mesh_bot_reporting.service /etc/systemd/system/
+sudo cp etc/mesh_bot_reporting.timer /etc/systemd/system/
+sudo systemctl daemon-reload
+sudo systemctl enable mesh_bot_reporting.timer
+sudo systemctl start mesh_bot_reporting.timer
+echo "mesh_bot_reporting.timer installed and enabled"
+echo "Check timer status with: systemctl status mesh_bot_reporting.timer"
+echo "List all timers with: systemctl list-timers"
+echo ""
 
 # # install mesh_bot_w3_server service
 # echo "Installing mesh_bot_w3_server.service to run the web3 server..."
@@ -468,6 +459,15 @@ else
     printf "*** Stay Up to date using 'bash update.sh' ***\n" >> install_notes.txt
 fi
 
+sudo chown -R "$whoami:$whoami" "$program_path/logs"
+sudo chown -R "$whoami:$whoami" "$program_path/data"
+sudo chown "$whoami:$whoami" "$program_path/config.ini"
+sudo chmod 640 "$program_path/config.ini"
+echo "Permissions set for meshbot on config.ini"
+sudo chmod 750 "$program_path/logs"
+sudo chmod 750 "$program_path/data"
+echo "Permissions set for meshbot on logs and data directories"
+
 printf "\nInstallation complete?\n"
 
 exit 0

mesh_bot.py

@@ -40,10 +40,10 @@ def auto_response(message, snr, rssi, hop, pkiStatus, message_from_id, channel_n
     "bbspost": lambda: handle_bbspost(message, message_from_id, deviceID),
     "bbsread": lambda: handle_bbsread(message),
     "blackjack": lambda: handleBlackJack(message, message_from_id, deviceID),
+    "approvecl": lambda: handle_checklist(message, message_from_id, deviceID),
+    "denycl": lambda: handle_checklist(message, message_from_id, deviceID),
     "checkin": lambda: handle_checklist(message, message_from_id, deviceID),
     "checklist": lambda: handle_checklist(message, message_from_id, deviceID),
-    "checklistapprove": lambda: handle_checklist(message, message_from_id, deviceID),
-    "checklistdeny": lambda: handle_checklist(message, message_from_id, deviceID),
     "checkout": lambda: handle_checklist(message, message_from_id, deviceID),
     "chess": lambda: handle_gTnW(chess=True),
     "clearsms": lambda: handle_sms(message_from_id, message),
@@ -84,6 +84,7 @@ def auto_response(message, snr, rssi, hop, pkiStatus, message_from_id, channel_n
     "cartremove": lambda: handle_inventory(message, message_from_id, deviceID),
     "cartsell": lambda: handle_inventory(message, message_from_id, deviceID),
     "joke": lambda: tell_joke(message_from_id),
+    "latest": lambda: get_newsAPI(message),
     "leaderboard": lambda: get_mesh_leaderboard(message, message_from_id, deviceID),
     "lemonstand": lambda: handleLemonade(message, message_from_id, deviceID),
     "lheard": lambda: handle_lheard(message, message_from_id, deviceID, isDM),
@@ -96,8 +97,6 @@ def auto_response(message, snr, rssi, hop, pkiStatus, message_from_id, channel_n
     "ping": lambda: handle_ping(message_from_id, deviceID, message, hop, snr, rssi, isDM, channel_number),
     "pinging": lambda: handle_ping(message_from_id, deviceID, message, hop, snr, rssi, isDM, channel_number),
     "pong": lambda: "🏓PING!!🛜",
-    "purgein": lambda: handle_checklist(message, message_from_id, deviceID),
-    "purgeout": lambda: handle_checklist(message, message_from_id, deviceID),
     "q:": lambda: quizHandler(message, message_from_id, deviceID),
     "quiz": lambda: quizHandler(message, message_from_id, deviceID),
     "readnews": lambda: handleNews(message_from_id, deviceID, message, isDM),
@@ -1541,6 +1540,9 @@ def handle_boot(mesh=True):
             
             if my_settings.solar_conditions_enabled:
                 logger.debug("System: Celestial Telemetry Enabled")
+
+            if my_settings.meshagesTTS:
+                logger.debug("System: Meshages TTS Text-to-Speech Enabled")
             
             if my_settings.location_enabled:
                 if my_settings.use_meteo_wxApi:
@@ -1559,15 +1561,17 @@ def handle_boot(mesh=True):
             
             if my_settings.wikipedia_enabled:
                 if my_settings.use_kiwix_server:
-                    logger.debug(f"System: Wikipedia search Enabled using Kiwix server at {kiwix_url}")
+                    logger.debug(f"System: Wikipedia search Enabled using Kiwix server at {my_settings.kiwix_url}")
                 else:
                     logger.debug("System: Wikipedia search Enabled")
             
             if my_settings.rssEnable:
-                logger.debug(f"System: RSS Feed Reader Enabled for feeds: {rssFeedNames}")
+                logger.debug(f"System: RSS Feed Reader Enabled for feeds: {my_settings.rssFeedNames}")
+            if my_settings.enable_headlines:
+                logger.debug("System: News Headlines Enabled from NewsAPI.org")
             
             if my_settings.radio_detection_enabled:
-                logger.debug(f"System: Radio Detection Enabled using rigctld at {my_settings.rigControlServerAddress} broadcasting to channels: {my_settings.sigWatchBroadcastCh} for {get_freq_common_name(get_hamlib('f'))}")
+                logger.debug(f"System: Radio Detection Enabled using rigctld at {my_settings.rigControlServerAddress} broadcasting to channels: {my_settings.sigWatchBroadcastCh}")
             
             if my_settings.file_monitor_enabled:
                 logger.warning(f"System: File Monitor Enabled for {my_settings.file_monitor_file_path}, broadcasting to channels: {my_settings.file_monitor_broadcastCh}")
@@ -1578,21 +1582,21 @@ def handle_boot(mesh=True):
             if my_settings.read_news_enabled:
                 logger.debug(f"System: File Monitor News Reader Enabled for {my_settings.news_file_path}")
             if my_settings.bee_enabled:
-                logger.debug("System: File Monitor Bee Monitor Enabled for bee.txt")
-            
-            if my_settings.wxAlertBroadcastEnabled:
-                logger.debug(f"System: Weather Alert Broadcast Enabled on channels {my_settings.wxAlertBroadcastChannel}")
-            
-            if my_settings.emergencyAlertBrodcastEnabled:
-                logger.debug(f"System: Emergency Alert Broadcast Enabled on channels {my_settings.emergencyAlertBroadcastCh} for FIPS codes {my_settings.myStateFIPSList}")
-                if my_settings.myStateFIPSList == ['']:
-                    logger.warning("System: No FIPS codes set for iPAWS Alerts")
-            
-            if my_settings.emergency_responder_enabled:
-                logger.debug(f"System: Emergency Responder Enabled on channels {my_settings.emergency_responder_alert_channel} for interface {my_settings.emergency_responder_alert_interface}")
-            
+                logger.debug("System: File Monitor Bee Monitor Enabled for 🐝bee.txt")
+            if my_settings.usAlerts:
+                logger.debug(f"System: Emergency Alert Broadcast Enabled on channel {my_settings.emergency_responder_alert_channel} for interface {my_settings.emergency_responder_alert_interface}")
+            if my_settings.enableDEalerts:
+                logger.debug(f"System: NINA Alerts Enabled with counties {my_settings.myRegionalKeysDE}")
             if my_settings.volcanoAlertBroadcastEnabled:
-                logger.debug(f"System: Volcano Alert Broadcast Enabled on channels {my_settings.volcanoAlertBroadcastChannel}")
+                logger.debug(f"System: Volcano Alert Broadcast Enabled on channels {my_settings.emergency_responder_alert_channel} ignoreUSGSWords {my_settings.ignoreUSGSWords}")
+            if my_settings.ipawsAlertEnabled:
+                logger.debug(f"System: iPAWS Alerts Enabled with FIPS codes {my_settings.myStateFIPSList} ignorelist {my_settings.ignoreFEMAwords}")
+            if my_settings.enableDEalerts:
+                logger.debug(f"System: NINA Alerts Enabled with counties {my_settings.myRegionalKeysDE}")
+            if my_settings.wxAlertBroadcastEnabled:
+                logger.debug(f"System: Weather Alert Broadcast Enabled on channels {my_settings.emergency_responder_alert_channel} ignoreEASwords {my_settings.ignoreEASwords}")
+            if my_settings.emergency_responder_enabled:
+                logger.debug(f"System: Emergency Responder Enabled on channels {my_settings.emergency_responder_alert_channel}")
             
             if my_settings.qrz_hello_enabled:
                 if my_settings.train_qrz:
@@ -1889,7 +1893,13 @@ def onReceive(packet, interface):
                                 else:
                                     # respond with help message on DM
                                     send_message(help_message, channel_number, message_from_id, rxNode)
-
+                    
+                    # add message to tts queue
+                    if meshagesTTS:
+                        # add to the tts_read_queue
+                        readMe = f"DM from {get_name_from_number(message_from_id, 'short', rxNode)}: {message_string}"
+                        tts_read_queue.append(readMe)
+                        
                     # log the message to the message log
                     if log_messages_to_file:
                         msgLogger.info(f"Device:{rxNode} Channel:{channel_number} | {get_name_from_number(message_from_id, 'long', rxNode)} | DM | " + message_string.replace('\n', '-nl-'))
@@ -1993,6 +2003,12 @@ def onReceive(packet, interface):
                         if slotMachine:
                             msg = f"🎉 {get_name_from_number(message_from_id, 'long', rxNode)} played the Slot Machine and got: {slotMachine} 🥳"
                             send_message(msg, channel_number, 0, rxNode)
+
+                    # add message to tts queue
+                    if my_settings.meshagesTTS and channel_number == my_settings.ttsChannels:
+                        # add to the tts_read_queue
+                        readMe = f"DM from {get_name_from_number(message_from_id, 'short', rxNode)}: {message_string}"
+                        tts_read_queue.append(readMe)
         else:
             # Evaluate non TEXT_MESSAGE_APP packets
             consumeMetadata(packet, rxNode, channel_number)
@@ -2044,7 +2060,11 @@ async def main():
             tasks.append(asyncio.create_task(handleSignalWatcher(), name="hamlib"))
 
         if my_settings.voxDetectionEnabled:
+            from modules.radio import voxMonitor
             tasks.append(asyncio.create_task(voxMonitor(), name="vox_detection"))
+
+        if my_settings.meshagesTTS:
+            tasks.append(asyncio.create_task(handleTTS(), name="tts_handler"))
         
         if my_settings.wsjtx_detection_enabled:
             tasks.append(asyncio.create_task(handleWsjtxWatcher(), name="wsjtx_monitor"))

modules/README.md

@@ -139,8 +139,8 @@ The checklist module provides asset tracking and accountability features with sa
 | `checkin`    | Check in a node/asset                         |
 | `checkout`   | Check out a node/asset                        |
 | `checklist`  | Show active check-ins                         |
-| `purgein`    | Delete your check-in record                   |
-| `purgeout`   | Delete your check-out record                  |
+| `approvecl`  | Admin Approve id                              |
+| `denycl`     | Admin Remove id                               |
 
 #### Advanced Features
 
@@ -150,8 +150,8 @@ The checklist module provides asset tracking and accountability features with sa
   - Ideal for solo activities, remote work, or safety accountability
 
 - **Approval Workflow**
-  - `checklistapprove <id>` - Approve a pending check-in (admin)
-  - `checklistdeny <id>` - Deny/remove a check-in (admin)
+  - `approvecl <id>` - Approve a pending check-in (admin)
+  - `denycl <id>` - Deny/remove a check-in (admin)
 
 more at [modules/checklist.md](modules/checklist.md)
 
@@ -475,7 +475,62 @@ Configure in `[wikipedia]` section of `config.ini`.
 
 ---
 
+## News & Headlines (`latest` Command)
 
+The `latest` command allows you to fetch current news headlines or articles on any topic using the NewsAPI integration. This is useful for quickly checking the latest developments on a subject, even from the mesh.
+
+### Usage
+
+- **Get the latest headlines on a topic:**
+  ```
+  latest <topic>
+  ```
+  Example:
+  ```
+  latest meshtastic
+  ```
+  This will return the most recent news articles about "meshtastic".
+
+- **General latest news:**
+  ```
+  latest
+  ```
+  Returns the latest general news headlines.
+
+### How It Works
+
+- The bot queries NewsAPI.org for the most recent articles matching your topic.
+- Each result includes the article title and a short description.
+
+You need to go register for the developer key and read terms of use.
+
+```ini
+# enable or disable the headline command which uses NewsAPI.org 
+enableNewsAPI = True
+newsAPI_KEY = key at https://newsapi.org/register
+newsAPIregion = us
+```
+
+### Example Output
+
+```
+🗞️:📰Meshtastic project launches new firmware
+The open-source mesh radio project Meshtastic has released a major firmware update...
+
+📰How Meshtastic is changing off-grid communication
+A look at how Meshtastic devices are being used for emergency response...
+
+📰Meshtastic featured at DEF CON 2025
+The Meshtastic team presented new features at DEF CON, drawing large crowds...
+```
+
+### Notes
+
+- You can search for any topic, e.g., `latest wildfire`, `latest ham radio`, etc.
+- The number of results can be adjusted in the configuration.
+- Requires internet access for the bot to fetch news.
+
+___
 ## DX Spotter Module
 
 The DX Spotter module allows you to fetch and display recent DX cluster spots from [spothole.app](https://spothole.app) directly in your mesh-bot.
@@ -972,7 +1027,6 @@ This uses USA: SAME, FIPS, to locate the alerts in the feed. By default ignoring
 
 ```ini
 eAlertBroadcastEnabled = False # Goverment IPAWS/CAP Alert Broadcast
-eAlertBroadcastCh = 2,3 # Goverment Emergency IPAWS/CAP Alert Broadcast Channels
 ignoreFEMAenable = True # Ignore any headline that includes followig word list
 ignoreFEMAwords = test,exercise
 # comma separated list of FIPS codes to trigger local alert. find your FIPS codes at https://en.wikipedia.org/wiki/Federal_Information_Processing_Standard_state_code

modules/checklist.md

@@ -26,7 +26,6 @@ The enhanced checklist module provides asset tracking and accountability feature
 ### 📍 Location Tracking
 - Automatic GPS location capture when checking in/out
 - View last known location in checklist
-- Track movement over time
 
 - **Time Window Monitoring**: Check-in with safety intervals (e.g., `checkin 60 Hunting in tree stand`)
   - Tracks if users don't check in within expected timeframe
@@ -34,20 +33,65 @@ The enhanced checklist module provides asset tracking and accountability feature
   - Provides `get_overdue_checkins()` function for alert integration
 
 - **Approval Workflow**:
-  - `checklistapprove <id>` - Approve pending check-ins (admin)
-  - `checklistdeny <id>` - Deny/remove check-ins (admin)
+  - `clok <id>` - Approve pending check-ins (admin)
+  - `denycl <id>` - Deny/remove check-ins (admin)
   - Support for approval-based workflows
 
-- **Enhanced Database Schema**:
-  - Added `approved` field for approval workflows
-  - Added `expected_checkin_interval` field for safety monitoring
-  - Automatic migration for existing databases
-
 #### New Commands:
-- `checklistapprove <id>` - Approve a check-in
-- `checklistdeny <id>` - Deny a check-in
+- `clok <id>` - Approve a check-in
+- `denycl <id>` - Deny a check-in
 - Enhanced `checkin [interval] [note]` - Now supports interval parameter
 
+### Enhanced Check Out Options
+
+You can now check out in three ways:
+
+#### 1. Check Out the Most Recent Active Check-in
+```
+checkout [notes]
+```
+Checks out your most recent active check-in.  
+*Example:*
+```
+checkout Heading back to camp
+```
+
+#### 2. Check Out All Active Check-ins
+```
+checkout all [notes]
+```
+Checks out **all** of your active check-ins at once.  
+*Example:*
+```
+checkout all Done for the day
+```
+*Response:*
+```
+Checked out 2 check-ins for Hunter1. Durations: 01:23:45, 00:15:30
+```
+
+#### 3. Check Out a Specific Check-in by ID
+```
+checkout <checkin_id> [notes]
+```
+Checks out a specific check-in using its ID (as shown in the `checklist` command).  
+*Example:*
+```
+checkout 123 Leaving early
+```
+*Response:*
+```
+Checked out check-in ID 123 for Hunter1. Duration: 00:45:12
+```
+
+**Tip:**  
+- Use `checklist` to see your current check-in IDs and durations.
+- You can always add a note to any checkout command for context.
+
+---
+
+These options allow you to manage your check-ins more flexibly, whether you want to check out everything at once or just a specific session.
+
 ## Configuration
 
 Add to your `config.ini`:
@@ -106,38 +150,31 @@ ID: Hunter1 checked-In for 01:23:45📝Solo hunting
 ID: Tech2 checked-In for 00:15:30📝Equipment repair
 ```
 
-#### Purge Records
-```
-purgein    # Delete your check-in record
-purgeout   # Delete your check-out record
-```
-
-Use these to manually remove your records if needed.
 
 ### Admin Commands
 
 #### Approve Check-in
 ```
-checklistapprove <checkin_id>
+approvecl <checkin_id>
 ```
 
 Approve a pending check-in (requires admin privileges).
 
 **Example:**
 ```
-checklistapprove 123
+approvecl 123
 ```
 
 #### Deny Check-in
 ```
-checklistdeny <checkin_id>
+denycl <checkin_id>
 ```
 
 Deny and remove a check-in (requires admin privileges).
 
 **Example:**
 ```
-checklistdeny 456
+denycl 456
 ```
 
 ## Safety Monitoring Feature
@@ -153,7 +190,7 @@ checkin 60 Hunting in remote area
 This tells the system:
 - You're checking in now
 - You expect to check in again or check out within 60 minutes
-- If 60 minutes pass without activity, you'll be marked as overdue
+- If 60 minutes pass without activity, you'll be marked as overdue alert
 
 ### Use Cases for Time Intervals
 
@@ -174,14 +211,17 @@ This tells the system:
 
 4. **Check-in Points**: Regular status updates during long operations
    ```
-   checkin 15 Descending cliff face
+   checkin 15 Descending cliff 
+   ```
+
+5. **Check-in a reminder**: Reminders to check in on something like a pot roast
+   ```
+   checkin 30 🍠🍖
    ```
 
 ### Overdue Check-ins
 
-The system tracks all check-ins with time intervals and can identify who is overdue. The module provides the `get_overdue_checkins()` function that returns a list of overdue users. 
-
-**Note**: Automatic alerts for overdue check-ins require integration with the bot's scheduler or alert system. The checklist module provides the detection capability, but sending notifications must be configured separately through the main bot's alert features.
+The system tracks all check-ins with time intervals and can identify who is overdue. The module provides the `get_overdue_checkins()` function that returns a list of overdue users. It alerts on the 20min watchdog.
 
 ## Practical Examples
 
@@ -258,15 +298,12 @@ checkin 45 Site survey tower location 2
 
 The checklist system automatically captures GPS coordinates when available. This can be used for:
 - Tracking last known position
-- Geo-fencing applications
-- Emergency response coordination
 - Asset location management
 
 ### Alert Systems
 
 The overdue check-in feature can trigger:
 - Notifications to supervisors
-- Emergency alerts
 - Automated messages to response teams
 - Email/SMS notifications (if configured)
 
@@ -274,9 +311,7 @@ The overdue check-in feature can trigger:
 
 Combine with the scheduler module to:
 - Send reminders to check in
-- Automatically generate reports
 - Schedule periodic check-in requirements
-- Send daily summaries
 
 ## Best Practices
 
@@ -306,6 +341,17 @@ Combine with the scheduler module to:
    checklist
    ```
 
+   The list will show ✅  approved and ☑️ unapproved
+   The alarm will only alert on approved.
+
+   in config.ini 
+   ```ini
+   # Auto approve new checklists
+   auto_approve = True
+   # Check-in reminder interval is 5min
+   # Checkin broadcast interface and channel is emergency_handler interface and channel
+   ```
+
 2. **Respond to Overdue Situations**: Act on overdue check-ins promptly
 
 3. **Set Clear Policies**: Establish when and how to use the system

modules/checklist.py

@@ -3,69 +3,50 @@
 
 import sqlite3
 from modules.log import logger
-from modules.settings import checklist_db, reverse_in_out, bbs_ban_list
+from modules.settings import checklist_db, reverse_in_out, bbs_ban_list, bbs_admin_list, checklist_auto_approve
 import time
 
-trap_list_checklist = ("checkin", "checkout", "checklist", "purgein", "purgeout", 
-                       "checklistapprove", "checklistdeny", "checklistadd", "checklistremove")
+trap_list_checklist = ("checkin", "checkout", "checklist", "approvecl", "denycl",)
 
 def initialize_checklist_database():
     try:
         conn = sqlite3.connect(checklist_db)
         c = conn.cursor()
-        # Check if the checkin table exists, and create it if it doesn't
         logger.debug("System: Checklist: Initializing database...")
         c.execute('''CREATE TABLE IF NOT EXISTS checkin
                      (checkin_id INTEGER PRIMARY KEY, checkin_name TEXT, checkin_date TEXT, 
                       checkin_time TEXT, location TEXT, checkin_notes TEXT, 
-                      approved INTEGER DEFAULT 1, expected_checkin_interval INTEGER DEFAULT 0)''')
-        # Check if the checkout table exists, and create it if it doesn't
+                      approved INTEGER DEFAULT 1, expected_checkin_interval INTEGER DEFAULT 0,
+                      removed INTEGER DEFAULT 0)''')
         c.execute('''CREATE TABLE IF NOT EXISTS checkout
                      (checkout_id INTEGER PRIMARY KEY, checkout_name TEXT, checkout_date TEXT, 
-                      checkout_time TEXT, location TEXT, checkout_notes TEXT)''')
-        
-        # Add new columns if they don't exist (for migration)
-        try:
-            c.execute("ALTER TABLE checkin ADD COLUMN approved INTEGER DEFAULT 1")
-        except sqlite3.OperationalError:
-            pass  # Column already exists
-        
-        try:
-            c.execute("ALTER TABLE checkin ADD COLUMN expected_checkin_interval INTEGER DEFAULT 0")
-        except sqlite3.OperationalError:
-            pass  # Column already exists
-        
-        try:
-            c.execute("ALTER TABLE checkin ADD COLUMN removed INTEGER DEFAULT 0")
-        except sqlite3.OperationalError:
-            pass  # Column already exists
-        
-        # Add this to your DB init (if not already present)
-        try:
-            c.execute("ALTER TABLE checkout ADD COLUMN removed INTEGER DEFAULT 0")
-        except sqlite3.OperationalError:
-            pass  # Column already exists
-        
+                      checkout_time TEXT, location TEXT, checkout_notes TEXT,
+                      checkin_id INTEGER, removed INTEGER DEFAULT 0)''')
         conn.commit()
         conn.close()
         return True
     except Exception as e:
-        logger.error(f"Checklist: Failed to initialize database: {e}")
+        logger.error(f"Checklist: Failed to initialize database: {e} Please delete old checklist database file. rm data/checklist.db")
         return False
 
 def checkin(name, date, time, location, notes):
     location = ", ".join(map(str, location))
-    # checkin a user
+    # Auto-approve if setting is enabled
+    approved_value = 1 if checklist_auto_approve else 0
     conn = sqlite3.connect(checklist_db)
     c = conn.cursor()
     try:
-        c.execute("INSERT INTO checkin (checkin_name, checkin_date, checkin_time, location, checkin_notes) VALUES (?, ?, ?, ?, ?)", (name, date, time, location, notes))
-        # # remove any checkouts that are older than the checkin
-        # c.execute("DELETE FROM checkout WHERE checkout_date < ? OR (checkout_date = ? AND checkout_time < ?)", (date, date, time))
+        c.execute(
+            "INSERT INTO checkin (checkin_name, checkin_date, checkin_time, location, checkin_notes, removed, approved) VALUES (?, ?, ?, ?, ?, 0, ?)",
+            (name, date, time, location, notes, approved_value)
+        )
     except sqlite3.OperationalError as e:
         if "no such table" in str(e):
             initialize_checklist_database()
-            c.execute("INSERT INTO checkin (checkin_name, checkin_date, checkin_time, location, checkin_notes) VALUES (?, ?, ?, ?, ?)", (name, date, time, location, notes))
+            c.execute(
+                "INSERT INTO checkin (checkin_name, checkin_date, checkin_time, location, checkin_notes, removed, approved) VALUES (?, ?, ?, ?, ?, 0, ?)",
+                (name, date, time, location, notes, approved_value)
+            )
         else:
             raise
     conn.commit()
@@ -75,71 +56,90 @@ def checkin(name, date, time, location, notes):
     else:
         return "Checked✅In: " + str(name)
 
-def delete_checkin(checkin_id):
-    # delete a checkin
-    conn = sqlite3.connect(checklist_db)
-    c = conn.cursor()
-    c.execute("DELETE FROM checkin WHERE checkin_id = ?", (checkin_id,))
-    conn.commit()
-    conn.close()
-    return "Checkin deleted." + str(checkin_id)
-
-def checkout(name, date, time_str, location, notes):
+def checkout(name, date, time_str, location, notes, all=False, checkin_id=None):
     location = ", ".join(map(str, location))
-    checkin_record = None  # Ensure variable is always defined
     conn = sqlite3.connect(checklist_db)
     c = conn.cursor()
+    checked_out_ids = []
+    durations = []
     try:
-        # Check if the user has a checkin before checking out
-        c.execute("""
-            SELECT checkin_id FROM checkin 
-            WHERE checkin_name = ? 
-            AND NOT EXISTS (
-            SELECT 1 FROM checkout 
-            WHERE checkout_name = checkin_name 
-            AND (checkout_date > checkin_date OR (checkout_date = checkin_date AND checkout_time > checkin_time))
-            )
-            ORDER BY checkin_date DESC, checkin_time DESC 
-            LIMIT 1
-        """, (name,))
-        checkin_record = c.fetchone()
-        if checkin_record:
-            c.execute("INSERT INTO checkout (checkout_name, checkout_date, checkout_time, location, checkout_notes) VALUES (?, ?, ?, ?, ?)", (name, date, time_str, location, notes))
-            # calculate length of time checked in
-            c.execute("SELECT checkin_time, checkin_date FROM checkin WHERE checkin_id = ?", (checkin_record[0],))
-            checkin_time, checkin_date = c.fetchone()
-            checkin_datetime = time.strptime(checkin_date + " " + checkin_time, "%Y-%m-%d %H:%M:%S")
-            time_checked_in_seconds = time.time() - time.mktime(checkin_datetime)
-            timeCheckedIn = time.strftime("%H:%M:%S", time.gmtime(time_checked_in_seconds))
-            # # remove the checkin record older than the checkout
-            # c.execute("DELETE FROM checkin WHERE checkin_date < ? OR (checkin_date = ? AND checkin_time < ?)", (date, date, time_str))
+        if checkin_id is not None:
+            # Check out a specific check-in by ID
+            c.execute("""
+                SELECT checkin_id, checkin_time, checkin_date FROM checkin
+                WHERE checkin_id = ? AND checkin_name = ?
+            """, (checkin_id, name))
+            row = c.fetchone()
+            if row:
+                c.execute("INSERT INTO checkout (checkout_name, checkout_date, checkout_time, location, checkout_notes, checkin_id) VALUES (?, ?, ?, ?, ?, ?)",
+                          (name, date, time_str, location, notes, row[0]))
+                checkin_time, checkin_date = row[1], row[2]
+                checkin_datetime = time.strptime(checkin_date + " " + checkin_time, "%Y-%m-%d %H:%M:%S")
+                time_checked_in_seconds = time.time() - time.mktime(checkin_datetime)
+                durations.append(time.strftime("%H:%M:%S", time.gmtime(time_checked_in_seconds)))
+                checked_out_ids.append(row[0])
+        elif all:
+            # Check out all active check-ins for this user
+            c.execute("""
+                SELECT checkin_id, checkin_time, checkin_date FROM checkin 
+                WHERE checkin_name = ? 
+                AND removed = 0
+                AND checkin_id NOT IN (
+                    SELECT checkin_id FROM checkout WHERE checkin_id IS NOT NULL
+                )
+            """, (name,))
+            rows = c.fetchall()
+            for row in rows:
+                c.execute("INSERT INTO checkout (checkout_name, checkout_date, checkout_time, location, checkout_notes, checkin_id) VALUES (?, ?, ?, ?, ?, ?)",
+                          (name, date, time_str, location, notes, row[0]))
+                checkin_time, checkin_date = row[1], row[2]
+                checkin_datetime = time.strptime(checkin_date + " " + checkin_time, "%Y-%m-%d %H:%M:%S")
+                time_checked_in_seconds = time.time() - time.mktime(checkin_datetime)
+                durations.append(time.strftime("%H:%M:%S", time.gmtime(time_checked_in_seconds)))
+                checked_out_ids.append(row[0])
+        else:
+            # Default: check out the most recent active check-in
+            c.execute("""
+                SELECT checkin_id, checkin_time, checkin_date FROM checkin 
+                WHERE checkin_name = ? 
+                AND removed = 0
+                AND checkin_id NOT IN (
+                    SELECT checkin_id FROM checkout WHERE checkin_id IS NOT NULL
+                )
+                ORDER BY checkin_date DESC, checkin_time DESC 
+                LIMIT 1
+            """, (name,))
+            row = c.fetchone()
+            if row:
+                c.execute("INSERT INTO checkout (checkout_name, checkout_date, checkout_time, location, checkout_notes, checkin_id) VALUES (?, ?, ?, ?, ?, ?)",
+                          (name, date, time_str, location, notes, row[0]))
+                checkin_time, checkin_date = row[1], row[2]
+                checkin_datetime = time.strptime(checkin_date + " " + checkin_time, "%Y-%m-%d %H:%M:%S")
+                time_checked_in_seconds = time.time() - time.mktime(checkin_datetime)
+                durations.append(time.strftime("%H:%M:%S", time.gmtime(time_checked_in_seconds)))
+                checked_out_ids.append(row[0])
     except sqlite3.OperationalError as e:
         if "no such table" in str(e):
             conn.close()
             initialize_checklist_database()
-            # Try again after initializing
-            return checkout(name, date, time_str, location, notes)
+            return checkout(name, date, time_str, location, notes, all=all, checkin_id=checkin_id)
         else:
             conn.close()
             raise
     conn.commit()
     conn.close()
-    if checkin_record:
-        if reverse_in_out:
-            return "Checked⌛️In: " + str(name) + " duration " + timeCheckedIn
+    if checked_out_ids:
+        if all:
+            return f"Checked out {len(checked_out_ids)} check-ins for {name}. Durations: {', '.join(durations)}"
+        elif checkin_id is not None:
+            return f"Checked out check-in ID {checkin_id} for {name}. Duration: {durations[0]}"
         else:
-            return "Checked⌛️Out: " + str(name) + " duration " + timeCheckedIn
+            if reverse_in_out:
+                return f"Checked⌛️In: {name} duration {durations[0]}"
+            else:
+                return f"Checked⌛️Out: {name} duration {durations[0]}"
     else:
-        return "None found for " + str(name)
-
-def delete_checkout(checkout_id):
-    # delete a checkout
-    conn = sqlite3.connect(checklist_db)
-    c = conn.cursor()
-    c.execute("DELETE FROM checkout WHERE checkout_id = ?", (checkout_id,))
-    conn.commit()
-    conn.close()
-    return "Checkout deleted." + str(checkout_id)
+        return f"None found for {name}"
 
 def approve_checkin(checkin_id):
     """Approve a pending check-in"""
@@ -254,25 +254,27 @@ def get_overdue_checkins():
         return []
 
 def format_overdue_alert():
+    header = "⚠️ OVERDUE CHECK-INS:\a\n"
+    alert = ""
     try:
         """Format overdue check-ins as an alert message"""
         overdue = get_overdue_checkins()
-        logger.debug(f"Overdue check-ins: {overdue}")  # Add this line
         if not overdue:
             return None
-        
-        alert = "⚠️ OVERDUE CHECK-INS:\n"
         for entry in overdue:
             hours = entry['overdue_minutes'] // 60
             minutes = entry['overdue_minutes'] % 60
-            alert += f"{entry['name']}: {hours}h {minutes}m overdue"
+            if hours > 0:
+                alert += f"{entry['name']}: {hours}h {minutes}m overdue"
+            else:
+                alert += f"{entry['name']}: {minutes}m overdue"
             # if entry['location']:
             #     alert += f" @ {entry['location']}"
             if entry['checkin_notes']:
                 alert += f" 📝{entry['checkin_notes']}"
             alert += "\n"
-        
-        return alert.rstrip()
+        if alert:
+            return header + alert.rstrip()
     except Exception as e:
         logger.error(f"Checklist: Error formatting overdue alert: {e}")
         return None
@@ -285,9 +287,9 @@ def list_checkin():
         c.execute("""
             SELECT * FROM checkin
             WHERE removed = 0
-            AND checkin_id NOT IN (
-                SELECT checkin_id FROM checkout
-                WHERE checkout_date > checkin_date OR (checkout_date = checkin_date AND checkout_time > checkin_time)
+            AND NOT EXISTS (
+                SELECT 1 FROM checkout
+                WHERE checkout.checkin_id = checkin.checkin_id
             )
         """)
         rows = c.fetchall()
@@ -298,12 +300,16 @@ def list_checkin():
             return list_checkin()
         else:
             conn.close()
-            logger.error(f"Checklist: Error listing checkins: {e}")
+            initialize_checklist_database()
             return "Error listing checkins."
     conn.close()
-    timeCheckedIn = ""
+
+    # Get overdue info
+    overdue = {entry['id']: entry for entry in get_overdue_checkins()}
+
     checkin_list = ""
     for row in rows:
+        checkin_id = row[0]
         # Calculate length of time checked in, including days
         total_seconds = time.time() - time.mktime(time.strptime(row[2] + " " + row[3], "%Y-%m-%d %H:%M:%S"))
         days = int(total_seconds // 86400)
@@ -314,9 +320,31 @@ def list_checkin():
             timeCheckedIn = f"{days}d {hours:02}:{minutes:02}:{seconds:02}"
         else:
             timeCheckedIn = f"{hours:02}:{minutes:02}:{seconds:02}"
-            checkin_list += "ID: " + str(row[0]) + " " + row[1] + " checked-In for " + timeCheckedIn
+
+        # Add ⏰ if routine check-ins are required
+        routine = ""
+        if len(row) > 7 and row[7] and int(row[7]) > 0:
+            routine = f" ⏰({row[7]}m)"
+
+        # Indicate approval status
+        approved_marker = "✅" if row[6] == 1 else "☑️"
+
+        # Check if overdue
+        if checkin_id in overdue:
+            overdue_minutes = overdue[checkin_id]['overdue_minutes']
+            overdue_hours = overdue_minutes // 60
+            overdue_mins = overdue_minutes % 60
+            if overdue_hours > 0:
+                overdue_str = f"overdue by {overdue_hours}h {overdue_mins}m"
+            else:
+                overdue_str = f"overdue by {overdue_mins}m"
+            status = f"{row[1]} {overdue_str}{routine}"
+        else:
+            status = f"{row[1]} checked-In for {timeCheckedIn}{routine}"
+
+        checkin_list += f"ID: {checkin_id} {approved_marker} {status}"
         if row[5] != "":
-            checkin_list += "📝" + row[5]
+            checkin_list += " 📝" + row[5]
         if row != rows[-1]:
             checkin_list += "\n"
     # if empty list
@@ -331,6 +359,9 @@ def process_checklist_command(nodeID, message, name="none", location="none"):
     if str(nodeID) in bbs_ban_list:
         logger.warning("System: Checklist attempt from the ban list")
         return "unable to process command"
+    is_admin = False
+    if str(nodeID) in bbs_admin_list:
+        is_admin = True
     
     message_lower = message.lower()
     parts = message.split()
@@ -359,22 +390,44 @@ def process_checklist_command(nodeID, message, name="none", location="none"):
         return result
     
     elif ("checkout" in message_lower and not reverse_in_out) or ("checkin" in message_lower and reverse_in_out):
-        return checkout(name, current_date, current_time, location, comment)
+        # Support: checkout all, checkout <id>, or checkout [note]
+        all_flag = False
+        checkin_id = None
+        actual_comment = comment
     
-    elif "purgein" in message_lower:
-        return mark_checkin_removed_by_name(name)
+        # Split the command into parts after the keyword
+        checkout_args = parts[1:] if len(parts) > 1 else []
     
-    elif "purgeout" in message_lower:
-        return mark_checkout_removed_by_name(name)
+        if checkout_args:
+            if checkout_args[0].lower() == "all":
+                all_flag = True
+                actual_comment = " ".join(checkout_args[1:]) if len(checkout_args) > 1 else ""
+            elif checkout_args[0].isdigit():
+                checkin_id = int(checkout_args[0])
+                actual_comment = " ".join(checkout_args[1:]) if len(checkout_args) > 1 else ""
+            else:
+                actual_comment = " ".join(checkout_args)
     
-    elif message_lower.startswith("checklistapprove "):
+        return checkout(name, current_date, current_time, location, actual_comment, all=all_flag, checkin_id=checkin_id)
+    
+    # elif "purgein" in message_lower:
+    #     return mark_checkin_removed_by_name(name)
+    
+    # elif "purgeout" in message_lower:
+    #     return mark_checkout_removed_by_name(name)
+    
+    elif "approvecl " in message_lower:
+        if not is_admin:
+            return "You do not have permission to approve check-ins."
         try:
             checkin_id = int(parts[1])
             return approve_checkin(checkin_id)
         except (ValueError, IndexError):
             return "Usage: checklistapprove <checkin_id>"
-    
-    elif message_lower.startswith("checklistdeny "):
+
+    elif "denycl " in message_lower:
+        if not is_admin:
+            return "You do not have permission to deny check-ins."
         try:
             checkin_id = int(parts[1])
             return deny_checkin(checkin_id)
@@ -385,21 +438,15 @@ def process_checklist_command(nodeID, message, name="none", location="none"):
         if not reverse_in_out:
             return ("Command: checklist followed by\n"
                     "checkin [interval] [note]\n"
-                    "checkout [note]\n"
-                    "purgein - delete your checkin\n"
-                    "purgeout - delete your checkout\n"
-                    "checklistapprove <id> - approve checkin\n"
-                    "checklistdeny <id> - deny checkin\n"
-                    "Example: checkin 60 Hunting in tree stand")
+                    "checkout [all] [note]\n"
+                    "Example: checkin 60 Leaving for a hike")
         else:
             return ("Command: checklist followed by\n"
-                    "checkout [interval] [note]\n"
+                    "checkout [all] [interval] [note]\n"
                     "checkin [note]\n"
-                    "purgeout - delete your checkout\n"
-                    "purgein - delete your checkin\n"
-                    "Example: checkout 60 Leaving park")
+                    "Example: checkout 60 Leaving for a hike")
     
-    elif "checklist" in message_lower:
+    elif message_lower.strip() == "checklist":
         return list_checkin()
     
     else:

modules/radio.md

@@ -0,0 +1,55 @@
+# Radio Module: Meshages TTS (Text-to-Speech) Setup
+
+The radio module supports audible mesh messages using the [KittenTTS](https://github.com/KittenML/KittenTTS) engine. This allows the bot to generate and play speech from text, making mesh alerts and messages audible on your device.
+
+## Features
+
+- Converts mesh messages to speech using KittenTTS.
+
+## Installation
+
+1. **Install Python dependencies:**
+
+   - `kittentts` is the TTS engine.
+
+`pip install https://github.com/KittenML/KittenTTS/releases/download/0.1/kittentts-0.1.0-py3-none-any.whl`
+
+2. **Install PortAudio (required for sounddevice):**
+
+   - **macOS:**  
+     ```sh
+     brew install portaudio
+     ```
+   - **Linux (Debian/Ubuntu):**  
+     ```sh
+     sudo apt-get install portaudio19-dev
+     ```
+   - **Windows:**  
+     No extra step needed; `sounddevice` will use the default audio driver.
+
+## Configuration
+
+- Enable TTS in your `config.ini`:
+  ```ini
+  [radioMon]
+  meshagesTTS = True
+  ```
+
+## Usage
+
+When enabled, the bot will generate and play speech for mesh messages using the selected voice.  
+No additional user action is required.
+
+## Troubleshooting
+
+- If you see errors about missing `sounddevice` or `portaudio`, ensure you have installed the dependencies above.
+- On macOS, you may need to allow microphone/audio access for your terminal.
+- If you have audio issues, check your system’s default output device.
+
+## References
+
+- [KittenTTS GitHub](https://github.com/KittenML/KittenTTS)
+- [KittenTTS Model on HuggingFace](https://huggingface.co/KittenML/kitten-tts-nano-0.2)
+- [sounddevice documentation](https://python-sounddevice.readthedocs.io/)
+
+---

modules/radio.py

@@ -16,6 +16,9 @@ import struct
 import json
 from modules.log import logger
 
+# verbose debug logging for trap words function
+debugVoxTmsg = False
+
 from modules.settings import (
     radio_detection_enabled,
     rigControlServerAddress,
@@ -31,14 +34,52 @@ from modules.settings import (
     voxTrapList,
     voxOnTrapList,
     voxEnableCmd,
-    ERROR_FETCHING_DATA
+    ERROR_FETCHING_DATA,
+    meshagesTTS,
 )
 
 # module global variables
+previousStrength = -40
+signalCycle = 0
 
-
-# verbose debug logging for trap words function
-debugVoxTmsg = False
+FREQ_NAME_MAP = {
+    462562500: "GRMS CH1",
+    462587500: "GRMS CH2",
+    462612500: "GRMS CH3",
+    462637500: "GRMS CH4",
+    462662500: "GRMS CH5",
+    462687500: "GRMS CH6",
+    462712500: "GRMS CH7",
+    467562500: "GRMS CH8",
+    467587500: "GRMS CH9",
+    467612500: "GRMS CH10",
+    467637500: "GRMS CH11",
+    467662500: "GRMS CH12",
+    467687500: "GRMS CH13",
+    467712500: "GRMS CH14",
+    467737500: "GRMS CH15",
+    462550000: "GRMS CH16",
+    462575000: "GMRS CH17",
+    462600000: "GMRS CH18",
+    462625000: "GMRS CH19",
+    462675000: "GMRS CH20",
+    462670000: "GMRS CH21",
+    462725000: "GMRS CH22",
+    462725500: "GMRS CH23",
+    467575000: "GMRS CH24",
+    467600000: "GMRS CH25",
+    467625000: "GMRS CH26",
+    467650000: "GMRS CH27",
+    467675000: "GMRS CH28",
+    467700000: "FRS CH1",
+    462650000: "FRS CH5",
+    462700000: "FRS CH7",
+    462737500: "FRS CH16",
+    146520000: "2M Simplex Calling",
+    446000000: "70cm Simplex Calling",
+    156800000: "Marine CH16",
+    # Add more as needed
+}
 
 # --- WSJT-X and JS8Call Settings Initialization ---
 wsjtxMsgQueue = []  # Queue for WSJT-X detected messages
@@ -100,9 +141,9 @@ try:
     watched_callsigns = list({cs.upper() for cs in callsigns})
 
 except ImportError:
-    logger.debug("RadioMon: WSJT-X/JS8Call settings not configured")
+    logger.debug("System: RadioMon: WSJT-X/JS8Call settings not configured")
 except Exception as e:
-    logger.warning(f"RadioMon: Error loading WSJT-X/JS8Call settings: {e}")
+    logger.warning(f"System: RadioMon: Error loading WSJT-X/JS8Call settings: {e}")
 
 
 if radio_detection_enabled:
@@ -136,51 +177,43 @@ if voxDetectionEnabled:
             voxModel = Model(lang=voxLanguage) # use built in model for specified language
 
     except Exception as e:
-        print(f"RadioMon: Error importing VOX dependencies: {e}")
+        print(f"System: RadioMon: Error importing VOX dependencies: {e}")
         print(f"To use VOX detection please install the vosk and sounddevice python modules")
         print(f"pip install vosk sounddevice")
         print(f"sounddevice needs pulseaudio,  apt-get install portaudio19-dev")
         voxDetectionEnabled = False
-        logger.error(f"RadioMon: VOX detection disabled due to import error")
+        logger.error(f"System: RadioMon: VOX detection disabled due to import error")
 
-FREQ_NAME_MAP = {
-    462562500: "GRMS CH1",
-    462587500: "GRMS CH2",
-    462612500: "GRMS CH3",
-    462637500: "GRMS CH4",
-    462662500: "GRMS CH5",
-    462687500: "GRMS CH6",
-    462712500: "GRMS CH7",
-    467562500: "GRMS CH8",
-    467587500: "GRMS CH9",
-    467612500: "GRMS CH10",
-    467637500: "GRMS CH11",
-    467662500: "GRMS CH12",
-    467687500: "GRMS CH13",
-    467712500: "GRMS CH14",
-    467737500: "GRMS CH15",
-    462550000: "GRMS CH16",
-    462575000: "GMRS CH17",
-    462600000: "GMRS CH18",
-    462625000: "GMRS CH19",
-    462675000: "GMRS CH20",
-    462670000: "GMRS CH21",
-    462725000: "GMRS CH22",
-    462725500: "GMRS CH23",
-    467575000: "GMRS CH24",
-    467600000: "GMRS CH25",
-    467625000: "GMRS CH26",
-    467650000: "GMRS CH27",
-    467675000: "GMRS CH28",
-    467700000: "FRS CH1",
-    462650000: "FRS CH5",
-    462700000: "FRS CH7",
-    462737500: "FRS CH16",
-    146520000: "2M Simplex Calling",
-    446000000: "70cm Simplex Calling",
-    156800000: "Marine CH16",
-    # Add more as needed
-}
+if meshagesTTS:
+    try:
+        # TTS for meshages imports
+        logger.debug("System: RadioMon: Initializing TTS model for audible meshages")
+        import sounddevice as sd
+        from kittentts import KittenTTS
+        ttsModel = KittenTTS("KittenML/kitten-tts-nano-0.2")
+        available_voices = [
+            'expr-voice-2-m', 'expr-voice-2-f', 'expr-voice-3-m', 'expr-voice-3-f',
+            'expr-voice-4-m', 'expr-voice-4-f', 'expr-voice-5-m', 'expr-voice-5-f'
+        ]
+    except Exception as e:
+        logger.error(f"To use Meshages TTS please review the radio.md documentation for setup instructions.")
+        meshagesTTS = False
+
+async def generate_and_play_tts(text, voice, samplerate=24000):
+    """Async: Generate speech and play audio."""
+    text = text.strip()
+    if not text:
+        return
+    try:
+        logger.debug(f"System: RadioMon: Generating TTS for text: {text} with voice: {voice}")
+        audio = await asyncio.to_thread(ttsModel.generate, text, voice=voice)
+        if audio is None or len(audio) == 0:
+            return
+        await asyncio.to_thread(sd.play, audio, samplerate)
+        await asyncio.to_thread(sd.wait)
+        del audio
+    except Exception as e:
+        logger.warning(f"System: RadioMon: Error in generate_and_play_tts: {e}")
 
 def get_freq_common_name(freq):
     freq = int(freq)
@@ -194,14 +227,14 @@ def get_freq_common_name(freq):
 def get_hamlib(msg="f"):
     # get data from rigctld server
     if "socket" not in globals():
-        logger.warning("RadioMon: 'socket' module not imported. Hamlib disabled.")
+        logger.warning("System: RadioMon: 'socket' module not imported. Hamlib disabled.")
         return ERROR_FETCHING_DATA
     try:
         rigControlSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         rigControlSocket.settimeout(2)
         rigControlSocket.connect((rigControlServerAddress.split(":")[0],int(rigControlServerAddress.split(":")[1])))
     except Exception as e:
-        logger.error(f"RadioMon: Error connecting to rigctld: {e}")
+        logger.error(f"System: RadioMon: Error connecting to rigctld: {e}")
         return ERROR_FETCHING_DATA
 
     try:
@@ -215,7 +248,7 @@ def get_hamlib(msg="f"):
         data = data.replace(b'\n',b'')
         return data.decode("utf-8").rstrip()
     except Exception as e:
-        logger.error(f"RadioMon: Error fetching data from rigctld: {e}")
+        logger.error(f"System: RadioMon: Error fetching data from rigctld: {e}")
         return ERROR_FETCHING_DATA
     
 def get_sig_strength():
@@ -225,7 +258,7 @@ def get_sig_strength():
 def checkVoxTrapWords(text):
     try:
         if not voxOnTrapList:
-            logger.debug(f"RadioMon: VOX detected: {text}")
+            logger.debug(f"System: RadioMon: VOX detected: {text}")
             return text
         if text:
             traps = [voxTrapList] if isinstance(voxTrapList, str) else voxTrapList
@@ -235,27 +268,27 @@ def checkVoxTrapWords(text):
                 trap_lower = trap_clean.lower()
                 idx = text_lower.find(trap_lower)
                 if debugVoxTmsg:
-                    logger.debug(f"RadioMon: VOX checking for trap word '{trap_lower}' in: '{text}' (index: {idx})")
+                    logger.debug(f"System: RadioMon: VOX checking for trap word '{trap_lower}' in: '{text}' (index: {idx})")
                 if idx != -1:
                     new_text = text[idx + len(trap_clean):].strip()
                     if debugVoxTmsg:
-                        logger.debug(f"RadioMon: VOX detected trap word '{trap_lower}' in: '{text}' (remaining: '{new_text}')")
+                        logger.debug(f"System: RadioMon: VOX detected trap word '{trap_lower}' in: '{text}' (remaining: '{new_text}')")
                     new_words = new_text.split()
                     if voxEnableCmd:
                         for word in new_words:
                             if word in botMethods:
-                                logger.info(f"RadioMon: VOX action '{word}' with '{new_text}'")
+                                logger.info(f"System: RadioMon: VOX action '{word}' with '{new_text}'")
                                 if word == "joke":
                                     return botMethods[word](vox=True)
                                 else:
                                     return botMethods[word](None, None, None, vox=True)
-                    logger.debug(f"RadioMon: VOX returning text after trap word '{trap_lower}': '{new_text}'")
+                    logger.debug(f"System: RadioMon: VOX returning text after trap word '{trap_lower}': '{new_text}'")
                     return new_text
             if debugVoxTmsg:
-                logger.debug(f"RadioMon: VOX no trap word found in: '{text}'")
+                logger.debug(f"System: RadioMon: VOX no trap word found in: '{text}'")
         return None
     except Exception as e:
-        logger.debug(f"RadioMon: Error in checkVoxTrapWords: {e}")
+        logger.debug(f"System: RadioMon: Error in checkVoxTrapWords: {e}")
         return None
 
 async def signalWatcher():
@@ -265,7 +298,7 @@ async def signalWatcher():
         signalStrength = int(get_sig_strength())
         if signalStrength >= previousStrength and signalStrength > signalDetectionThreshold:
             message = f"Detected {get_freq_common_name(get_hamlib('f'))} active. S-Meter:{signalStrength}dBm"
-            logger.debug(f"RadioMon: {message}. Waiting for {signalHoldTime} seconds")
+            logger.debug(f"System: RadioMon: {message}. Waiting for {signalHoldTime} seconds")
             previousStrength = signalStrength
             signalCycle = 0
             await asyncio.sleep(signalHoldTime)
@@ -285,7 +318,7 @@ async def signalWatcher():
 async def make_vox_callback(loop, q):
     def vox_callback(indata, frames, time, status):
         if status:
-            logger.warning(f"RadioMon: VOX input status: {status}")
+            logger.warning(f"System: RadioMon: VOX input status: {status}")
         try:
             loop.call_soon_threadsafe(q.put_nowait, bytes(indata))
         except asyncio.QueueFull:
@@ -298,7 +331,7 @@ async def make_vox_callback(loop, q):
                 loop.call_soon_threadsafe(q.put_nowait, bytes(indata))
             except asyncio.QueueFull:
                 # If still full, just drop this frame
-                logger.debug("RadioMon: VOX queue full, dropping audio frame")
+                logger.debug("System: RadioMon: VOX queue full, dropping audio frame")
         except RuntimeError:
             # Loop may be closed
             pass
@@ -310,7 +343,7 @@ async def voxMonitor():
         model = voxModel
         device_info = sd.query_devices(voxInputDevice, 'input')
         samplerate = 16000
-        logger.debug(f"RadioMon: VOX monitor started on device {device_info['name']} with samplerate {samplerate} using trap words: {voxTrapList if voxOnTrapList else 'none'}")
+        logger.debug(f"System: RadioMon: VOX monitor started on device {device_info['name']} with samplerate {samplerate} using trap words: {voxTrapList if voxOnTrapList else 'none'}")
         rec = KaldiRecognizer(model, samplerate)
         loop = asyncio.get_running_loop()
         callback = await make_vox_callback(loop, q)
@@ -337,7 +370,7 @@ async def voxMonitor():
 
                 await asyncio.sleep(0.1)
     except Exception as e:
-        logger.error(f"RadioMon: Error in VOX monitor: {e}")
+        logger.warning(f"System: RadioMon: Error in VOX monitor: {e}")
 
 def decode_wsjtx_packet(data):
     """Decode WSJT-X UDP packet according to the protocol specification"""
@@ -439,7 +472,7 @@ def decode_wsjtx_packet(data):
         return None
         
     except Exception as e:
-        logger.debug(f"RadioMon: Error decoding WSJT-X packet: {e}")
+        logger.debug(f"System: RadioMon: Error decoding WSJT-X packet: {e}")
         return None
 
 def check_callsign_match(message, callsigns):
@@ -481,7 +514,7 @@ def check_callsign_match(message, callsigns):
 async def wsjtxMonitor():
     """Monitor WSJT-X UDP broadcasts for decode messages"""
     if not wsjtx_enabled:
-        logger.warning("RadioMon: WSJT-X monitoring called but not enabled")
+        logger.warning("System: RadioMon: WSJT-X monitoring called but not enabled")
         return
     
     try:
@@ -490,9 +523,9 @@ async def wsjtxMonitor():
         sock.bind((wsjtx_udp_address, wsjtx_udp_port))
         sock.setblocking(False)
         
-        logger.info(f"RadioMon: WSJT-X UDP listener started on {wsjtx_udp_address}:{wsjtx_udp_port}")
+        logger.info(f"System: RadioMon: WSJT-X UDP listener started on {wsjtx_udp_address}:{wsjtx_udp_port}")
         if watched_callsigns:
-            logger.info(f"RadioMon: Watching for callsigns: {', '.join(watched_callsigns)}")
+            logger.info(f"System: RadioMon: Watching for callsigns: {', '.join(watched_callsigns)}")
         
         while True:
             try:
@@ -507,29 +540,29 @@ async def wsjtxMonitor():
                     # Check if message contains watched callsigns
                     if check_callsign_match(message, watched_callsigns):
                         msg_text = f"WSJT-X {mode}: {message} (SNR: {snr:+d}dB)"
-                        logger.info(f"RadioMon: {msg_text}")
+                        logger.info(f"System: RadioMon: {msg_text}")
                         wsjtxMsgQueue.append(msg_text)
                         
             except BlockingIOError:
                 # No data available
                 await asyncio.sleep(0.1)
             except Exception as e:
-                logger.debug(f"RadioMon: Error in WSJT-X monitor loop: {e}")
+                logger.debug(f"System: RadioMon: Error in WSJT-X monitor loop: {e}")
                 await asyncio.sleep(1)
                 
     except Exception as e:
-        logger.error(f"RadioMon: Error starting WSJT-X monitor: {e}")
+        logger.warning(f"System: RadioMon: Error starting WSJT-X monitor: {e}")
 
 async def js8callMonitor():
     """Monitor JS8Call TCP API for messages"""
     if not js8call_enabled:
-        logger.warning("RadioMon: JS8Call monitoring called but not enabled")
+        logger.warning("System: RadioMon: JS8Call monitoring called but not enabled")
         return
     
     try:
-        logger.info(f"RadioMon: JS8Call TCP listener connecting to {js8call_tcp_address}:{js8call_tcp_port}")
+        logger.info(f"System: RadioMon: JS8Call TCP listener connecting to {js8call_tcp_address}:{js8call_tcp_port}")
         if watched_callsigns:
-            logger.info(f"RadioMon: Watching for callsigns: {', '.join(watched_callsigns)}")
+            logger.info(f"System: RadioMon: Watching for callsigns: {', '.join(watched_callsigns)}")
         
         while True:
             try:
@@ -539,14 +572,14 @@ async def js8callMonitor():
                 sock.connect((js8call_tcp_address, js8call_tcp_port))
                 sock.setblocking(False)
                 
-                logger.info("RadioMon: Connected to JS8Call API")
+                logger.info("System: RadioMon: Connected to JS8Call API")
                 
                 buffer = ""
                 while True:
                     try:
                         data = sock.recv(4096)
                         if not data:
-                            logger.warning("RadioMon: JS8Call connection closed")
+                            logger.warning("System: RadioMon: JS8Call connection closed")
                             break
                         
                         buffer += data.decode('utf-8', errors='ignore')
@@ -570,34 +603,34 @@ async def js8callMonitor():
                                     
                                     if text and check_callsign_match(text, watched_callsigns):
                                         msg_text = f"JS8Call from {from_call}: {text} (SNR: {snr:+d}dB)"
-                                        logger.info(f"RadioMon: {msg_text}")
+                                        logger.info(f"System: RadioMon: {msg_text}")
                                         js8callMsgQueue.append(msg_text)
                                         
                             except json.JSONDecodeError:
-                                logger.debug(f"RadioMon: Invalid JSON from JS8Call: {line[:100]}")
+                                logger.debug(f"System: RadioMon: Invalid JSON from JS8Call: {line[:100]}")
                             except Exception as e:
-                                logger.debug(f"RadioMon: Error processing JS8Call message: {e}")
+                                logger.debug(f"System: RadioMon: Error processing JS8Call message: {e}")
                                 
                     except BlockingIOError:
                         await asyncio.sleep(0.1)
                     except socket.timeout:
                         await asyncio.sleep(0.1)
                     except Exception as e:
-                        logger.debug(f"RadioMon: Error in JS8Call receive loop: {e}")
+                        logger.debug(f"System: RadioMon: Error in JS8Call receive loop: {e}")
                         break
                         
                 sock.close()
-                logger.warning("RadioMon: JS8Call connection lost, reconnecting in 5s...")
+                logger.warning("System: RadioMon: JS8Call connection lost, reconnecting in 5s...")
                 await asyncio.sleep(5)
                 
             except socket.timeout:
-                logger.warning("RadioMon: JS8Call connection timeout, retrying in 5s...")
+                logger.warning("System: RadioMon: JS8Call connection timeout, retrying in 5s...")
                 await asyncio.sleep(5)
             except Exception as e:
-                logger.warning(f"RadioMon: Error connecting to JS8Call: {e}")
+                logger.warning(f"System: RadioMon: Error connecting to JS8Call: {e}")
                 await asyncio.sleep(10)
                 
     except Exception as e:
-        logger.error(f"RadioMon: Error starting JS8Call monitor: {e}")
+        logger.warning(f"System: RadioMon: Error starting JS8Call monitor: {e}")
 
 # end of file

modules/rss.py

@@ -1,11 +1,13 @@
 # rss feed module for meshing-around 2025
 from modules.log import logger
-from modules.settings import rssFeedURL, rssFeedNames, rssMaxItems, rssTruncate, urlTimeoutSeconds, ERROR_FETCHING_DATA
+from modules.settings import rssFeedURL, rssFeedNames, rssMaxItems, rssTruncate, urlTimeoutSeconds, ERROR_FETCHING_DATA, newsAPI_KEY, newsAPIsort
 import urllib.request
 import xml.etree.ElementTree as ET
 import html
 from html.parser import HTMLParser
 import bs4 as bs
+import requests
+import datetime
 
 # Common User-Agent for all RSS requests
 COMMON_USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3'
@@ -136,3 +138,41 @@ def get_rss_feed(msg):
         logger.error(f"Error fetching RSS feed from {feed_url}: {e}")
         return ERROR_FETCHING_DATA
 
+def get_newsAPI(user_search="meshtastic"):
+    # Fetch news from NewsAPI.org
+    user_search = user_search.strip()
+    if user_search.lower().startswith("latest"):
+        user_search = user_search[6:].strip()
+    if not user_search:
+        user_search = "meshtastic"
+    try:
+        last_week = datetime.datetime.now() - datetime.timedelta(days=7)
+        newsAPIurl = (
+            f"https://newsapi.org/v2/everything?"
+            f"q={user_search}&language=en&from={last_week.strftime('%Y-%m-%d')}&sortBy={newsAPIsort}shedAt&pageSize=5&apiKey={newsAPI_KEY}"
+        )
+
+        response = requests.get(newsAPIurl, headers={"User-Agent": COMMON_USER_AGENT}, timeout=urlTimeoutSeconds)
+        news_data = response.json()
+
+        if news_data.get("status") != "ok":
+            error_message = news_data.get("message", "Unknown error")
+            logger.error(f"NewsAPI error: {error_message}")
+            return ERROR_FETCHING_DATA
+        logger.debug(f"System: NewsAPI Searching for '{user_search}' got {news_data.get('totalResults', 0)} results")
+        articles = news_data.get("articles", [])[:3]
+        news_list = []
+        for article in articles:
+            title = article.get("title", "No Title")
+            url = article.get("url", "")
+            description = article.get("description", '')
+            news_list.append(f"📰{title}\n{description}")
+        
+        # Make a nice newspaper style output
+        msg = f"🗞️:"
+        for item in news_list:
+            msg += item + "\n\n"
+        return msg.strip()
+    except Exception as e:
+        logger.error(f"System: NewsAPI fetching news: {e}")
+        return ERROR_FETCHING_DATA

modules/settings.py

@@ -32,6 +32,7 @@ cmdHistory = [] # list to hold the command history for lheard and history comman
 msg_history = [] # list to hold the message history for the messages command
 max_bytes = 200 # Meshtastic has ~237 byte limit, use conservative 200 bytes for message content
 voxMsgQueue = [] # queue for VOX detected messages
+tts_read_queue = [] # queue for TTS messages
 wsjtxMsgQueue = [] # queue for WSJT-X detected messages
 js8callMsgQueue = [] # queue for JS8Call detected messages
 # Game trackers
@@ -275,12 +276,10 @@ try:
     rssMaxItems = config['general'].getint('rssMaxItems', 3) # default 3 items
     rssTruncate = config['general'].getint('rssTruncate', 100) # default 100 characters
     rssFeedNames = config['general'].get('rssFeedNames', 'default,arrl').split(',')
-
-    # emergency response
-    emergency_responder_enabled = config['emergencyHandler'].getboolean('enabled', False)
-    emergency_responder_alert_channel = config['emergencyHandler'].getint('alert_channel', 2) # default 2
-    emergency_responder_alert_interface = config['emergencyHandler'].getint('alert_interface', 1) # default 1
-    emergency_responder_email = config['emergencyHandler'].get('email', '').split(',')
+    newsAPI_KEY = config['general'].get('newsAPI_KEY', '') # default empty
+    newsAPIregion = config['general'].get('newsAPIregion', 'us') # default us
+    enable_headlines = config['general'].getboolean('enableNewsAPI', False) # default False
+    newsAPIsort = config['general'].get('sort_by', 'relevancy') # default publishedAt
 
     # sentry
     sentry_enabled = config['sentry'].getboolean('SentryEnabled', False) # default False
@@ -320,28 +319,49 @@ try:
     coastalForecastDays = config['location'].getint('coastalForecastDays', 3) # default 3 days
 
     # location alerts
-    emergencyAlertBrodcastEnabled = config['location'].getboolean('eAlertBroadcastEnabled', False) # default False
+    eAlertBroadcastEnabled = config['location'].getboolean('eAlertBroadcastEnabled', False) # old deprecated name
+    ipawsAlertEnabled = config['location'].getboolean('ipawsAlertEnabled', False) # default False new ^
+    # Keep both in sync for backward compatibility
+    if eAlertBroadcastEnabled or ipawsAlertEnabled:
+        eAlertBroadcastEnabled = True
+        ipawsAlertEnabled = True
+    wxAlertsEnabled = config['location'].getboolean('NOAAalertsEnabled', True) # default True
     wxAlertBroadcastEnabled = config['location'].getboolean('wxAlertBroadcastEnabled', False) # default False
+    volcanoAlertBroadcastEnabled = config['location'].getboolean('volcanoAlertBroadcastEnabled', False) # default False
     enableGBalerts = config['location'].getboolean('enableGBalerts', False) # default False
     enableDEalerts = config['location'].getboolean('enableDEalerts', False) # default False
-    wxAlertsEnabled = config['location'].getboolean('NOAAalertsEnabled', True) # default True
+
     ignoreEASenable = config['location'].getboolean('ignoreEASenable', False) # default False
     ignoreEASwords = config['location'].get('ignoreEASwords', 'test,advisory').split(',') # default test,advisory
-    myRegionalKeysDE = config['location'].get('myRegionalKeysDE', '110000000000').split(',') # default city Berlin
+    ignoreFEMAenable = config['location'].getboolean('ignoreFEMAenable', True) # default True
+    ignoreFEMAwords = config['location'].get('ignoreFEMAwords', 'test,exercise').split(',') # default test,exercise
+    ignoreUSGSEnable = config['location'].getboolean('ignoreVolcanoEnable', False) # default False
+    ignoreUSGSWords = config['location'].get('ignoreVolcanoWords', 'test,advisory').split(',') # default test,advisory
+    
     forecastDuration = config['location'].getint('NOAAforecastDuration', 4) # NOAA forcast days
     numWxAlerts = config['location'].getint('NOAAalertCount', 2) # default 2 alerts
     enableExtraLocationWx = config['location'].getboolean('enableExtraLocationWx', False) # default False
     myStateFIPSList = config['location'].get('myFIPSList', '').split(',') # default empty
     mySAMEList = config['location'].get('mySAMEList', '').split(',') # default empty
-    ignoreFEMAenable = config['location'].getboolean('ignoreFEMAenable', True) # default True
-    ignoreFEMAwords = config['location'].get('ignoreFEMAwords', 'test,exercise').split(',') # default test,exercise
-    wxAlertBroadcastChannel = config['location'].get('wxAlertBroadcastCh', '2').split(',') # default Channel 2
-    emergencyAlertBroadcastCh = config['location'].get('eAlertBroadcastCh', '2').split(',') # default Channel 2
-    volcanoAlertBroadcastEnabled = config['location'].getboolean('volcanoAlertBroadcastEnabled', False) # default False
-    volcanoAlertBroadcastChannel = config['location'].get('volcanoAlertBroadcastCh', '2').split(',') # default Channel 2
-    ignoreUSGSEnable = config['location'].getboolean('ignoreVolcanoEnable', False) # default False
-    ignoreUSGSWords = config['location'].get('ignoreVolcanoWords', 'test,advisory').split(',') # default test,advisory
+    myRegionalKeysDE = config['location'].get('myRegionalKeysDE', '110000000000').split(',') # default city Berlin
+    eAlertBroadcastChannel = config['location'].getint('eAlertBroadcastChannel', '') # default empty
+
+    # any US alerts enabled
+    usAlerts = (
+        ipawsAlertEnabled or
+        wxAlertBroadcastEnabled or
+        volcanoAlertBroadcastEnabled or
+        wxAlertsEnabled or 
+        eAlertBroadcastEnabled
+        )
     
+    # emergency response
+    emergency_responder_enabled = config['emergencyHandler'].getboolean('enabled', False)
+    emergency_responder_alert_channel = config['emergencyHandler'].getint('alert_channel', 2) # default 2
+    emergency_responder_alert_interface = config['emergencyHandler'].getint('alert_interface', 1) # default 1
+    emergency_responder_email = config['emergencyHandler'].get('email', '').split(',')
+
+
     # bbs
     bbs_enabled = config['bbs'].getboolean('enabled', False)
     bbsdb = config['bbs'].get('bbsdb', 'data/bbsdb.pkl')
@@ -355,6 +375,7 @@ try:
     checklist_enabled = config['checklist'].getboolean('enabled', False)
     checklist_db = config['checklist'].get('checklist_db', 'data/checklist.db')
     reverse_in_out = config['checklist'].getboolean('reverse_in_out', False)
+    checklist_auto_approve = config['checklist'].getboolean('auto_approve', True) # default True
 
     # qrz hello
     qrz_hello_enabled = config['qrz'].getboolean('enabled', False)
@@ -417,6 +438,9 @@ try:
     voxOnTrapList = config['radioMon'].getboolean('voxOnTrapList', False) # default False
     voxTrapList = config['radioMon'].get('voxTrapList', 'chirpy').split(',') # default chirpy
     voxEnableCmd = config['radioMon'].getboolean('voxEnableCmd', True) # default True
+    meshagesTTS = config['radioMon'].getboolean('meshagesTTS', False) # default False
+    ttsChannels = config['radioMon'].get('ttsChannels', '2').split(',') # default Channel 2
+    ttsnoWelcome = config['radioMon'].getboolean('ttsnoWelcome', False) # default False
     
     # WSJT-X and JS8Call monitoring
     wsjtx_detection_enabled = config['radioMon'].getboolean('wsjtxDetectionEnabled', False) # default WSJT-X detection disabled

modules/system.py

@@ -114,7 +114,7 @@ if location_enabled:
         help_message = help_message + ", howtall"
 
 # NOAA alerts needs location module
-if wxAlertBroadcastEnabled or emergencyAlertBrodcastEnabled or volcanoAlertBroadcastEnabled:
+if wxAlertBroadcastEnabled or ipawsAlertEnabled or volcanoAlertBroadcastEnabled or eAlertBroadcastEnabled: #eAlertBroadcastEnabled depricated
     from modules.locationdata import * # from the spudgunman/meshing-around repo
     # limited subset, this should be done better but eh..
     trap_list = trap_list + ("wx", "wxa", "wxalert", "ea", "ealert", "valert")
@@ -153,10 +153,14 @@ if wikipedia_enabled or use_kiwix_server:
     help_message = help_message + ", wiki"
 
 # RSS Feed Configuration
-if rssEnable:
+if rssEnable or enable_headlines:
     from modules.rss import * # from the spudgunman/meshing-around repo
-    trap_list = trap_list + ("readrss",)
-    help_message = help_message + ", readrss"
+    if rssEnable:
+        trap_list = trap_list + ("readrss",)
+        help_message = help_message + ", readrss"
+    if enable_headlines:
+        trap_list = trap_list + ("latest",)
+        help_message = help_message + ", latest"
 
 # LLM Configuration
 if llm_enabled:
@@ -288,13 +292,6 @@ if inventory_enabled:
     trap_list = trap_list + trap_list_inventory # items item, itemlist, itemsell, etc.
     help_message = help_message + ", item, cart"
 
-# Radio Monitor Configuration
-if radio_detection_enabled:
-    from modules.radio import * # from the spudgunman/meshing-around repo
-
-if voxDetectionEnabled:
-    from modules.radio import * # from the spudgunman/meshing-around repo
-
 # File Monitor Configuration
 if file_monitor_enabled or read_news_enabled or bee_enabled or enable_runShellCmd or cmdShellSentryAlerts:
     from modules.filemon import * # from the spudgunman/meshing-around repo
@@ -1111,136 +1108,70 @@ def handleMultiPing(nodeID=0, deviceID=1):
                             multiPingList.pop(j)
                             break
 
-priorVolcanoAlert = ""
-priorEmergencyAlert = ""
-priorWxAlert = ""
+# Alert broadcasting initialization
+last_alerts = {
+    "overdue": {"time": 0, "message": ""},
+    "fema": {"time": 0, "message": ""},
+    "uk": {"time": 0, "message": ""},
+    "de": {"time": 0, "message": ""},
+    "wx": {"time": 0, "message": ""},
+    "volcano": {"time": 0, "message": ""},
+}
+def should_send_alert(alert_type, new_message, min_interval=1):
+    now = time.time()
+    last = last_alerts[alert_type]
+    # Only send if enough time has passed AND the message is different
+    if (now - last["time"]) > min_interval and new_message != last["message"]:
+        last_alerts[alert_type]["time"] = now
+        last_alerts[alert_type]["message"] = new_message
+        return True
+    return False
+
 def handleAlertBroadcast(deviceID=1):
     try:
-        global priorVolcanoAlert, priorEmergencyAlert, priorWxAlert
-        alertUk = NO_ALERTS
-        alertDe = NO_ALERTS
-        alertFema = NO_ALERTS
-        wxAlert = NO_ALERTS
-        volcanoAlert = NO_ALERTS
-        overdueAlerts = NO_ALERTS
+        alertUk = alertDe = alertFema = wxAlert = volcanoAlert = overdueAlerts = NO_ALERTS
         alertWx = False
-        # only allow API call every 20 minutes
-        # the watchdog will call this function 3 times, seeing possible throttling on the API
         clock = datetime.now()
-        if clock.minute % 20 != 0:
-            return False
-        if clock.second > 17:
-            return False
-        
-        # check for alerts
-        if wxAlertBroadcastEnabled:
-            alertWx = alertBrodcastNOAA()
-
-        if emergencyAlertBrodcastEnabled:
-            if enableDEalerts:
-                alertDe = get_nina_alerts()
-            if enableGBalerts:
-                alertUk = get_govUK_alerts()
-            else:
-                # default USA alerts
-                alertFema = getIpawsAlert(latitudeValue,longitudeValue, shortAlerts=True)
 
+        # Overdue check-in alert
         if checklist_enabled:
             overdueAlerts = format_overdue_alert()
-        
-        # format alert
-        if alertWx:
-            wxAlert = f"🚨 {alertWx[1]} EAS-WX ALERT: {alertWx[0]}"
-        else:
-            wxAlert = False
+            if overdueAlerts:
+                if should_send_alert("overdue", overdueAlerts, min_interval=300): # 5 minutes interval for overdue alerts
+                    send_message(overdueAlerts, emergency_responder_alert_channel, 0, emergency_responder_alert_interface)
 
-        femaAlert = alertFema
-        ukAlert = alertUk
-        deAlert = alertDe
-
-        if overdueAlerts != NO_ALERTS and overdueAlerts != None:
-            logger.debug("System: Adding overdue checkin to emergency alerts")
-            if femaAlert and NO_ALERTS not in femaAlert and ERROR_FETCHING_DATA not in femaAlert:
-                femaAlert += "\n\n" + overdueAlerts
-            elif ukAlert and NO_ALERTS not in ukAlert and ERROR_FETCHING_DATA not in ukAlert:
-                ukAlert += "\n\n" + overdueAlerts
-            elif deAlert and NO_ALERTS not in deAlert and ERROR_FETCHING_DATA not in deAlert:
-                deAlert += "\n\n" + overdueAlerts
-            else:
-                # only overdue alerts to send
-                if overdueAlerts != "" and overdueAlerts is not None and overdueAlerts != NO_ALERTS:
-                    if overdueAlerts != priorEmergencyAlert:
-                        priorEmergencyAlert = overdueAlerts
-                    else:
-                        return False
-                    if isinstance(emergencyAlertBroadcastCh, list):
-                        for channel in emergencyAlertBroadcastCh:
-                            send_message(overdueAlerts, int(channel), 0, deviceID)
-                    else:
-                        send_message(overdueAlerts, emergencyAlertBroadcastCh, 0, deviceID)
-                        return True
-
-        if emergencyAlertBrodcastEnabled:
-            if NO_ALERTS not in femaAlert and ERROR_FETCHING_DATA not in femaAlert:
-                if femaAlert != priorEmergencyAlert:
-                    priorEmergencyAlert = femaAlert
-                else:
-                    return False
-                if isinstance(emergencyAlertBroadcastCh, list):
-                    for channel in emergencyAlertBroadcastCh:
-                        send_message(femaAlert, int(channel), 0, deviceID)
-                else:
-                    send_message(femaAlert, emergencyAlertBroadcastCh, 0, deviceID)
-                return True
-            if NO_ALERTS not in ukAlert:
-                if ukAlert != priorEmergencyAlert:
-                    priorEmergencyAlert = ukAlert
-                else:
-                    return False
-                if isinstance(emergencyAlertBroadcastCh, list):
-                    for channel in emergencyAlertBroadcastCh:
-                        send_message(ukAlert, int(channel), 0, deviceID)
-                else:
-                    send_message(ukAlert, emergencyAlertBroadcastCh, 0, deviceID)
-                return True
-
-            if NO_ALERTS not in alertDe:
-                if deAlert != priorEmergencyAlert:
-                    priorEmergencyAlert = deAlert
-                else:
-                    return False
-                if isinstance(emergencyAlertBroadcastCh, list):
-                    for channel in emergencyAlertBroadcastCh:
-                        send_message(deAlert, int(channel), 0, deviceID)
-                else:
-                    send_message(deAlert, emergencyAlertBroadcastCh, 0, deviceID)
-                return True
+        # Only allow API call every 20 minutes
+        if not (clock.minute % 20 == 0 and clock.second <= 17):
+            return False
 
+        # Collect alerts
         if wxAlertBroadcastEnabled:
-            if wxAlert:
-                if wxAlert != priorWxAlert:
-                    priorWxAlert = wxAlert
-                else:
-                    return False
-                if isinstance(wxAlertBroadcastChannel, list):
-                    for channel in wxAlertBroadcastChannel:
-                        send_message(wxAlert, int(channel), 0, deviceID)
-                else:
-                    send_message(wxAlert, wxAlertBroadcastChannel, 0, deviceID)
-                return True
-
+            alertWx = alertBrodcastNOAA()
+            if alertWx:
+                wxAlert = f"🚨 {alertWx[1]} EAS-WX ALERT: {alertWx[0]}"
+        if eAlertBroadcastEnabled or ipawsAlertEnabled:
+            alertFema = getIpawsAlert(latitudeValue, longitudeValue, shortAlerts=True)
         if volcanoAlertBroadcastEnabled:
             volcanoAlert = get_volcano_usgs(latitudeValue, longitudeValue)
-            if volcanoAlert and NO_ALERTS not in volcanoAlert and ERROR_FETCHING_DATA not in volcanoAlert:
-                # check if the alert is different from the last one
-                if volcanoAlert != priorVolcanoAlert:
-                    priorVolcanoAlert = volcanoAlert
-                    if isinstance(volcanoAlertBroadcastChannel, list):
-                        for channel in volcanoAlertBroadcastChannel:
-                            send_message(volcanoAlert, int(channel), 0, deviceID)
-                    else:
-                        send_message(volcanoAlert, volcanoAlertBroadcastChannel, 0, deviceID)
-                    return True
+
+        if enableDEalerts:
+            deAlerts = get_nina_alerts()
+
+        if usAlerts:
+            alert_types = [
+                ("fema", alertFema, ipawsAlertEnabled),
+                ("wx", wxAlert, wxAlertBroadcastEnabled),
+                ("volcano", volcanoAlert, volcanoAlertBroadcastEnabled),]
+
+        if enableDEalerts:
+            alert_types = [("de", deAlerts, enableDEalerts)]
+
+        for alert_type, alert_msg, enabled in alert_types:
+            if enabled and alert_msg and NO_ALERTS not in alert_msg and ERROR_FETCHING_DATA not in alert_msg:
+                if should_send_alert(alert_type, alert_msg):
+                    send_message(alert_msg, emergency_responder_alert_channel, 0, emergency_responder_alert_interface)
+                if eAlertBroadcastChannel != '':
+                    send_message(alert_msg, eAlertBroadcastChannel, 0, emergency_responder_alert_interface)
     except Exception as e:
         logger.error(f"System: Error in handleAlertBroadcast: {e}")
     return False
@@ -1550,10 +1481,11 @@ def consumeMetadata(packet, rxNode=0, channel=-1):
             # Track highest altitude 🚀 (also log if over highfly_altitude threshold)
             if position_data.get('altitude') is not None:
                 altitude = position_data['altitude']
-                if altitude > meshLeaderboard['highestAltitude']['value']:
-                    meshLeaderboard['highestAltitude'] = {'nodeID': nodeID, 'value': altitude, 'timestamp': time.time()}
-                    if logMetaStats:
-                        logger.info(f"System: 🚀 New altitude record: {altitude}m from NodeID:{nodeID} ShortName:{get_name_from_number(nodeID, 'short', rxNode)}")
+                if altitude > highfly_altitude:
+                    if altitude > meshLeaderboard['highestAltitude']['value']:
+                        meshLeaderboard['highestAltitude'] = {'nodeID': nodeID, 'value': altitude, 'timestamp': time.time()}
+                        if logMetaStats:
+                            logger.info(f"System: 🚀 New altitude record: {altitude}m from NodeID:{nodeID} ShortName:{get_name_from_number(nodeID, 'short', rxNode)}")
             # Track tallest node 🪜 (under the highfly_altitude limit by 100m)
             if position_data.get('altitude') is not None:
                 altitude = position_data['altitude']
@@ -1982,7 +1914,8 @@ def get_sysinfo(nodeID=0, deviceID=1):
     return sysinfo
 
 async def handleSignalWatcher():
-    global lastHamLibAlert
+    from modules.radio import signalWatcher
+    from modules.settings import sigWatchBroadcastCh, sigWatchBroadcastInterface, lastHamLibAlert
     # monitor rigctld for signal strength and frequency
     while True:
         msg =  await signalWatcher()
@@ -2208,17 +2141,40 @@ async def handleSentinel(deviceID):
         handleSentinel_loop = 0  # Reset if nothing detected
 
 async def process_vox_queue():
-        # process the voxMsgQueue
-        global voxMsgQueue
-        items_to_process = voxMsgQueue[:]
-        voxMsgQueue.clear()
-        if len(items_to_process) > 0:
-            logger.debug(f"System: Processing {len(items_to_process)} items in voxMsgQueue")
-            for item in items_to_process:
-                message = item
-                for channel in sigWatchBroadcastCh:
-                    if antiSpam and int(channel) != publicChannel:
-                        send_message(message, int(channel), 0, sigWatchBroadcastInterface)
+    # process the voxMsgQueue
+    from modules.settings import sigWatchBroadcastCh, sigWatchBroadcastInterface, voxMsgQueue
+    items_to_process = voxMsgQueue[:]
+    voxMsgQueue.clear()
+    if len(items_to_process) > 0:
+        logger.debug(f"System: Processing {len(items_to_process)} items in voxMsgQueue")
+        for item in items_to_process:
+            message = item
+            for channel in sigWatchBroadcastCh:
+                if antiSpam and int(channel) != publicChannel:
+                    send_message(message, int(channel), 0, sigWatchBroadcastInterface)
+
+async def handleTTS():
+    from modules.radio import generate_and_play_tts, available_voices
+    from modules.settings import ttsnoWelcome, tts_read_queue
+    logger.debug("System: Handle TTS started")
+    if not ttsnoWelcome:
+        logger.debug("System: Playing TTS welcome message to disable set 'ttsnoWelcome = True' in settings.ini")
+        await generate_and_play_tts("Hey its Cheerpy! Thanks for using Meshing-Around on Meshtasstic!", available_voices[0])
+    try:
+        while True:
+            if tts_read_queue:
+                tts_read = tts_read_queue.pop(0)
+                voice = available_voices[0]
+                # ensure the tts_read ends with a punctuation mark
+                if not tts_read.endswith(('.', '!', '?')):
+                    tts_read += '.'
+                try:
+                    await generate_and_play_tts(tts_read, voice)
+                except Exception as e:
+                    logger.error(f"System: TTShandler error: {e}")
+            await asyncio.sleep(1)
+    except Exception as e:
+        logger.critical(f"System: handleTTS crashed: {e}")
 
 async def watchdog():
     global localTelemetryData, retry_int1, retry_int2, retry_int3, retry_int4, retry_int5, retry_int6, retry_int7, retry_int8, retry_int9
@@ -2252,7 +2208,7 @@ async def watchdog():
 
                     handleMultiPing(0, i)
 
-                    if wxAlertBroadcastEnabled or emergencyAlertBrodcastEnabled or volcanoAlertBroadcastEnabled or checklist_enabled:
+                    if anyAlertBroadcastEnabled or checklist_enabled:
                         handleAlertBroadcast(i)
 
                     intData = displayNodeTelemetry(0, i)

modules/test_checklist.py

@@ -0,0 +1,78 @@
+# modules/test_checklist.py
+import os
+import sys
+
+# Add the parent directory to sys.path to allow module imports
+parent_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
+sys.path.insert(0, parent_path)
+
+import unittest
+from unittest.mock import patch
+from checklist import process_checklist_command, initialize_checklist_database
+import time
+
+class TestProcessChecklistCommand(unittest.TestCase):
+    def setUp(self):
+        # Always start with a fresh DB
+        initialize_checklist_database()
+        # Patch settings for consistent test behavior
+        patcher1 = patch('modules.checklist.reverse_in_out', False)
+        patcher2 = patch('modules.checklist.bbs_ban_list', [])
+        patcher3 = patch('modules.checklist.bbs_admin_list', ['999'])
+        self.mock_reverse = patcher1.start()
+        self.mock_ban = patcher2.start()
+        self.mock_admin = patcher3.start()
+        self.addCleanup(patcher1.stop)
+        self.addCleanup(patcher2.stop)
+        self.addCleanup(patcher3.stop)
+
+    def test_checkin_command(self):
+        result = process_checklist_command(1, "checkin test note", name="TESTUSER", location=["loc"])
+        self.assertIn("Checked✅In: TESTUSER", result)
+
+    def test_checkout_command(self):
+        # First checkin
+        process_checklist_command(1, "checkin test note", name="TESTUSER", location=["loc"])
+        # Then checkout
+        result = process_checklist_command(1, "checkout", name="TESTUSER", location=["loc"])
+        self.assertIn("Checked⌛️Out: TESTUSER", result)
+
+    def test_checkin_with_interval(self):
+        result = process_checklist_command(1, "checkin 15 hiking", name="TESTUSER", location=["loc"])
+        self.assertIn("monitoring every 15min", result)
+
+    def test_checkout_all(self):
+        # Multiple checkins
+        process_checklist_command(1, "checkin note1", name="TESTUSER", location=["loc"])
+        process_checklist_command(1, "checkin note2", name="TESTUSER", location=["loc"])
+        result = process_checklist_command(1, "checkout all", name="TESTUSER", location=["loc"])
+        self.assertIn("Checked out", result)
+        self.assertIn("check-ins for TESTUSER", result)
+
+
+    def test_checklistapprove_nonadmin(self):
+        process_checklist_command(1, "checkin foo", name="FOO", location=["loc"])
+        result = process_checklist_command(2, "checklistapprove 1", name="NOTADMIN", location=["loc"])
+        self.assertNotIn("approved", result)
+
+    def test_checklistdeny_nonadmin(self):
+        process_checklist_command(1, "checkin foo", name="FOO", location=["loc"])
+        result = process_checklist_command(2, "checklistdeny 1", name="NOTADMIN", location=["loc"])
+        self.assertNotIn("denied", result)
+
+    def test_help_command(self):
+        result = process_checklist_command(1, "checklist ?", name="TESTUSER", location=["loc"])
+        self.assertIn("Command: checklist", result)
+
+    def test_checklist_listing(self):
+        process_checklist_command(1, "checkin foo", name="FOO", location=["loc"])
+        result = process_checklist_command(1, "checklist", name="FOO", location=["loc"])
+        self.assertIsInstance(result, str)
+        self.assertIn("checked-In", result)
+
+    def test_invalid_command(self):
+        result = process_checklist_command(1, "foobar", name="FOO", location=["loc"])
+        self.assertEqual(result, "Invalid command.")
+
+if __name__ == "__main__":
+    unittest.main()

script/README.md

@@ -1,22 +1,4 @@
-## script/runShell.sh
 
-**Purpose:**  
-`runShell.sh` is a simple demo shell script for the Mesh Bot project. It demonstrates how to execute shell commands within the project’s scripting environment.
-
-**Usage:**  
-Run this script from the terminal to see a basic example of shell scripting in the project context.
-
-```sh
-bash script/runShell.sh
-```
-
-**What it does:**  
-- Changes the working directory to the script’s location.
-- Prints the current directory path and a message indicating the script is running.
-- Serves as a template for creating additional shell scripts or automating tasks related to the project.
-
-**Note:**  
-You can modify this script to add more shell commands or automation steps as needed for your workflow.
 
 ## script/runShell.sh
 
@@ -57,4 +39,64 @@ bash script/sysEnv.sh
 - Designed to work on Linux systems, with special handling for Raspberry Pi hardware.
 
 **Note:**  
-You can expand or modify this script to include additional telemetry or environment checks as needed for your deployment.
+You can expand or modify this script to include additional telemetry or environment checks as needed for your deployment.
+
+## script/configMerge.py
+
+**Purpose:**  
+`configMerge.py` is a Python script that merges your user configuration (`config.ini`) with the default template (`config.template`). This helps you keep your settings up to date when the default configuration changes, while preserving your customizations.
+
+**Usage:**  
+Run this script from the project root or the `script/` directory:
+
+```sh
+python3 script/configMerge.py
+```
+
+**What it does:**  
+- Backs up your current `config.ini` to `config.bak`.
+- Merges new or updated settings from `config.template` into your `config.ini`.
+- Saves the merged result as `config_new.ini`.
+- Shows a summary of changes between your config and the merged version.
+
+**Note:**  
+After reviewing the changes, you can replace your `config.ini` with the merged version:
+
+```sh
+cp config_new.ini config.ini
+```
+
+This script is useful for safely updating your configuration when new options are added upstream.
+
+## script/addFav.py
+
+**Purpose:**  
+`addFav.py` is a Python script to help manage and add favorite nodes to all interfaces using data from `config.ini`. It supports both bot and roof (client_base) node workflows, making it easier to retain DM keys and manage node lists across devices.
+
+**Usage:**  
+Run this script from the main repo directory:
+
+```sh
+python3 script/addFav.py
+```
+
+- To print the contents of `roofNodeList.pkl` and exit, use:
+  ```sh
+  # note it is not production ready
+  python3 script/addFav.py -p
+  ```
+
+**What it does:**  
+- Interactively asks if you are running on a roof (client_base) node or a bot.
+- On the bot:  
+  - Compiles a list of favorite nodes and saves it to `roofNodeList.pkl` for later use on the roof node.
+- On the roof node:  
+  - Loads the node list from `roofNodeList.pkl`.
+- Shows which favorite nodes will be added and asks for confirmation.
+- Adds favorite nodes to the appropriate devices, handling API rate limits.
+- Logs actions and errors for troubleshooting.
+
+**Note:**  
+- Always run this script from the main repo directory to ensure module imports work.
+- After running on the bot, copy `roofNodeList.pkl` to the roof node and rerun the script there to complete the process.
+

update.sh

@@ -67,12 +67,13 @@ fi
 if [[ -f "config.ini" ]]; then
     owner=$(stat -f "%Su" config.ini)
     perms=$(stat -f "%A" config.ini)
-    echo "config.ini is owned by: $owner"
-    echo "config.ini permissions: $perms"
+    
     if [[ "$owner" == "root" ]]; then
+        echo "config.ini is owned by: $owner"
         echo "Warning: config.ini is owned by root check out the etc/set-permissions.sh script"
     fi
     if [[ $(stat -f "%Lp" config.ini) =~ .*[7,6,2]$ ]]; then
+        cho "config.ini permissions: $perms"
         echo "Warning: config.ini is world-writable or world-readable! check out the etc/set-permissions.sh script"
     fi