Update requirements.txt

Update README.md
Update mesh_bot.py
2026-03-28 17:32:36 +01:00 · 2025-01-18 20:57:26 -08:00 · 2025-01-18 20:55:23 -08:00 · 2025-01-18 20:52:45 -08:00 · 2025-01-18 20:38:50 -08:00 · 2025-01-18 20:10:19 -08:00
31 changed files with 2123 additions and 757 deletions
--- a/15
+++ b/15
@@ -1,24 +1,21 @@
-FROM python:3.10-slim
+FROM python:3.13-slim
 ENV PYTHONUNBUFFERED=1

-RUN apt-get update && apt-get install -y gettext tzdata locales && rm -rf /var/lib/apt/lists/*
+RUN apt-get update && apt-get install -y gettext tzdata locales nano && rm -rf /var/lib/apt/lists/*

 # Set the locale default to en_US.UTF-8
 RUN sed -i -e 's/# en_US.UTF-8 UTF-8/en_US.UTF-8 UTF-8/' /etc/locale.gen && \
    dpkg-reconfigure --frontend=noninteractive locales && \
    update-locale LANG=en_US.UTF-8
-ENV LANG en_US.UTF-8 
+ENV LANG="en_US.UTF-8"
 ENV TZ="America/Los_Angeles"

 WORKDIR /app
 COPY . /app
-COPY requirements.txt .
+COPY config.template /app/config.ini

 RUN pip install -r requirements.txt
-COPY . .

-COPY config.ini /app/config.ini
-COPY entrypoint.sh /app/entrypoint.sh
+RUN chmod +x /app/script/docker/entrypoint.sh

-RUN chmod +x /app/entrypoint.sh
-ENTRYPOINT ["/app/entrypoint.sh"]
+ENTRYPOINT ["/bin/bash", "/app/script/docker/entrypoint.sh"]
--- a/README.md
+++ b/README.md
@@ -5,18 +5,20 @@ Welcome to the Mesh Bot project! This feature-rich bot is designed to enhance yo
 ![Example Use](etc/pong-bot.jpg "Example Use")

 ## Key Features
+![CodeQlBadge](https://github.com/SpudGunMan/meshing-around/actions/workflows/dynamic/github-code-scanning/codeql/badge.svg)

 ### Intelligent Keyword Responder
 - **Automated Responses**: The bot detects keywords like "ping" and responds with "pong" in direct messages (DMs) or group channels.
 - **Customizable Triggers**: Monitor group channels for specific keywords and set custom responses.
 - **Emergency Response**: Monitor channels for keywords indicating emergencies and alert a wider audience.
+- **New Node Hello**: Greet new nodes on the mesh with a hello message

 ### Network Tools
 - **Build, Test Local Mesh**: Ping allow for message delivery testing with more realistic packets vs. telemetry
 - **Test Node Hardware**: `test` will send incremental sized data into the radio buffer for overall length of message testing

-### Dual Radio/Node Support
- **Simultaneous Monitoring**: Monitor two networks at the same time.
+### Multi Radio/Node Support
+- **Simultaneous Monitoring**: Monitor up to nine networks at the same time.
 - **Flexible Messaging**: send mail and messages, between networks.

 ### Advanced Messaging Capabilities
@@ -25,16 +27,21 @@ Welcome to the Mesh Bot project! This feature-rich bot is designed to enhance yo
 - **Store and Forward**: Replay messages with the `messages` command, and log messages locally to disk.
 - **Send Mail**: Send mail to nodes using `bbspost @nodeNumber #message` or `bbspost @nodeShortName #message`.
 - **BBS Linking**: Combine multiple bots to expand BBS reach.
- **E-Mail/SMS**: Send mesh-messages to E-Mail or SMS expanding visability.
+- **E-Mail/SMS**: Send mesh-messages to E-Mail or SMS(Email) expanding visability.
+- **New Node Hello**: Send a hello to any new node seen in text message.

 ### Interactive AI and Data Lookup
- **NOAA location Data**: Get localized weather(alerts) and Tide information. Open-Meteo is used for wx only outside NOAA coverage. 
+- **NOAA location Data**: Get localized weather(alerts), River Flow, and Tide information. Open-Meteo is used for wx only outside NOAA coverage. 
 - **Wiki Integration**: Look up data using Wikipedia results.
 - **Ollama LLM AI**: Interact with the [Ollama](https://github.com/ollama/ollama/tree/main/docs) LLM AI for advanced queries and responses.
+- **Satalite Pass Info**: Get passes for satalite at your location.

 ### Proximity Alerts
 - **Location-Based Alerts**: Get notified when members arrive back at a configured lat/long, perfect for remote locations like campsites.

+### CheckList / Check In Out
+- **Asset Tracking**: Maintain a list of node/asset checkin and checkout. Usefull for accountability of people, assets. Radio-Net, FEMA, Trailhead.
+
 ### Fun and Games
 - **Built-in Games**: Enjoy games like DopeWars, Lemonade Stand, BlackJack, and VideoPoker.
 - **Command-Based Gameplay**: Issue `games` to display help and start playing.
@@ -47,6 +54,8 @@ Welcome to the Mesh Bot project! This feature-rich bot is designed to enhance yo
 - **FEMA iPAWS/EAS Alerts via API**: Use an internet-connected node to message Emergency Alerts from FEMA
 - **NOAA EAS Alerts via API**: Use an internet-connected node to message Emergency Alerts from NOAA.
 - **EAS Alerts over the air**: Utilizing external tools to report EAS alerts offline over mesh.
+- **UK.GOV Alerts**: Pulling data form the UK.GOV alert page
+- **NINA alerts for Germany**: Emergency Alerts from xrepository.de feed

 ### File Monitor Alerts
 - **File Monitor**: Monitor a flat/text file for changes, broadcast the contents of the message to the mesh channel.
@@ -59,33 +68,23 @@ Welcome to the Mesh Bot project! This feature-rich bot is designed to enhance yo
 - **Message Chunking**: Automatically chunk messages over 160 characters to ensure higher delivery success across hops.

 ## Getting Started
-This project is developed on Linux (specifically a Raspberry Pi) but should work on any platform where the [Meshtastic protobuf API](https://meshtastic.org/docs/software/python/cli/) modules are supported, and with any compatible [Meshtastic](https://meshtastic.org/docs/getting-started/) hardware. For pico or low-powered devices, or [femtofox](https://github.com/noon92/femtofox) project for embedding, possibly see the [buildroot](https://github.com/buildroot-meshtastic/buildroot-meshtastic). 🥔 Please use responsibly and follow local rulings for such equipment. This project captures packets, logs them, and handles over the air communications which can include PII such as GPS locations.
+This project is developed on Linux (specifically a Raspberry Pi) but should work on any platform where the [Meshtastic protobuf API](https://meshtastic.org/docs/software/python/cli/) modules are supported, and with any compatible [Meshtastic](https://meshtastic.org/docs/getting-started/) hardware. For pico or low-powered devices, see projects for embedding, [buildroot](https://github.com/buildroot-meshtastic/buildroot-meshtastic), there is also [femtofox](https://github.com/noon92/femtofox). 🥔 Please use responsibly and follow local rulings for such equipment. This project captures packets, logs them, and handles over the air communications which can include PII such as GPS locations.

 ### Installation

 #### Clone the Repository
+If you dont have git you will need it `sudo apt-get install git`
 ```sh
 git clone https://github.com/spudgunman/meshing-around
 ```
 The code is under active development, so make sure to pull the latest changes regularly!

-#### Optional Automation of setup
+#### Automation of setup
 - **Automated Installation**: `install.sh` will automate optional venv and requirements installation.
 - **Launch Script**: `launch.sh` will activate and launch the app in the venv

 #### Docker Installation
-If you prefer to use Docker, follow these steps:
-
-1. Ensure your serial port is properly shared and the GPU is configured if using LLM in docker with [NVIDIA](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/docker-specialized.html).
-2. Build the Docker image:
-    ```sh
-    cd meshing-around
-    docker build -t meshing-around .
-    ```
-3. Run the Docker container:
-    ```sh
-    docker run --rm -it --device=/dev/ttyUSB0 meshing-around
-    ```
+If you prefer to use [Docker](script/docker/README.md)

 #### Custom Install
 Install the required dependencies using pip:
@@ -135,7 +134,7 @@ ignoreDefaultChannel = False # ignoreDefaultChannel, the bot will ignore the def
 ```

 ### Location Settings
-The weather forecasting defaults to NOAA, for locations outside the USA, you can set `UseMeteoWxAPI` to `True`, to use a global weather API. The `lat` and `lon` are default values when a node has no location data. It is also the default (or value when none found for user) for Sentry, all NOAA, repeater lookup, etc.
+The weather forecasting defaults to NOAA, for locations outside the USA, you can set `UseMeteoWxAPI` to `True`, to use a global weather API. The `lat` and `lon` are default values when a node has no location data, as well as the default for all NOAA, repeater lookup. It is also the center of radius for Sentry.

 ```ini
 [location]
@@ -143,10 +142,11 @@ enabled = True
 lat = 48.50
 lon = -123.0
 UseMeteoWxAPI = True
+riverListDefault = # NOAA Hydrology data, unique identifiers, LID or USGS ID
 ```

 ### Module Settings
-Modules can be enabled or disabled as needed.
+Modules can be enabled or disabled as needed. They are essentally larger functions of code which you may not want on your mesh or in memory space.

 ```ini
 [bbs]
@@ -179,7 +179,7 @@ sentryIgnoreList = # list of ignored nodes numbers ex: 2813308004,4258675309
 ```

 ### E-Mail / SMS Settings
-To enable connectivity with SMTP/IMAP.
+To enable connectivity with SMTP allows messages from meshtastic into SMTP. The term SMS here is for connection via [carrier email](https://avtech.com/articles/138/list-of-email-to-sms-addresses/)

 ```ini
 [smtp]
@@ -198,31 +198,29 @@ Traps the following ("emergency", "911", "112", "999", "police", "fire", "ambula

 ```ini
 [emergencyHandler]
-# enable or disable the emergency response handler
-enabled = True
-# channel to send a message to when the emergency handler is triggered
-alert_channel = 2
+enabled = True # enable or disable the emergency response handler
+alert_channel = 2 # channel to send a message to when the emergency handler is triggered
 alert_interface = 1
 ```

 ### EAS Alerting
 To Alert on Mesh with the EAS API you can set the channels and enable, checks every 20min.

-#### FEMA iPAWS/EAS
-UNDER DEV..
-
-This uses the SAME code to locate the bot and alerts.
+#### FEMA iPAWS/EAS and UK.gov NINA
+This uses USA: SAME, FIPS, ZIP code to locate the alerts in the feed. By default ignoring Test messages.

 ```ini
-# FEMA IPAWS/CAP Alert Broadcast
-femaAlertBroadcastEnabled = True
-# FEMA IPAWS/CAP Alert Broadcast Channels
-femaAlertBroadcastCh = 2,4
-# Ignore any headline that includes the word Test
-ignoreFEMAtest = True
-# comma separated list of codes trigger local alert. (e.g., SAME, FIPS, ZIP)
+eAlertBroadcastEnabled = False # Goverment IPAWS/CAP Alert Broadcast
+eAlertBroadcastCh = 2,3 # Goverment Emergency IPAWS/CAP Alert Broadcast Channels
+ignoreFEMAtest = True # Ignore any headline that includes the word Test
+# comma separated list of codes (e.g., SAME,FIPS,ZIP) trigger local alert.
 # find your SAME https://www.weather.gov/nwr/counties
 mySAME = 053029,053073
+
+# To use other country services enable only a single optional serivce
+
+enableGBalerts = False # use UK.gov for alert source
+enableDEalerts = False # Use DE Alert Broadcast Data see template for filters
 ```

 #### NOAA EAS
@@ -262,6 +260,7 @@ llmEnableHistory = True # enable history for the LLM model to use in responses a
 llmContext_fromGoogle = True # enable context from google search results helps with responses accuracy
 googleSearchResults = 3 # number of google search results to include in the context more results = more compute time
 ```
+Note for LLM in docker with [NVIDIA](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/docker-specialized.html). Needed for the container with ollama running. 

 ### Radio Monitoring
 A module allowing a Hamlib compatible radio to connect to the bot. When functioning, it will message the configured channel with a message of in use. **Requires hamlib/rigctld to be running as a service.**
@@ -287,6 +286,8 @@ file_path = alert.txt
 broadcastCh = 2,4
 enable_read_news = False
 news_file_path = news.txt
+news_random_line = False # only return a single random line from the news file
+enable_runShellCmd = False # enables running of bash commands runShell.sh demo for sysinfo
 ```

 #### Offline EAS
@@ -314,6 +315,14 @@ rtl_fm -f 162425000 -s 22050 | multimon-ng -t raw -a EAS /dev/stdin | python eas
 #### Newspaper on mesh
 a newspaper could be built by external scripts. could use Ollama to compile text via news web pages and write news.txt

+### Greet new nodes QRZ module
+This isnt QRZ.com this is Q code for who is calling me, this will track new nodes and say hello
+```ini
+[qrz] 
+enabled = True # QRZ Hello to new nodes
+qrz_hello_string = "send CMD or DM me for more info." # will be sent to all heard nodes once
+```
+
 ### Scheduler
 In the config.ini enable the module
 ```ini
@@ -332,7 +341,7 @@ schedule.every().wednesday.at("19:00").do(lambda: send_message("Net Starting Now
 ```

 #### BBS Link
-The scheduler also handles the BBL Link Brodcast message, this would be an esxample of a mesh-admin channel on 8 being used to pass BBS post traffic between two bots as the initator, one direction pull.
+The scheduler also handles the BBS Link Brodcast message, this would be an esxample of a mesh-admin channel on 8 being used to pass BBS post traffic between two bots as the initator, one direction pull.
 ```python
 # Send bbslink looking for peers every other day at 10:00 using send_message function to channel 8 on device 1
 schedule.every(2).days.at("10:00").do(lambda: send_message("bbslink MeshBot looking for peers", 8, 0, 1))
@@ -343,7 +352,9 @@ bbslink_whitelist = # list of whitelisted nodes numbers ex: 2813308004,425867530
 ```

 ### MQTT Notes
-There is no direct support for MQTT in the code, however, reports from Discord are that using [meshtasticd](https://meshtastic.org/docs/hardware/devices/linux-native-hardware/) with no radio and attaching the bot to the software node, which is MQTT-linked, allows routing. There also seems to be a quicker way to enable MQTT by having your bot node with the enabled [serial](https://meshtastic.org/docs/configuration/module/serial/) module with echo enabled and MQTT uplink and downlink. These two methods have been mentioned as allowing MQTT routing for the project. 
+There is no direct support for MQTT in the code, however, reports from Discord are that using [meshtasticd](https://meshtastic.org/docs/hardware/devices/linux-native-hardware/) with no radio and attaching the bot to the software node, which is MQTT-linked, allows routing. Tested working fully Firmware:2.5.15.79da236 with [mosquitto](https://meshtastic.org/docs/software/integrations/mqtt/mosquitto/).
+
+~~There also seems to be a quicker way to enable MQTT by having your bot node with the enabled [serial](https://meshtastic.org/docs/configuration/module/serial/) module with echo enabled and MQTT uplink and downlink. These two~~ 

 ## Full list of commands for the bot

@@ -351,25 +362,28 @@ There is no direct support for MQTT in the code, however, reports from Discord a
 | Command | Description | ✅ Works Off-Grid |
 |---------|-------------|-
 | `ping`, `ack` | Return data for signal. Example: `ping 15 #DrivingI5` (activates auto-ping every 20 seconds for count 15) | ✅ |
-| `test` | Returns like ping but also can be used to test the limits of data buffers `test 4` sends data to the maxBuffer limit (default 220) | ✅ |
+| `cmd` | Returns the list of commands (the help message) | ✅ |
+| `history` | Returns the last commands run by user(s) | ✅ |
+| `lheard` | Returns the last 5 heard nodes with SNR. Can also use `sitrep` | ✅ |
+| `motd` | Displays the message of the day or sets it. Example: `motd $New Message Of the day` | ✅ |
+| `sysinfo` | Returns the bot node telemetry info | ✅ |
+| `test` | used to test the limits of data transfer `test 4` sends data to the maxBuffer limit (default 220) | ✅ |
 | `whereami` | Returns the address of the sender's location if known |
 | `whoami` | Returns details of the node asking, also returned when position exchanged 📍 | ✅ |
-| `motd` | Displays the message of the day or sets it. Example: `motd $New Message Of the day` | ✅ |
-| `lheard` | Returns the last 5 heard nodes with SNR. Can also use `sitrep` | ✅ |
-| `history` | Returns the last commands run by user(s) | ✅ |
-| `cmd` | Returns the list of commands (the help message) | ✅ |
+| `whois` | Returns details known about node, more data with bbsadmin node | ✅ |

 ### Radio Propagation & Weather Forcasting
 | Command | Description | |
 |---------|-------------|-------------------
-| `sun` and `moon` | Return info on rise and set local time | ✅ |
-| `solar` | Gives an idea of the x-ray flux | |
+| `ea` and `ealert` | Return FEMA iPAWS/EAS alerts in USA or UK/DE Headline or expanded details for USA | |
 | `hfcond` | Returns a table of HF solar conditions | |
-| `tide` | Returns the local tides (NOAA data source) |
 | `rlist` | Returns a table of nearby repeaters from RepeaterBook | |
+| `riverflow` | Return information from NOAA for river flow info. Example: `riverflow modules/settings.py`| |
+| `solar` | Gives an idea of the x-ray flux | |
+| `sun` and `moon` | Return info on rise and set local time | ✅ |
+| `tide` | Returns the local tides (NOAA data source) |
 | `wx` and `wxc` | Return local weather forecast (wxc is metric value), NOAA or Open Meteo for weather forecasting | |
 | `wxa` and `wxalert` | Return NOAA alerts. Short title or expanded details | |
-| `ea` and `ealert` | Return FEMA iPAWS/EAS alerts. Headline or expanded details | |

 ### Bulletin Board & Mail
 | Command | Description | |
@@ -390,21 +404,29 @@ There is no direct support for MQTT in the code, however, reports from Discord a
 ### Data Lookup 
 | Command | Description | |
 |---------|-------------|-
-| `wiki:` | Searches Wikipedia and returns the first few sentences of the first result if a match. Example: `wiki: lora radio` |
 | `askai` and `ask:` | Ask Ollama LLM AI for a response. Example: `askai what temp do I cook chicken` | ✅ |
 | `messages` | Replays the last messages heard, like Store and Forward | ✅ |
 | `readnews` | returns the contents of a file (news.txt, by default) via the chunker on air | ✅ |
+| `satpass` | returns the pass info from API for defined NORAD ID in config or Example: `satpass 25544,33591`| |
+| `wiki:` | Searches Wikipedia and returns the first few sentences of the first result if a match. Example: `wiki: lora radio` |
+
+### CheckList
+| Command | Description | |
+|---------|-------------|-
+| `checkin` | Check in the node to the checklist database | ✅ |
+| `checkout` | Checkout the node in the checklist database | ✅ |
+| `checklist` | Display the checklist database | ✅ |

 ### Games (via DM)
 | Command | Description | |
 |---------|-------------|-
+| `blackjack` | Plays Blackjack (Casino 21) | ✅ |
+| `dopewars` | Plays the classic drug trader game | ✅ |
+| `golfsim` | Plays a 9-hole Golf Simulator | ✅ |
 | `joke` | Tells a joke | ✅ |
 | `lemonstand` | Plays the classic Lemonade Stand finance game | ✅ |
-| `dopewars` | Plays the classic drug trader game | ✅ |
-| `blackjack` | Plays Blackjack (Casino 21) | ✅ |
-| `videopoker` | Plays basic 5-card hold Video Poker | ✅ |
 | `mastermind` | Plays the classic code-breaking game | ✅ |
-| `golfsim` | Plays a 9-hole Golf Simulator | ✅ |
+| `videopoker` | Plays basic 5-card hold Video Poker | ✅ |

 # Recognition

@@ -430,6 +452,8 @@ I used ideas and snippets from other responder bots and want to call them out!
 - **[https://github.com/A-c0rN](A-c0rN)**: Assistance with iPAWS and EAS
 - **Mike O'Connell/skrrt**: For [eas_alert_parser](etc/eas_alert_parser.py) enhanced by **sheer.cold**
 - **PiDiBi**: For looking at test functions and other suggestions like wxc, CPU use, and alerting ideas.
+- **WH6GXZ nurse dude**: For bashing on installer
+- **Josh**: For more bashing on installer!
 - **Cisien, bitflip, **Woof**, **propstg**, **Josh** and Hailo1999**: For testing and feature ideas on Discord and GitHub.
 - **Meshtastic Discord Community**: For tossing out ideas and testing code.

@@ -437,7 +461,7 @@ I used ideas and snippets from other responder bots and want to call them out!
 - **Node Backup Management**: [Node Slurper](https://github.com/SpudGunMan/node-slurper)

 ### Requirements
-Python 3.8? or later is needed (dev on latest). The following can be installed with `pip install -r requirements.txt` or using the [install.sh](install.sh) script for venv and automation:
+Python 3.8? or later is needed (docker on 3.13). The following can be installed with `pip install -r requirements.txt` or using the [install.sh](install.sh) script for venv and automation:

 ```sh
 pip install meshtastic
@@ -457,14 +481,6 @@ pip install schedule
 pip install wikipedia
 ```

-For open-meteo use:
-
-```sh
-pip install openmeteo_requests
-pip install retry_requests
-pip install numpy
-```
-
 For the Ollama LLM:

 ```sh
@@ -476,3 +492,5 @@ To enable emoji in the Debian console, install the fonts:
 ```sh
 sudo apt-get install fonts-noto-color-emoji
 ```
+
+Meshtastic® is a registered trademark of Meshtastic LLC. Meshtastic software components are released under various licenses, see GitHub for details. No warranty is provided - use at your own risk.
--- a/config.template
+++ b/config.template
@@ -8,23 +8,26 @@
 type = serial
 port = /dev/ttyACM0
 # port = /dev/ttyUSB0
-# port = COM1
-# hostname = 192.168.0.1
+# hostname = meshtastic.local
 # mac = 00:11:22:33:44:55

-# Additional interface for dual radio support
+# Additional interface for multi radio support
 [interface2]
 enabled = False
 type = serial
 port = /dev/ttyUSB0
-#port = /dev/ttyACM1
+# port = /dev/ttyACM1
 # port = COM1
-# hostname = meshtastic.local
+# hostname = localhost
 # mac = 00:11:22:33:44:55

+# example, the third interface would be [interface3] up to 9
+
 [general]
 # if False will respond on all channels but the default channel
 respond_by_dm_only = True
+# Allows auto-ping feature in a channel, False forces to 1 ping only
+autoPingInChannel = False
 # defaultChannel is the meshtastic default public channel, e.g. LongFast (if none use -1)
 defaultChannel = 0
 # ignoreDefaultChannel, the bot will ignore the default channel set above
@@ -72,6 +75,8 @@ urlTimeout = 10
 LogMessagesToFile = False
 # Logging of system messages to file
 SyslogToFile = True
+# logging level for the bot (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+sysloglevel = DEBUG
 # Number of log files to keep in days, 0 to keep all
 log_backup_count = 32

@@ -89,7 +94,7 @@ emailSentryAlerts = False
 # radius in meters to detect someone close to the bot
 SentryRadius = 100
 # channel to send a message to when the watchdog is triggered
-SentryChannel = 9
+SentryChannel = 2
 # holdoff time multiplied by seconds(20) of the watchdog
 SentryHoldoff = 9
 # list of ignored nodes numbers ex: 2813308004,4258675309
@@ -106,62 +111,74 @@ bbslink_enabled = False
 # list of whitelisted nodes numbers ex: 2813308004,4258675309 empty list allows all
 bbslink_whitelist = 

-[smtp]
-# enable or disable the SMTP module
-enableSMTP = False
-# enable or disable the IMAP module for inbound email
-enableImap = False
-# list of Sysop Emails seperate with commas
-sysopEmails =
-SMTP_SERVER = smtp.gmail.com
-# 587 SMTP over TLS/STARTTLS, 25 legacy SMTP, 465 SMTP over SSL
-SMTP_PORT = 587
-# Sender email: be mindful of public access, don't use your personal email
-FROM_EMAIL = none@gmail.com
-SMTP_AUTH = True
-SMTP_USERNAME = none@gmail.com
-SMTP_PASSWORD = none
-EMAIL_SUBJECT = Meshtastic✉️
-
-# IMAP not implimented yet
-IMAP_SERVER = imap.gmail.com
-# 993 IMAP over TLS/SSL, 143 legacy IMAP
-IMAP_PORT = 993
-# IMAP login usually same as SMTP
-IMAP_USERNAME = none@gmail.com
-IMAP_PASSWORD = none
-IMAP_FOLDER = inbox
-
-
 # location module
 [location]
 enabled = True
 lat = 48.50
 lon = -123.0
+
+# Default to metric units rather than imperial
+useMetric = False
+
+# repeaterList lookup location (rbook / artsci)
+repeaterLookup = rbook
+
 # NOAA weather forecast days, the first two rows are today and tonight
 NOAAforecastDuration = 4
 # number of weather alerts to display
 NOAAalertCount = 2
+
 # use Open-Meteo API for weather data not NOAA useful for non US locations
 UseMeteoWxAPI = False
-# Default to metric units rather than imperial
-useMetric = False
-# repeaterList lookup location (rbook / artsci)
-repeaterLookup = rbook
-# EAS Alert Broadcast
+
+# NOAA Hydrology unique identifiers, LID or USGS ID
+riverListDefault = 
+
+# NOAA EAS Alert Broadcast
 wxAlertBroadcastEnabled = False
 # EAS Alert Broadcast Channels
 wxAlertBroadcastCh = 2
-# FEMA IPAWS/CAP Alert Broadcast
-femaAlertBroadcastEnabled = False
-# FEMA IPAWS/CAP Alert Broadcast Channels
-femaAlertBroadcastCh = 2
+# Add extra location to the weather alert
+enableExtraLocationWx = False
+
+# Goverment Alert Broadcast defaults to FEMA IPAWS
+eAlertBroadcastEnabled = False
+# Goverment Alert Broadcast Channels
+eAlertBroadcastCh = 2
+
+# FEMA Alert Broadcast Settings
 # Ignore any headline that includes the word Test
 ignoreFEMAtest = True
 # comma separated list of codes (e.g., SAME,FIPS,ZIP) trigger local alert.
 # find your SAME https://www.weather.gov/nwr/counties
 mySAME = 053029,053073

+# Use UK Alert Broadcast Data
+enableGBalerts = False
+
+# Use 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/
+n2yoAPIKey = 
+# NORAD list https://www.n2yo.com/satellites/
+satList = 25544,7530
+
+# CheckList Checkin/Checkout
+[checklist]
+enabled = False
+checklist_db = data/checklist.db
+
+[qrz]
+# QRZ Hello to new nodes with message
+enabled = False
+qrz_db = data/qrz.db
+qrz_hello_string = "send CMD or DM me for more info."
+
 # repeater module
 [repeater]
 enabled = False
@@ -195,6 +212,36 @@ file_path = alert.txt
 broadcastCh = 2
 enable_read_news = False
 news_file_path = news.txt
+# only return a single random line from the news file
+news_random_line = False
+# enable the use of exernal shell commands
+enable_runShellCmd = False
+
+[smtp]
+# enable or disable the SMTP module
+enableSMTP = False
+# enable or disable the IMAP module for inbound email
+enableImap = False
+# list of Sysop Emails seperate with commas
+sysopEmails =
+SMTP_SERVER = smtp.gmail.com
+# 587 SMTP over TLS/STARTTLS, 25 legacy SMTP, 465 SMTP over SSL
+SMTP_PORT = 587
+# Sender email: be mindful of public access, don't use your personal email
+FROM_EMAIL = none@gmail.com
+SMTP_AUTH = True
+SMTP_USERNAME = none@gmail.com
+SMTP_PASSWORD = none
+EMAIL_SUBJECT = Meshtastic✉️
+
+# IMAP not implimented yet
+IMAP_SERVER = imap.gmail.com
+# 993 IMAP over TLS/SSL, 143 legacy IMAP
+IMAP_PORT = 993
+# IMAP login usually same as SMTP
+IMAP_USERNAME = none@gmail.com
+IMAP_PASSWORD = none
+IMAP_FOLDER = inbox

 [games]
 # if hop limit for the user exceeds this value, the message will be dropped
@@ -216,7 +263,7 @@ splitDelay = 0.0
 MESSAGE_CHUNK_SIZE = 160
 # Request Acknowledgement of message OTA
 wantAck = False
-# Max lilmit Buffer for radio testing
+# Max limit buffer for radio testing. 233 is hard limit 2.5+ firmware
 maxBuffer = 220


--- a/entrypoint.sh
+++ b/entrypoint.sh
@@ -1,6 +0,0 @@
-#!/bin/bash
-
-# Substitute environment variables in the config file
-envsubst < /app/config.ini > /app/config.tmp && mv /app/config.tmp /app/config.ini
-
-exec python /app/mesh_bot.py
--- a/etc/simulator.py
+++ b/etc/simulator.py
@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # # Simulate meshing-around de K7MHI 2024
-from modules.log import * # Import the logger
+from modules.log import * # Import the logger; ### --> If you are reading this put the script in the project root <-- ###
 import time
 import random

--- a/install.sh
+++ b/install.sh
@@ -1,91 +1,175 @@
 #!/bin/bash
+# meshing-around install helper script

 # install.sh
 cd "$(dirname "$0")"
 program_path=$(pwd)
-cp etc/pong_bot.tmp etc/pong_bot.service
-cp etc/mesh_bot.tmp etc/mesh_bot.service
-cp etc/mesh_bot_reporting.tmp etc/mesh_bot_reporting.service
-
+printf "\n########################"
 printf "\nMeshing Around Installer\n"
-printf "\nThis script will install the Meshing Around bot and its dependencies works best in debian/ubuntu\n"
-printf "\nChecking for dependencies\n"
+printf "########################\n"
+printf "\nThis script will try and install the Meshing Around Bot and its dependencies.\n"
+printf "Installer works best in raspian/debian/ubuntu or foxbuntu embedded systems.\n"
+printf "If there is a problem, try running the installer again.\n"
+printf "\nChecking for dependencies...\n"

+# check if we are in /opt/meshing-around
+if [ $program_path != "/opt/meshing-around" ]; then
+    printf "\nIt is suggested to project path to /opt/meshing-around\n"
+    printf "Do you want to move the project to /opt/meshing-around? (y/n)"
+    read move
+    if [[ $(echo "$move" | grep -i "^y") ]]; then
+        sudo mv $program_path /opt/meshing-around
+        cd /opt/meshing-around
+        printf "\nProject moved to /opt/meshing-around. re-run the installer\n"
+        exit 0
+    fi
+fi
+
+# check write access to program path
+if [[ ! -w ${program_path} ]]; then
+    printf "\nInstall path not writable, try running the installer with sudo\n"
+    exit 1
+fi
+
+# if hostname = femtofox, then we are on embedded
+if [[ $(hostname) == "femtofox" ]]; then
+    printf "\nDetected femtofox embedded system\n"
+    embedded="y"
+else
+    # check if running on embedded
+    printf "\nAre You installing into an embedded system like a luckfox or -native? most should say no here (y/n)"
+    read embedded
+fi
+
+if [[ $(echo "${embedded}" | grep -i "^y") ]]; then
+    printf "\nDetected embedded skipping dependency installation\n"
+else
+    # Check and install dependencies
+    if ! command -v python3 &> /dev/null
+    then
+        printf "python3 not found, trying 'apt-get install python3 python3-pip'\n"
+        sudo apt-get install python3 python3-pip
+    fi
+    if ! command -v pip &> /dev/null
+    then
+        printf "pip not found, trying 'apt-get install python3-pip'\n"
+        sudo apt-get install python3-pip
+    fi
+
+    # double check for python3 and pip
+    if ! command -v python3 &> /dev/null
+    then
+        printf "python3 not found, please install python3 with your OS\n"
+        exit 1
+    fi
+    if ! command -v pip &> /dev/null
+    then
+        printf "pip not found, please install pip with your OS\n"
+        exit 1
+    fi
+    printf "\nDependencies installed\n"
+fi

 # add user to groups for serial access
-printf "\nAdding user to dialout and tty groups for serial access\n"
+printf "\nAdding user to dialout, bluetooth, and tty groups for serial access\n"
 sudo usermod -a -G dialout $USER
 sudo usermod -a -G tty $USER
 sudo usermod -a -G bluetooth $USER

-# check for pip
-if ! command -v pip &> /dev/null
-then
-    printf "pip not found, please install pip with your OS\n"
-    sudo apt-get install python3-pip
-else
-    printf "python pip found\n"
-fi
+# copy service files
+cp etc/pong_bot.tmp etc/pong_bot.service
+cp etc/mesh_bot.tmp etc/mesh_bot.service
+cp etc/mesh_bot_reporting.tmp etc/mesh_bot_reporting.service

 # generate config file, check if it exists
-if [ -f config.ini ]; then
+if [[ -f config.ini ]]; then
    printf "\nConfig file already exists, moving to backup config.old\n"
    mv config.ini config.old
 fi

 cp config.template config.ini
-printf "\nConfig file generated\n"
+printf "\nConfig files generated!\n"

+# update lat,long in config.ini 
+latlong=$(curl --silent --max-time 20 https://ipinfo.io/loc || echo "48.50,-123.0")
+IFS=',' read -r lat lon <<< "$latlong"
+sed -i "s|lat = 48.50|lat = $lat|g" config.ini
+sed -i "s|lon = -123.0|lon = $lon|g" config.ini
+echo "lat,long updated in config.ini to $latlong"

-# set virtual environment and install dependencies
-printf "\nMeshing Around Installer\n"
-
-echo "Do you want to install the bot in a virtual environment? (y/n)"
-read venv
-
-if [ $venv == "y" ]; then
-    # set virtual environment
-    if ! python3 -m venv --help &> /dev/null; then
-        printf "Python3 venv module not found, please install python3-venv with your OS\n"
-        exit 1
-    else
-        echo "Creating virtual environment..."
-        python3 -m venv venv
-        source venv/bin/activate
-
-        #check if python3 has venv module
-        if [ -f venv/bin/activate ]; then
-            printf "\nFpund virtual environment for python\n"
-        else
-            sudo apt-get install python3-venv
-            printf "\nPython3 venv module not found, please install python3-venv with your OS if not already done. re-run the script\n"
-            exit 1
-        fi
-
-        # config service files for virtual environment
-        replace="s|python3 mesh_bot.py|/usr/bin/bash launch.sh mesh|g"
-        sed -i "$replace" etc/mesh_bot.service
-        replace="s|python3 pong_bot.py|/usr/bin/bash launch.sh pong|g"
-        sed -i "$replace" etc/pong_bot.service
-
-        # install dependencies
-        pip install -U -r requirements.txt
-    fi
+# check if running on embedded
+if [[ $(echo "${embedded}" | grep -i "^y") ]]; then
+    printf "\nDetected embedded skipping venv\n"
 else
-    printf "\nSkipping virtual environment...\n"
-    # install dependencies
-    printf "Are you on Raspberry Pi(debian/ubuntu)?\nshould we add --break-system-packages to the pip install command? (y/n)"
-    read rpi
-    if [ $rpi == "y" ]; then
-        pip install -U -r requirements.txt --break-system-packages
+    printf "\nRecomended install is in a python virtual environment, do you want to use venv? (y/n)"
+    read venv
+
+    if [[ $(echo "${venv}" | grep -i "^y") ]]; then
+        # set virtual environment
+        if ! python3 -m venv --help &> /dev/null; then
+            printf "Python3/venv error, please install python3-venv with your OS\n"
+            exit 1
+        else
+            echo "The Following could be messy, or take some time on slower devices."
+            echo "Creating virtual environment..."
+            #check if python3 has venv module
+            if [[ -f venv/bin/activate ]]; then
+                printf "\nFound virtual environment for python\n"
+                python3 -m venv venv
+                source venv/bin/activate
+            else
+                printf "\nVirtual environment not found, trying `sudo apt-get install python3-venv`\n"
+                sudo apt-get install python3-venv
+            fi
+            # create virtual environment
+            python3 -m venv venv
+
+            # double check for python3-venv
+            if [[ -f venv/bin/activate ]]; then
+                printf "\nFound virtual environment for python\n"
+                source venv/bin/activate
+            else
+                printf "\nPython3 venv module not found, please install python3-venv with your OS\n"
+                exit 1
+            fi
+
+            printf "\nVirtual environment created\n"
+
+            # config service files for virtual environment
+            replace="s|python3 mesh_bot.py|/usr/bin/bash launch.sh mesh|g"
+            sed -i "$replace" etc/mesh_bot.service
+            replace="s|python3 pong_bot.py|/usr/bin/bash launch.sh pong|g"
+            sed -i "$replace" etc/pong_bot.service
+
+            # install dependencies to venv
+            pip install -U -r requirements.txt
+        fi
    else
-        pip install -U -r requirements.txt
+        printf "\nSkipping virtual environment...\n"
+        # install dependencies to system
+        printf "Are you on Raspberry Pi(debian/ubuntu)?\nshould we add --break-system-packages to the pip install command? (y/n)"
+        read rpi
+        if [[ $(echo "${rpi}" | grep -i "^y") ]]; then
+            pip install -U -r requirements.txt --break-system-packages
+        else
+            pip install -U -r requirements.txt
+        fi
    fi
 fi

-printf "\n\n"
-echo "Which bot do you want to install as a service? Pong Mesh or None? (pong/mesh/n)"
-read bot
+# if $1 is passed
+if [[ $1 == "mesh" ]]; then
+    bot="mesh"
+elif [[ $1 == "pong" ]]; then
+    bot="pong"
+else
+    printf "\n\n"
+    echo "Which bot do you want to install as a service? Pong Mesh or None? (pong/mesh/n)"
+    echo "Pong bot is a simple bot for network testing"
+    echo "Mesh bot is a more complex bot more suited for meshing around"
+    echo "None will skip the service install"
+    read bot
+fi

 # set the correct path in the service file
 replace="s|/dir/|$program_path/|g"
@@ -93,7 +177,32 @@ sed -i $replace etc/pong_bot.service
 sed -i $replace etc/mesh_bot.service
 sed -i $replace etc/mesh_bot_reporting.service
 # set the correct user in the service file?
-whoami=$(whoami)
+
+#ask if we should add a user for the bot
+if [[ $(echo "${embedded}" | grep -i "^n") ]]; then
+    printf "\nDo you want to add a local user (meshbot) no login, for the bot? (y/n)"
+    read meshbotservice
+fi
+
+if [[ $(echo "${meshbotservice}" | grep -i "^y") ]] || [[ $(echo "${embedded}" | grep -i "^y") ]]; then
+    sudo useradd -M meshbot
+    sudo usermod -L meshbot
+    sudo groupadd meshbot
+    sudo usermod -a -G meshbot meshbot
+    whoami="meshbot"
+    echo "Added user meshbot with no home directory"
+    sudo usermod -a -G dialout $whoami
+    sudo usermod -a -G tty $whoami
+    sudo usermod -a -G bluetooth $whoami
+    echo "Added meshbot to dialout, tty, and bluetooth groups"
+
+    sudo chown -R $whoami:$whoami $program_path/logs
+    sudo chown -R $whoami:$whoami $program_path/data
+    echo "Permissions set for meshbot on logs and data directories"
+else
+    whoami=$(whoami)
+fi
+# set the correct user in the service file
 replace="s|User=pi|User=$whoami|g"
 sed -i $replace etc/pong_bot.service
 sed -i $replace etc/mesh_bot.service
@@ -102,58 +211,130 @@ replace="s|Group=pi|Group=$whoami|g"
 sed -i $replace etc/pong_bot.service
 sed -i $replace etc/mesh_bot.service
 sed -i $replace etc/mesh_bot_reporting.service
-sudo systemctl daemon-reload
 printf "\n service files updated\n"

-# ask if emoji font should be installed for linux
-echo "Do you want to install the emoji font for debian/ubuntu linux? (y/n)"
-read emoji
-if [ $emoji == "y" ]; then
-    sudo apt-get install -y fonts-noto-color-emoji
-    echo "Emoji font installed!, reboot to load the font"
-fi
-
-if [ $bot == "pong" ]; then
+if [[ $(echo "${bot}" | grep -i "^p") ]]; then
    # install service for pong bot
    sudo cp etc/pong_bot.service /etc/systemd/system/
    sudo systemctl enable pong_bot.service
+    sudo systemctl daemon-reload
+    echo "to start pong bot service: systemctl start pong_bot"
+    service="pong_bot"
 fi

-if [ $bot == "mesh" ]; then
+if [[ $(echo "${bot}" | grep -i "^m") ]]; then
    # install service for mesh bot
    sudo cp etc/mesh_bot.service /etc/systemd/system/
    sudo systemctl enable mesh_bot.service
+    sudo systemctl daemon-reload
+    echo "to start mesh bot service: systemctl start mesh_bot"
+    service="mesh_bot"
 fi

-if [ $bot == "n" ]; then
-    if [ -f launch.sh ]; then
-        printf "\nTo run the bot, use the command: ./launch.sh\n"
-        ./launch.sh
+# check if running on embedded for final steps
+if [[ $(echo "${embedded}" | grep -i "^n") ]]; then
+    # ask if emoji font should be installed for linux
+    printf "\nDo you want to install the emoji font for debian/ubuntu linux? (y/n)"
+    read emoji
+    if [[ $(echo "${emoji}" | grep -i "^y") ]]; then
+        sudo apt-get install -y fonts-noto-color-emoji
+        echo "Emoji font installed!, reboot to load the font"
    fi
-fi

-printf "\nOptionally if you want to install the LLM Ollama compnents we will execute the following commands\n"
-printf "\ncurl -fsSL https://ollama.com/install.sh | sh\n"
+    printf "\nOptionally if you want to install the multi gig LLM Ollama compnents we will execute the following commands\n"
+    printf "\ncurl -fsSL https://ollama.com/install.sh | sh\n"
+    printf "ollama pull gemma2:2b\n"
+    printf "Total download is multi GB, recomend pi5/8GB or better for this\n"
+    # ask if the user wants to install the LLM Ollama components
+    printf "\nDo you want to install the LLM Ollama components? (y/n)"
+    read ollama
+    if [[ $(echo "${ollama}" | grep -i "^y") ]]; then
+        curl -fsSL https://ollama.com/install.sh | sh

-# ask if the user wants to install the LLM Ollama components
-echo "Do you want to install the LLM Ollama components? (y/n)"
-read ollama
-if [ $ollama == "y" ]; then
-    curl -fsSL https://ollama.com/install.sh | sh
-
-    # ask if want to install gemma2:2b
-    printf "\n Ollama install done now we can install the Gemma2:2b components, multi GB download\n"
-    echo "Do you want to install the Gemma2:2b components? (y/n)"
-    read gemma
-    if [ $gemma == "y" ]; then
-        ollama pull gemma2:2b
+        # ask if want to install gemma2:2b
+        printf "\n Ollama install done now we can install the Gemma2:2b components\n"
+        echo "Do you want to install the Gemma2:2b components? (y/n)"
+        read gemma
+        if [[ $(echo "${gemma}" | grep -i "^y") ]]; then
+            ollama pull gemma2:2b
+        fi
    fi
+
+    if [[ $(echo "${embedded}" | grep -i "^n") ]]; then
+        # document the service install
+        printf "To install the %s service and keep notes, reference following commands:\n\n" "$service" > install_notes.txt
+        printf "sudo cp %s/etc/%s.service /etc/systemd/system/etc/%s.service\n" "$program_path" "$service" "$service" >> install_notes.txt
+        printf "sudo systemctl daemon-reload\n" >> install_notes.txt
+        printf "sudo systemctl enable %s.service\n" "$service" >> install_notes.txt
+        printf "sudo systemctl start %s.service\n" "$service" >> install_notes.txt
+        printf "sudo systemctl status %s.service\n\n" "$service" >> install_notes.txt
+        printf "To see logs and stop the service:\n" >> install_notes.txt
+        printf "sudo journalctl -u %s.service\n" "$service" >> install_notes.txt
+        printf "sudo systemctl stop %s.service\n" "$service" >> install_notes.txt
+        printf "sudo systemctl disable %s.service\n" "$service" >> install_notes.txt
+    fi
+    
+    if [[ $(echo "${venv}" | grep -i "^y") ]]; then
+        printf "\nFor running on venv, virtual launch bot with './launch.sh mesh' in path $program_path\n" >> install_notes.txt
+    fi
+
+    read -p "Press enter to complete the installation, these commands saved to install_notes.txt"
+
+    printf "\nGood time to reboot? (y/n)"
+    read reboot
+    if [[ $(echo "${reboot}" | grep -i "^y") ]]; then
+        sudo reboot
+    fi
+else
+    # we are on embedded
+    # replace "type = serial" with "type = tcp" in config.ini
+    replace="s|type = serial|type = tcp|g"
+    sed -i "$replace" config.ini
+    # replace "# hostname = meshtastic.local" with "hostname = localhost" in config.ini
+    replace="s|# hostname = meshtastic.local|hostname = localhost|g"
+    sed -i "$replace" config.ini
+    printf "\nConfig file updated for embedded\n"
+
+    # Set up the meshing around service
+    sudo cp /opt/meshing-around/etc/$service.service /etc/systemd/system/$service.service
+    sudo systemctl daemon-reload
+    sudo systemctl enable $service.service
+    sudo systemctl start $service.service
+    printf "Reference following commands:\n\n" "$service" > install_notes.txt
+    printf "sudo systemctl status %s.service\n\n" "$service" >> install_notes.txt
+    printf "To see logs and stop the service:\n" >> install_notes.txt
+    printf "sudo journalctl -u %s.service\n" "$service" >> install_notes.txt
+    printf "sudo systemctl stop %s.service\n" "$service" >> install_notes.txt
+    printf "sudo systemctl disable %s.service\n" "$service" >> install_notes.txt
 fi

-echo "Good time to reboot? (y/n)"
-read reboot
-if [ $reboot == "y" ]; then
-    sudo reboot
-fi
+printf "\nInstallation complete!\n"

 exit 0
+
+# to uninstall the product run the following commands as needed
+
+# sudo systemctl stop mesh_bot
+# sudo systemctl disable mesh_bot
+# sudo systemctl stop pong_bot
+# sudo systemctl disable pong_bot
+# sudo systemctl stop mesh_bot_reporting
+# sudo systemctl disable mesh_bot_reporting
+# sudo rm /etc/systemd/system/mesh_bot.service
+# sudo rm /etc/systemd/system/mesh_bot_reporting.service
+# sudo rm /etc/systemd/system/pong_bot.service
+# sudo systemctl daemon-reload
+# sudo systemctl reset-failed
+
+# sudo gpasswd -d meshbot dialout
+# sudo gpasswd -d meshbot tty
+# sudo gpasswd -d meshbot bluetooth
+# sudo groupdel meshbot
+# sudo userdel meshbot
+
+# sudo rm -rf /opt/meshing-around
+
+
+# after install shenannigans
+# add 'bee = True' to config.ini General section. You will likley want to clean the txt up a bit
+# wget https://courses.cs.washington.edu/courses/cse163/20wi/files/lectures/L04/bee-movie.txt -O bee.txt
--- a/launch.sh
+++ b/launch.sh
@@ -1,4 +1,5 @@
 #!/bin/bash
+# This script launches the meshing-around bot or the report generator in python virtual environment

 # launch.sh
 cd "$(dirname "$0")"
--- a/logs/README.md
+++ b/logs/README.md
@@ -1,26 +1,26 @@
+# Logs and Reports
 Logs will collect here. Give a day of logs or a bunch of messages to have good reports.

-Reporting is via [../etc/report_generator5.py](../etc/report_generator5.py). The report_generator5 has newer feel and HTML5 coding. The index.html output is published in [../etc/www](../etc/www) there is a .cfg file created on first run for configuring values as needed.
- - `multi_log_reader = True` on by default will read all logs (or set to false to return daily logs)
+## Reporting Note
+Reporting is via [../etc/report_generator5.py](../etc/report_generator5.py). The report_generator5 has newer feel and HTML5 coding. The index.html output is published in [../etc/www](../etc/www) there is a .cfg file created on first run for configuring values as needed (like moving web root)
 - Make sure to have `SyslogToFile = True` and default of DEBUG log level to fully enable reporting! ‼️
- - provided serviceTimer templates in etc/

 ![reportView](../etc/reporting.jpg)

+## Settings
 Logging messages to disk or 'Syslog' to disk uses the python native logging function.
-```
+```conf
 [general]
 # logging to file of the non Bot messages only
 LogMessagesToFile = False
 # Logging of system messages to file, needed for reporting engine
 SyslogToFile = True
+# logging level for the bot (DEBUG, INFO, WARNING, ERROR, CRITICAL)
+sysloglevel = DEBUG
 # Number of log files to keep in days, 0 to keep all
 log_backup_count = 32
 ```
+## Web Reporting WebServer
+There is a web-server module. You can run `python3 modules/web.py` from the project root directory and it will serve up the web content.

-To change the stdout (what you see on the console) logging level (default is DEBUG) see the following example, line is in [../modules/log.py](../modules/log.py)
-
-```
-# Set level for stdout handler
-stdout_handler.setLevel(logging.INFO)
-```
+find it at. http://localhost:8420
--- a/mesh_bot.py
+++ b/mesh_bot.py
@@ -2,10 +2,15 @@
 # Meshtastic Autoresponder MESH Bot
 # K7MHI Kelly Keeton 2024

+try:
+    from pubsub import pub
+except ImportError:
+    print(f"Important dependencies are not met, try install.sh\n\n Did you mean to './launch.sh mesh' using a virtual environment.")
+    exit(1)
+
 import asyncio
 import time # for sleep, get some when you can :)
 import random
-from pubsub import pub # pip install pubsub
 from modules.log import *
 from modules.system import *

@@ -14,8 +19,6 @@ restrictedCommands = ["blackjack", "videopoker", "dopewars", "lemonstand", "golf
 restrictedResponse = "🤖only available in a Direct Message📵" # "" for none

 # Global Variables
-cmdHistory = [] # list to hold the last commands
-seenNodes = [] # list to hold the last seen nodes
 DEBUGpacket = False # Debug print the packet rx
 DEBUGhops = False # Debug print hop info and bad hop count packets

@@ -25,7 +28,7 @@ def auto_response(message, snr, rssi, hop, pkiStatus, message_from_id, channel_n
    message_lower = message.lower()
    bot_response = "🤖I'm sorry, I'm afraid I can't do that."

-    # Command List
+    # Command List processes system.trap_list. system.messageTrap() sends any commands to here
    default_commands = {
    "ack": lambda: handle_ping(message_from_id, deviceID, message, hop, snr, rssi, isDM, channel_number),
    "ask:": lambda: handle_llm(message_from_id, channel_number, deviceID, message, publicChannel),
@@ -39,14 +42,17 @@ 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),
+    "checkin": lambda: handle_checklist(message, message_from_id, deviceID),
+    "checklist": lambda: handle_checklist(message, message_from_id, deviceID),
+    "checkout": lambda: handle_checklist(message, message_from_id, deviceID),
    "clearsms": lambda: handle_sms(message_from_id, message),
    "cmd": lambda: help_message,
    "cq": lambda: handle_ping(message_from_id, deviceID, message, hop, snr, rssi, isDM, channel_number),
    "cqcq": lambda: handle_ping(message_from_id, deviceID, message, hop, snr, rssi, isDM, channel_number),
    "cqcqcq": lambda: handle_ping(message_from_id, deviceID, message, hop, snr, rssi, isDM, channel_number),
    "dopewars": lambda: handleDopeWars(message, message_from_id, deviceID),
-    "ea": lambda: handle_fema_alerts(message, message_from_id, deviceID),
-    "ealert": lambda: handle_fema_alerts(message, message_from_id, deviceID),
+    "ea": lambda: handle_emergency_alerts(message, message_from_id, deviceID),
+    "ealert": lambda: handle_emergency_alerts(message, message_from_id, deviceID),
    "email:": lambda: handle_email(message_from_id, message),
    "games": lambda: gamesCmdList,
    "globalthermonuclearwar": lambda: handle_gTnW(),
@@ -64,19 +70,23 @@ def auto_response(message, snr, rssi, hop, pkiStatus, message_from_id, channel_n
    "pinging": lambda: handle_ping(message_from_id, deviceID, message, hop, snr, rssi, isDM, channel_number),
    "pong": lambda: "🏓PING!!🛜",
    "readnews": lambda: read_news(),
+    "riverflow": lambda: handle_riverFlow(message, message_from_id, deviceID),
    "rlist": lambda: handle_repeaterQuery(message_from_id, deviceID, channel_number),
+    "satpass": lambda: handle_satpass(message_from_id, deviceID, channel_number, message),
    "setemail": lambda: handle_email(message_from_id, message),
    "setsms": lambda: handle_sms( message_from_id, message),
    "sitrep": lambda: handle_lheard(message, message_from_id, deviceID, isDM),
    "sms:": lambda: handle_sms(message_from_id, message),
    "solar": lambda: drap_xray_conditions() + "\n" + solar_conditions(),
    "sun": lambda: handle_sun(message_from_id, deviceID, channel_number),
+    "sysinfo": lambda: sysinfo(message, message_from_id, deviceID),
    "test": lambda: handle_ping(message_from_id, deviceID, message, hop, snr, rssi, isDM, channel_number),
    "testing": lambda: handle_ping(message_from_id, deviceID, message, hop, snr, rssi, isDM, channel_number),
    "tide": lambda: handle_tide(message_from_id, deviceID, channel_number),
    "videopoker": lambda: handleVideoPoker(message, message_from_id, deviceID),
    "whereami": lambda: handle_whereami(message_from_id, deviceID, channel_number),
    "whoami": lambda: handle_whoami(message_from_id, deviceID, hop, snr, rssi, pkiStatus),
+    "whois": lambda: handle_whois(message, deviceID, channel_number, message_from_id),
    "wiki:": lambda: handle_wiki(message, isDM),
    "wiki?": lambda: handle_wiki(message, isDM),
    "wx": lambda: handle_wxc(message_from_id, deviceID, 'wx'),
@@ -85,6 +95,7 @@ def auto_response(message, snr, rssi, hop, pkiStatus, message_from_id, channel_n
    "wxc": lambda: handle_wxc(message_from_id, deviceID, 'wxc'),
    "📍": lambda: handle_whoami(message_from_id, deviceID, hop, snr, rssi, pkiStatus),
    "🔔": lambda: handle_alertBell(message_from_id, deviceID, message),
+    "🐝": lambda: read_file("bee.txt", True),
    # any value from system.py:trap_list_emergency will trigger the emergency function
    "112": lambda: handle_emergency(message_from_id, deviceID, message),
    "911": lambda: handle_emergency(message_from_id, deviceID, message),
@@ -131,6 +142,7 @@ def auto_response(message, snr, rssi, hop, pkiStatus, message_from_id, channel_n

 def handle_ping(message_from_id, deviceID,  message, hop, snr, rssi, isDM, channel_number):
    global multiPing
+    myNodeNum = globals().get(f'myNodeNum{deviceID}', 777)
    if  "?" in message and isDM:
        return message.split("?")[0].title() + " command returns SNR and RSSI, or hopcount from your message. Try adding e.g. @place or #tag"
    
@@ -150,10 +162,7 @@ def handle_ping(message_from_id, deviceID,  message, hop, snr, rssi, isDM, chann
        msg = random.choice(["✋ACK-ACK!\n", "✋Ack to you!\n"])
        type = "✋ACK"
    elif "cqcq" in message.lower() or "cq" in message.lower() or "cqcqcq" in message.lower():
-        if deviceID == 1:
-            myname = get_name_from_number(myNodeNum1, 'short', 1)
-        elif deviceID == 2:
-            myname = get_name_from_number(myNodeNum2, 'short', 2)
+        myname = get_name_from_number(myNodeNum, 'short', deviceID)
        msg = f"QSP QSL OM DE  {myname}   K\n"
    else:
        msg = "🔊 Can you hear me now?"
@@ -170,6 +179,7 @@ def handle_ping(message_from_id, deviceID,  message, hop, snr, rssi, isDM, chann
        msg = msg + " #" + message.split("#")[1]
        type = type + " #" + message.split("#")[1]

+
    # check for multi ping request
    if " " in message:
        # if stop multi ping
@@ -179,6 +189,7 @@ def handle_ping(message_from_id, deviceID,  message, hop, snr, rssi, isDM, chann
                    multiPingList.pop(i)
                    msg = "🛑 auto-ping"

+
        # if 3 or more entries (2 or more active), throttle the multi-ping for congestion
        if len(multiPingList) > 2:
            msg = "🚫⛔️ auto-ping, service busy. ⏳Try again soon."
@@ -189,6 +200,10 @@ def handle_ping(message_from_id, deviceID,  message, hop, snr, rssi, isDM, chann
                pingCount = int(message.split(" ")[1])
                if pingCount == 123 or pingCount == 1234:
                    pingCount =  1
+                elif not autoPingInChannel and not isDM:
+                    # no autoping in channels
+                    pingCount = 1
+
                if pingCount > 51:
                    pingCount = 50
            except:
@@ -200,6 +215,10 @@ def handle_ping(message_from_id, deviceID,  message, hop, snr, rssi, isDM, chann
                msg = f"🛜Initalizing BufferTest, using chunks of about {int(maxBuffer // pingCount)}, max length {maxBuffer} in {pingCount} messages"
            else:
                msg = f"🚦Initalizing {pingCount} auto-ping"
+
+    # if not a DM add the username to the beginning of msg
+    if not useDMForResponse and not isDM:
+        msg = "@" + get_name_from_number(message_from_id, 'short', deviceID) + " " + msg
            
    return msg

@@ -208,15 +227,19 @@ def handle_alertBell(message_from_id, deviceID, message):
    return random.choice(msg)

 def handle_emergency(message_from_id, deviceID, message):
+    myNodeNum = globals().get(f'myNodeNum{deviceID}', 777)
+    # if user in bbs_ban_list return
+    if str(message_from_id) in bbs_ban_list:
+        # silent discard
+        logger.warning(f"System: {message_from_id} on spam list, no emergency responder alert sent")
+        return ''
    # trgger alert to emergency_responder_alert_channel
    if message_from_id != 0:
-        if deviceID == 1: rxNode = myNodeNum1 
-        elif deviceID == 2: rxNode = myNodeNum2
        nodeLocation = get_node_location(message_from_id, deviceID)
        # if default location is returned set to Unknown
        if nodeLocation[0] == latitudeValue and nodeLocation[1] == longitudeValue:
            nodeLocation = ["?", "?"]
-        nodeInfo = f"{get_name_from_number(message_from_id, 'short', deviceID)} detected by {get_name_from_number(rxNode, 'short', deviceID)} lastGPS {nodeLocation[0]}, {nodeLocation[1]}"
+        nodeInfo = f"{get_name_from_number(message_from_id, 'short', deviceID)} detected by {get_name_from_number(myNodeNum, 'short', deviceID)} lastGPS {nodeLocation[0]}, {nodeLocation[1]}"
        msg = f"🔔🚨Intercepted Possible Emergency Assistance needed for: {nodeInfo}"
        # alert the emergency_responder_alert_channel
        time.sleep(responseDelay)
@@ -265,9 +288,9 @@ def handle_wxalert(message_from_id, deviceID, message):
        location = get_node_location(message_from_id, deviceID)
        if "wxalert" in message:
            # Detailed weather alert
-            weatherAlert = getActiveWeatherAlertsDetail(str(location[0]), str(location[1]))
+            weatherAlert = getActiveWeatherAlertsDetailNOAA(str(location[0]), str(location[1]))
        else:
-            weatherAlert = getWeatherAlerts(str(location[0]), str(location[1]))
+            weatherAlert = getWeatherAlertsNOAA(str(location[0]), str(location[1]))
        
        if NO_ALERTS not in weatherAlert:
            weatherAlert = weatherAlert[0]
@@ -289,6 +312,34 @@ llmRunCounter = 0
 llmTotalRuntime = []
 llmLocationTable = [{'nodeID': 1234567890, 'location': 'No Location'},]

+def handle_satpass(message_from_id, deviceID, channel_number, message):
+    location = get_node_location(message_from_id, deviceID)
+    passes = ''
+    satList = satListConfig
+    message = message.lower()
+
+    # if user has a NORAD ID in the message
+    if "satpass " in message:
+        try:
+            userList = message.split("satpass ")[1].split(" ")[0]
+            #split userList and make into satList overrided the config.ini satList
+            satList = userList.split(",")
+        except:
+            return "example use:🛰️satpass 25544,33591"
+
+    # Detailed satellite pass
+    for bird in satList:
+        satPass = getNextSatellitePass(bird, str(location[0]), str(location[1]))
+        if satPass:
+            # append to passes
+            passes = passes + satPass + "\n"
+    # remove the last newline
+    passes = passes[:-1]
+
+    if passes == '':
+        passes = "No 🛰️ anytime soon"
+    return passes
+        
 def handle_llm(message_from_id, channel_number, deviceID, message, publicChannel):
    global llmRunCounter, llmLocationTable, llmTotalRuntime, cmdHistory
    location_name = 'no location provided'
@@ -447,8 +498,9 @@ def handleLemonade(message, nodeID, deviceID):
        if highScore != 0:
            if highScore['userID'] != 0:
                nodeName = get_name_from_number(highScore['userID'])
-                if nodeName.isnumeric() and interface2_enabled:
-                    nodeName = get_name_from_number(highScore['userID'], 'long', 2)
+                if nodeName.isnumeric() and multiple_interface:
+                    logger.debug(f"System: TODO is multiple interface fix mention this please nodeName: {nodeName}")
+                    #nodeName = get_name_from_number(highScore['userID'], 'long', 2)
                msg += f" HighScore🥇{nodeName} 💰{round(highScore['cash'], 2)}k "
    
    msg += start_lemonade(nodeID=nodeID, message=message, celsius=False)
@@ -487,8 +539,9 @@ def handleBlackJack(message, nodeID, deviceID):
            if highScore != 0:
                if highScore['nodeID'] != 0:
                    nodeName = get_name_from_number(highScore['nodeID'])
-                    if nodeName.isnumeric() and interface2_enabled:
-                        nodeName = get_name_from_number(highScore['nodeID'], 'long', 2)
+                    if nodeName.isnumeric() and multiple_interface:
+                        logger.debug(f"System: TODO is multiple interface fix mention this please nodeName: {nodeName}")
+                        #nodeName = get_name_from_number(highScore['nodeID'], 'long', 2)
                    msg += f" HighScore🥇{nodeName} with {highScore['highScore']} chips. "
    time.sleep(responseDelay + 1) # short answers with long replies can cause message collision added wait
    return msg
@@ -522,8 +575,9 @@ def handleVideoPoker(message, nodeID, deviceID):
            if highScore != 0:
                if highScore['nodeID'] != 0:
                    nodeName = get_name_from_number(highScore['nodeID'])
-                    if nodeName.isnumeric() and interface2_enabled:
-                        nodeName = get_name_from_number(highScore['nodeID'], 'long', 2)
+                    if nodeName.isnumeric() and multiple_interface:
+                        logger.debug(f"System: TODO is multiple interface fix mention this please nodeName: {nodeName}")
+                        #nodeName = get_name_from_number(highScore['nodeID'], 'long', 2)
                    msg += f" HighScore🥇{nodeName} with {highScore['highScore']} coins. "
    
        if last_cmd != "" and nodeID != 0:
@@ -601,30 +655,65 @@ def handleGolf(message, nodeID, deviceID):
    time.sleep(responseDelay + 1)
    return msg

+def handle_riverFlow(message, message_from_id, deviceID):
+    location = get_node_location(message_from_id, deviceID)
+    userRiver = message.lower()
+    
+    if "riverflow " in userRiver:
+        userRiver = userRiver.split("riverflow ")[1] if "riverflow " in userRiver else riverListDefault
+    else:
+        userRiver = userRiver.split(",") if "," in userRiver else riverListDefault
+    
+    # return river flow data
+    if use_meteo_wxApi:
+        return get_flood_openmeteo(location[0], location[1])
+    else:
+        # if userRiver a list
+        if type(userRiver) == list:
+            msg = ""
+            for river in userRiver:
+                msg += get_flood_noaa(location[0], location[1], river)
+            return msg
+        # if single river
+        msg = get_flood_noaa(location[0], location[1], userRiver)
+        return msg
+
+
 def handle_wxc(message_from_id, deviceID, cmd):
    location = get_node_location(message_from_id, deviceID)
    if use_meteo_wxApi and not "wxc" in cmd and not use_metric:
-        logger.debug("System: Bot Returning Open-Meteo API for weather imperial")
+        #logger.debug("System: Bot Returning Open-Meteo API for weather imperial")
        weather = get_wx_meteo(str(location[0]), str(location[1]))
    elif use_meteo_wxApi:
-        logger.debug("System: Bot Returning Open-Meteo API for weather metric")
+        #logger.debug("System: Bot Returning Open-Meteo API for weather metric")
        weather = get_wx_meteo(str(location[0]), str(location[1]), 1)
    elif not use_meteo_wxApi and "wxc" in cmd or use_metric:
-        logger.debug("System: Bot Returning NOAA API for weather metric")
-        weather = get_weather(str(location[0]), str(location[1]), 1)
+        #logger.debug("System: Bot Returning NOAA API for weather metric")
+        weather = get_NOAAweather(str(location[0]), str(location[1]), 1)
    else:
-        logger.debug("System: Bot Returning NOAA API for weather imperial")
-        weather = get_weather(str(location[0]), str(location[1]))
+        #logger.debug("System: Bot Returning NOAA API for weather imperial")
+        weather = get_NOAAweather(str(location[0]), str(location[1]))
    return weather

-def handle_fema_alerts(message, message_from_id, deviceID):
+def handle_emergency_alerts(message, message_from_id, deviceID):
    location = get_node_location(message_from_id, deviceID)
+    if enableDEalerts:
+        # nina Alerts
+        return get_nina_alerts()
+    if enableGBalerts:
+        # UK Alerts
+        return get_govUK_alerts(str(location[0]), str(location[1]))
    if message.lower().startswith("ealert"):
-        # Detailed alert
+        # Detailed alert FEMA
        return getIpawsAlert(str(location[0]), str(location[1]))
    else:
-        # Headlines only
+        # Headlines only FEMA
        return getIpawsAlert(str(location[0]), str(location[1]), shortAlerts=True)
+    
+def handle_checklist(message, message_from_id, deviceID):
+    name = get_name_from_number(message_from_id, 'short', deviceID)
+    location = get_node_location(message_from_id, deviceID)
+    return process_checklist_command(message_from_id, message, name, location)

 def handle_bbspost(message, message_from_id, deviceID):
    if "$" in message and not "example:" in message:
@@ -692,6 +781,16 @@ def handle_sun(message_from_id, deviceID, channel_number):
    location = get_node_location(message_from_id, deviceID, channel_number)
    return get_sun(str(location[0]), str(location[1]))

+def sysinfo(message, message_from_id, deviceID):
+    if "?" in message:
+        return "sysinfo command returns system information."
+    else:
+        if enable_runShellCmd and file_monitor_enabled:
+            shellData = call_external_script(None, "script/sysEnv.sh").rstrip()
+            return get_sysinfo(message_from_id, deviceID) + "\n" + shellData
+        else:
+            return get_sysinfo(message_from_id, deviceID)
+
 def handle_lheard(message, nodeid, deviceID, isDM):
    if  "?" in message and isDM:
        return message.split("?")[0].title() + " command returns a list of the nodes that have been heard recently"
@@ -782,7 +881,7 @@ def handle_repeaterQuery(message_from_id, deviceID, channel_number):

 def handle_tide(message_from_id, deviceID, channel_number):
    location = get_node_location(message_from_id, deviceID, channel_number)
-    return get_tide(str(location[0]), str(location[1]))
+    return get_NOAAtide(str(location[0]), str(location[1]))

 def handle_moon(message_from_id, deviceID, channel_number):
    location = get_node_location(message_from_id, deviceID, channel_number)
@@ -813,6 +912,46 @@ def handle_whoami(message_from_id, deviceID, hop, snr, rssi, pkiStatus):
        msg = "Error in whoami"
    return msg

+def handle_whois(message, deviceID, channel_number, message_from_id):
+    #return data on a node name or number
+    if  "?" in message:
+        return message.split("?")[0].title() + " command returns information on a node."
+    else:
+        # get the nodeID from the message
+        msg = ''
+        node = ''
+        # find the requested node in db
+        if " " in message:
+            node = message.split(" ")[1]
+        if node.startswith("!") and len(node) == 9:
+            # mesh !hex
+            try:
+                node = int(node.strip("!"),16)
+            except ValueError as e:
+                node = 0
+        elif node.isalpha() or not node.isnumeric():
+            # try short name
+            node = get_num_from_short_name(node, deviceID)
+
+        # get details on the node
+        for i in range(len(seenNodes)):
+            if seenNodes[i]['nodeID'] == int(node):
+                msg = f"Node: {seenNodes[i]['nodeID']} is {get_name_from_number(seenNodes[i]['nodeID'], 'long', deviceID)}\n"
+                msg += f"Last 👀: {time.ctime(seenNodes[i]['lastSeen'])} "
+                break
+
+        if msg == '':
+            msg = "Provide a valid node number or short name"
+        else:
+            # if the user is an admin show the channel and interface and location
+            if str(message_from_id) in bbs_admin_list:
+                location = get_node_location(seenNodes[i]['nodeID'], deviceID, channel_number)
+                msg += f"Ch: {seenNodes[i]['channel']}, Int: {seenNodes[i]['rxInterface']}"
+                msg += f"Lat: {location[0]}, Lon: {location[1]}\n"
+                if location != [latitudeValue, longitudeValue]:
+                    msg += f"Loc: {where_am_i(str(location[0]), str(location[1]))}"
+        return msg
+
 def check_and_play_game(tracker, message_from_id, message_string, rxNode, channel_number, game_name, handle_game_func):
    global llm_enabled

@@ -877,24 +1016,39 @@ def onReceive(packet, interface):
    # set the value for the incomming interface
    if rxType == 'SerialInterface':
        rxInterface = interface.__dict__.get('devPath', 'unknown')
-        if port1 in rxInterface:
-            rxNode = 1
-        elif interface2_enabled and port2 in rxInterface:
-            rxNode = 2
+        if port1 in rxInterface: rxNode = 1
+        elif multiple_interface and port2 in rxInterface: rxNode = 2
+        elif multiple_interface and port3 in rxInterface: rxNode = 3
+        elif multiple_interface and port4 in rxInterface: rxNode = 4
+        elif multiple_interface and port5 in rxInterface: rxNode = 5
+        elif multiple_interface and port6 in rxInterface: rxNode = 6
+        elif multiple_interface and port7 in rxInterface: rxNode = 7
+        elif multiple_interface and port8 in rxInterface: rxNode = 8
+        elif multiple_interface and port9 in rxInterface: rxNode = 9
    
    if rxType == 'TCPInterface':
        rxHost = interface.__dict__.get('hostname', 'unknown')
-        if hostname1 in rxHost and interface1_type == 'tcp':
-            rxNode = 1
-        elif interface2_enabled and hostname2 in rxHost and interface2_type == 'tcp':
-            rxNode = 2
+        if hostname1 in rxHost and interface1_type == 'tcp': rxNode = 1
+        elif multiple_interface and hostname2 in rxHost and interface2_type == 'tcp': rxNode = 2
+        elif multiple_interface and hostname3 in rxHost and interface3_type == 'tcp': rxNode = 3
+        elif multiple_interface and hostname4 in rxHost and interface4_type == 'tcp': rxNode = 4
+        elif multiple_interface and hostname5 in rxHost and interface5_type == 'tcp': rxNode = 5
+        elif multiple_interface and hostname6 in rxHost and interface6_type == 'tcp': rxNode = 6
+        elif multiple_interface and hostname7 in rxHost and interface7_type == 'tcp': rxNode = 7
+        elif multiple_interface and hostname8 in rxHost and interface8_type == 'tcp': rxNode = 8
+        elif multiple_interface and hostname9 in rxHost and interface9_type == 'tcp': rxNode = 9

    if rxType == 'BLEInterface':
-        if interface1_type == 'ble':
-            rxNode = 1
-        elif interface2_enabled and interface2_type == 'ble':
-            rxNode = 2
-
+        if interface1_type == 'ble': rxNode = 1
+        elif multiple_interface and interface2_type == 'ble': rxNode = 2
+        elif multiple_interface and interface3_type == 'ble': rxNode = 3
+        elif multiple_interface and interface4_type == 'ble': rxNode = 4
+        elif multiple_interface and interface5_type == 'ble': rxNode = 5
+        elif multiple_interface and interface6_type == 'ble': rxNode = 6
+        elif multiple_interface and interface7_type == 'ble': rxNode = 7
+        elif multiple_interface and interface8_type == 'ble': rxNode = 8
+        elif multiple_interface and interface9_type == 'ble': rxNode = 9
+    
    # check if the packet has a channel flag use it
    if packet.get('channel'):
        channel_number = packet.get('channel', 0)
@@ -924,6 +1078,10 @@ def onReceive(packet, interface):
            message_bytes = packet['decoded']['payload']
            message_string = message_bytes.decode('utf-8')

+            # check if the packet is from us
+            if message_from_id in [myNodeNum1, myNodeNum2, myNodeNum3, myNodeNum4, myNodeNum5, myNodeNum6, myNodeNum7, myNodeNum8, myNodeNum9]:
+                logger.warning(f"System: Packet from self {message_from_id} loop or traffic replay deteted")
+
            # get the signal strength and snr if available
            if packet.get('rxSnr') or packet.get('rxRssi'):
                snr = packet.get('rxSnr', 0)
@@ -964,6 +1122,9 @@ def onReceive(packet, interface):
            if hop_start == hop_limit:
                hop = "Direct"
                hop_count = 0
+            elif hop_start == 0 and hop_limit > 0:
+                hop = "MQTT"
+                hop_count = 0
            else:
                # set hop to Direct if the message was sent directly otherwise set the hop count
                if hop_away > 0:
@@ -980,7 +1141,7 @@ def onReceive(packet, interface):
                return
        
            # If the packet is a DM (Direct Message) respond to it, otherwise validate its a message for us on the channel
-            if packet['to'] == myNodeNum1 or packet['to'] == myNodeNum2:
+            if packet['to'] in [myNodeNum1, myNodeNum2, myNodeNum3, myNodeNum4, myNodeNum5, myNodeNum6, myNodeNum7, myNodeNum8, myNodeNum9]:
                # message is DM to us
                isDM = True
                # check if the message contains a trap word, DMs are always responded to
@@ -1078,39 +1239,51 @@ def onReceive(packet, interface):
                        msgLogger.info(f"Device:{rxNode} Channel:{channel_number} | {get_name_from_number(message_from_id, 'long', rxNode)} | " + message_string.replace('\n', '-nl-'))

                     # repeat the message on the other device
-                    if repeater_enabled and interface2_enabled:         
+                    if repeater_enabled and multiple_interface:         
                        # wait a responseDelay to avoid message collision from lora-ack.
                        time.sleep(responseDelay)
                        rMsg = (f"{message_string} From:{get_name_from_number(message_from_id, 'short', rxNode)}")
                        # if channel found in the repeater list repeat the message
                        if str(channel_number) in repeater_channels:
-                            if rxNode == 1:
-                                logger.debug(f"Repeating message on Device2 Channel:{channel_number}")
-                                send_message(rMsg, channel_number, 0, 2)
-                            elif rxNode == 2:
-                                logger.debug(f"Repeating message on Device1 Channel:{channel_number}")
-                                send_message(rMsg, channel_number, 0, 1)
+                            for i in range(1, 10):
+                                if globals().get(f'interface{i}_enabled', False) and i != rxNode:
+                                    logger.debug(f"Repeating message on Device{i} Channel:{channel_number}")
+                                    send_message(rMsg, channel_number, 0, i)
+                                    time.sleep(responseDelay)
+                    
+                    # if QRZ enabled check if we have said hello
+                    if qrz_hello_enabled:
+                        if never_seen_before(message_from_id):
+                            # add to qrz_hello list
+                            hello(message_from_id, get_name_from_number(message_from_id, 'short', rxNode))
+                            # send a hello message as a DM
+                            send_message(f"Hello {get_name_from_number(message_from_id, 'short', rxNode)} {qrz_hello_string}", channel_number, message_from_id, rxNode)
+                            time.sleep(responseDelay)
        else:
            # Evaluate non TEXT_MESSAGE_APP packets
-            consumeMetadata(packet, rxNode)    
+            consumeMetadata(packet, rxNode)
    except KeyError as e:
        logger.critical(f"System: Error processing packet: {e} Device:{rxNode}")
        logger.debug(f"System: Error Packet = {packet}")

 async def start_rx():
    print (CustomFormatter.bold_white + f"\nMeshtastic Autoresponder Bot CTL+C to exit\n" + CustomFormatter.reset)
-    if llm_enabled:
-        logger.debug(f"System: Ollama LLM Enabled, loading model {llmModel} please wait")
-        llm_query(" ", myNodeNum1)
-        logger.debug(f"System: LLM model {llmModel} loaded")
+
    # Start the receive subscriber using pubsub via meshtastic library
    pub.subscribe(onReceive, 'meshtastic.receive')
    pub.subscribe(onDisconnect, 'meshtastic.connection.lost')
-    logger.info(f"System: Autoresponder Started for Device1 {get_name_from_number(myNodeNum1, 'long', 1)}," 
-                f"{get_name_from_number(myNodeNum1, 'short', 1)}. NodeID: {myNodeNum1}, {decimal_to_hex(myNodeNum1)}")
-    if interface2_enabled:
-        logger.info(f"System: Autoresponder Started for Device2 {get_name_from_number(myNodeNum2, 'long', 2)},"
-                    f"{get_name_from_number(myNodeNum2, 'short', 2)}. NodeID: {myNodeNum2}, {decimal_to_hex(myNodeNum2)}")
+
+    for i in range(1, 10):
+        if globals().get(f'interface{i}_enabled', False):
+            myNodeNum = globals().get(f'myNodeNum{i}', 0)
+            logger.info(f"System: Autoresponder Started for Device{i} {get_name_from_number(myNodeNum, 'long', i)},"
+                        f"{get_name_from_number(myNodeNum, 'short', i)}. NodeID: {myNodeNum}, {decimal_to_hex(myNodeNum)}")
+    
+    if llm_enabled:
+        logger.debug(f"System: Ollama LLM Enabled, loading model {llmModel} please wait")
+        llm_query(" ")
+        logger.debug(f"System: LLM model {llmModel} loaded")
+
    if log_messages_to_file:
        logger.debug("System: Logging Messages to disk")
    if syslog_to_file:
@@ -1143,18 +1316,28 @@ async def start_rx():
        logger.debug(f"System: Store and Forward Enabled using limit: {storeFlimit}")
    if useDMForResponse:
        logger.debug(f"System: Respond by DM only")
-    if repeater_enabled and interface2_enabled:
+    if repeater_enabled and multiple_interface:
        logger.debug(f"System: Repeater Enabled for Channels: {repeater_channels}")
    if radio_detection_enabled:
        logger.debug(f"System: Radio Detection Enabled using rigctld at {rigControlServerAddress} brodcasting to channels: {sigWatchBroadcastCh} for {get_freq_common_name(get_hamlib('f'))}")
    if file_monitor_enabled:
        logger.debug(f"System: File Monitor Enabled for {file_monitor_file_path}, broadcasting to channels: {file_monitor_broadcastCh}")
-    if read_news_enabled:
-        logger.debug(f"System: File Monitor News Reader Enabled for {news_file_path}")
+        if enable_runShellCmd:
+            logger.debug(f"System: Shell Command monitor enabled")
+        if read_news_enabled:
+            logger.debug(f"System: File Monitor News Reader Enabled for {news_file_path}")
+        if bee_enabled:
+            logger.debug(f"System: File Monitor Bee Monitor Enabled for bee.txt")
    if wxAlertBroadcastEnabled:
        logger.debug(f"System: Weather Alert Broadcast Enabled on channels {wxAlertBroadcastChannel}")
+    if emergencyAlertBrodcastEnabled:
+        logger.debug(f"System: Emergency Alert Broadcast Enabled on channels {emergencyAlertBroadcastCh}")
    if emergency_responder_enabled:
        logger.debug(f"System: Emergency Responder Enabled on channels {emergency_responder_alert_channel} for interface {emergency_responder_alert_interface}")
+    if qrz_hello_enabled:
+        logger.debug(f"System: QRZ Hello Enabled")
+    if checklist_enabled:
+        logger.debug(f"System: CheckList Module Enabled")
    if enableSMTP:
        if enableImap:
            logger.debug(f"System: SMTP Email Alerting Enabled using IMAP")
--- a/modules/checklist.py
+++ b/modules/checklist.py
@@ -0,0 +1,150 @@
+# Checkin Checkout database module for the bot
+# K7MHI Kelly Keeton 2024
+
+import sqlite3
+from modules.log import *
+import time
+
+trap_list_checklist = ("checkin", "checkout", "checklist", "purgein", "purgeout")
+
+def initialize_checklist_database():
+    # create the database
+    conn = sqlite3.connect(checklist_db)
+    c = conn.cursor()
+    # Check if the checkin table exists, and create it if it doesn't
+    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)''')
+    # Check if the checkout table exists, and create it if it doesn't
+    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)''')
+    conn.commit()
+    conn.close()
+    logger.debug("System: Ensured data/checklist.db exists with required tables")
+
+def checkin(name, date, time, location, notes):
+    location = ", ".join(map(str, location))
+    # checkin a user
+    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))
+    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))
+        else:
+            raise
+    conn.commit()
+    conn.close()
+    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):
+    location = ", ".join(map(str, location))
+    # checkout a user
+    conn = sqlite3.connect(checklist_db)
+    c = conn.cursor()
+    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 FROM checkin WHERE checkin_id = ?", (checkin_record[0],))
+            checkin_time = c.fetchone()[0]
+            checkin_datetime = time.strptime(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))
+    except sqlite3.OperationalError as e:
+        if "no such table" in str(e):
+            initialize_checklist_database()
+            c.execute("INSERT INTO checkout (checkout_name, checkout_date, checkout_time, location, checkout_notes) VALUES (?, ?, ?, ?, ?)", (name, date, time_str, location, notes))
+        else:
+            raise
+    conn.commit()
+    conn.close()
+    if checkin_record:
+        return "Checked Out: " + str(name) + " duration " + timeCheckedIn
+    else:
+        return "you must check in before checking out"
+
+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)
+
+def list_checkin():
+    # list checkins
+    conn = sqlite3.connect(checklist_db)
+    c = conn.cursor()
+    c.execute("""
+        SELECT * FROM checkin
+        WHERE checkin_id NOT IN (
+            SELECT checkin_id FROM checkout
+            WHERE checkout_date > checkin_date OR (checkout_date = checkin_date AND checkout_time > checkin_time)
+        )
+    """)
+    rows = c.fetchall()
+    conn.close()
+    timeCheckedIn = ""
+    checkin_list = ""
+    for row in rows:
+        #calculate length of time checked in
+        timeCheckedIn = time.strftime("%H:%M:%S", time.gmtime(time.time() - time.mktime(time.strptime(row[2] + " " + row[3], "%Y-%m-%d %H:%M:%S"))))
+        checkin_list += "ID: " + row[1] + " checked-In for " + timeCheckedIn
+        if row[5] != "":
+            checkin_list += " note: " + row[5]
+        if row != rows[-1]:
+            checkin_list += "\n"
+    # if empty list
+    if checkin_list == "":
+        return "No data to display."
+    return checkin_list
+
+def process_checklist_command(nodeID, message, name="none", location="none"):
+    current_date = time.strftime("%Y-%m-%d")
+    current_time = time.strftime("%H:%M:%S")
+    try:
+        comment = message.split(" ", 1)[1]
+    except IndexError:
+        comment = ""
+    # handle checklist commands
+    if "checkin" in message.lower():
+        return checkin(name, current_date, current_time, location, comment)
+    elif "checkout" in message.lower():
+        return checkout(name, current_date, current_time, location, comment)
+    elif "purgein" in message.lower():
+        return delete_checkin(nodeID)
+    elif "purgeout" in message.lower():
+        return delete_checkout(nodeID)
+    elif "checklist" in message.lower():
+        return list_checkin()
+    else:
+        return "Invalid command."
--- a/modules/filemon.py
+++ b/modules/filemon.py
@@ -3,22 +3,36 @@

 from modules.log import *
 import asyncio
+import random
 import os

 trap_list_filemon = ("readnews",)

-def read_file(file_monitor_file_path):
+def read_file(file_monitor_file_path, random_line_only=False):
+
    try:
-        with open(file_monitor_file_path, 'r') as f:
-            content = f.read()
-        return content
+        if not os.path.exists(file_monitor_file_path):
+            logger.warning(f"FileMon: File not found: {file_monitor_file_path}")
+            if file_monitor_file_path == "bee.txt":
+                return "🐝buzz 💐buzz buzz🍯"
+        if random_line_only:
+            # read a random line from the file
+            with open(file_monitor_file_path, 'r') as f:
+                lines = f.readlines()
+                return random.choice(lines)
+        else:
+            # read the whole file
+            with open(file_monitor_file_path, 'r') as f:
+                content = f.read()
+            return content
    except Exception as e:
        logger.warning(f"FileMon: Error reading file: {file_monitor_file_path}")
        return None
    
 def read_news():
    # read the news file on demand
-    return read_file(news_file_path)
+    return read_file(news_file_path, read_news_enabled)
+

 def write_news(content, append=False):
    # write the news file on demand
@@ -47,4 +61,24 @@ async def watch_file():
                content = content.replace('\n', ' ').replace('\r', '').strip()
                if content:
                    return content
-            await asyncio.sleep(1)  # Check every
+            await asyncio.sleep(1)  # Check every
+
+def call_external_script(message, script="script/runShell.sh"):
+    try:
+        # Debugging: Print the current working directory and resolved script path
+        current_working_directory = os.getcwd()
+        script_path = os.path.join(current_working_directory, script)
+
+        if not os.path.exists(script_path):
+            # try the raw script name
+            script_path = script
+            if not os.path.exists(script_path):
+                logger.warning(f"FileMon: Script not found: {script_path}")
+                return "sorry I can't do that"
+            
+        output = os.popen(f"bash {script_path} {message}").read()
+        return output
+    except Exception as e:
+        logger.warning(f"FileMon: Error calling external script: {e}")
+        return None
+    
--- a/modules/globalalert.py
+++ b/modules/globalalert.py
@@ -0,0 +1,77 @@
+# helper functions to use location data for data outside US/north america
+# K7MHI Kelly Keeton 2024
+
+import json # pip install json
+from geopy.geocoders import Nominatim # pip install geopy
+import maidenhead as mh # pip install maidenhead
+import requests # pip install requests
+import bs4 as bs # pip install beautifulsoup4
+import xml.dom.minidom 
+from modules.log import *
+
+trap_list_location_eu = ("ukalert", "ukwx", "ukflood")
+trap_list_location_de = ("dealert", "dewx", "deflood")
+
+def get_govUK_alerts(shortAlerts=False):
+    try:
+        # get UK.gov alerts
+        url = 'https://www.gov.uk/alerts'
+        response = requests.get(url)
+        soup = bs.BeautifulSoup(response.text, 'html.parser')
+        # the alerts are in <h2 class="govuk-heading-m" id="alert-status">
+        alert = soup.find('h2', class_='govuk-heading-m', id='alert-status')
+    except Exception as e:
+        logger.warning("Error getting UK alerts: " + str(e))
+        return NO_ALERTS
+    
+    if alert:
+        return "🚨" + alert.get_text(strip=True)
+    else:
+        return NO_ALERTS
+
+def get_nina_alerts():
+    try:
+        # get api.bund.dev alerts
+        alerts = []
+        for regionalKey in myRegionalKeysDE:
+            url = ("https://nina.api.proxy.bund.dev/api31/dashboard/" + regionalKey + ".json")
+            response = requests.get(url)
+            data = response.json()
+
+            for item in data:
+                title = item["i18nTitle"]["de"]
+                alerts.append(f"🚨 {title}")
+        return "\n".join(alerts) if alerts else NO_ALERTS
+    except Exception as e:
+        logger.warning("Error getting NINA DE alerts: " + str(e))
+        return NO_ALERTS
+
+def get_wxUKgov():
+    # get UK weather warnings
+    url = 'https://www.metoffice.gov.uk/weather/guides/rss'
+    url = 'https://www.metoffice.gov.uk/public/data/PWSCache/WarningsRSS/Region/nw'
+    try:
+        # get UK weather warnings
+        url = 'https://www.metoffice.gov.uk/weather/guides/rss'
+        response = requests.get(url)
+        soup = bs.BeautifulSoup(response.content, 'xml')
+        
+        items = soup.find_all('item')
+        alerts = []
+        
+        for item in items:
+            title = item.find('title').get_text(strip=True)
+            description = item.find('description').get_text(strip=True)
+            alerts.append(f"🚨 {title}: {description}")
+        
+        return "\n".join(alerts) if alerts else NO_ALERTS
+    except Exception as e:
+        logger.warning("Error getting UK weather warnings: " + str(e))
+        return NO_ALERTS
+    
+    
+def get_floodUKgov():
+    # get UK flood warnings
+    url = 'https://environment.data.gov.uk/flood-widgets/rss/feed-England.xml'
+    
+    return NO_ALERTS
--- a/modules/gpio.py
+++ b/modules/gpio.py
@@ -0,0 +1,73 @@
+# GPIO module for MeshLink, concept code, not implemented
+# K7MHI Kelly Keeton 2024
+
+# https://pypi.org/project/gpio/
+#import gpio
+
+# https://pythonhosted.org/RPIO/
+import RPIO
+
+from modules.log import *
+trap_list_gpio = ("gpio", "pin", "relay", "switch", "pwm")
+
+# set up input channel without pull-up
+RPIO.setup(7, RPIO.IN)
+
+# set up input channel with pull-up
+RPIO.setup(8, RPIO.IN, pull_up_down=RPIO.PUD_UP)
+
+# set up GPIO output channel
+RPIO.setup(8, RPIO.OUT)
+
+# change to BOARD numbering schema
+RPIO.setmode(RPIO.BOARD)
+
+# set up PWM channel
+RPIO.setup(12, RPIO.OUT)
+p = RPIO.PWM(12)
+
+def gpio_status():
+    # get status of GPIO pins
+    gpio_status = ""
+    gpio_status += "GPIO 7: " + str(RPIO.input(7)) + "\n"
+    gpio_status += "GPIO 8: " + str(RPIO.input(8)) + "\n"
+    gpio_status += "GPIO 12: " + str(RPIO.input(12)) + "\n"
+    return gpio_status
+
+def gpio_toggle():
+    # toggle GPIO pin 8
+    RPIO.output(8, not RPIO.input(8))
+    return "GPIO 8 toggled"
+
+def gpio_pwm():
+    # set PWM on GPIO pin 12
+    p.start(50)
+    return "PWM started"
+
+def gpio_stop():
+    # stop PWM on GPIO pin 12
+    p.stop()
+    return "PWM stopped"
+
+def gpio_shutdown():
+    # shutdown GPIO
+    RPIO.cleanup()
+    return "GPIO shutdown"
+
+def trap_gpio(message):
+    # trap for GPIO commands
+    if "status" in message:
+        return gpio_status()
+    elif "toggle" in message:
+        return gpio_toggle()
+    elif "pwm" in message:
+        return gpio_pwm()
+    elif "stop" in message:
+        return gpio_stop()
+    elif "shutdown" in message:
+        return gpio_shutdown()
+    else:
+        return "GPIO command not recognized"
+    
+
+    
--- a/modules/locationdata.py
+++ b/modules/locationdata.py
@@ -1,4 +1,4 @@
-# helper functions to use location data like NOAA weather
+# helper functions to use location data for the API for NOAA weather, FEMA iPAWS, and repeater data
 # K7MHI Kelly Keeton 2024

 import json # pip install json
@@ -9,7 +9,7 @@ import bs4 as bs # pip install beautifulsoup4
 import xml.dom.minidom 
 from modules.log import *

-trap_list_location = ("whereami", "tide", "moon", "wx", "wxc", "wxa", "wxalert", "rlist", "ea", "ealert")
+trap_list_location = ("whereami", "tide", "wx", "wxc", "wxa", "wxalert", "rlist", "ea", "ealert", "riverflow")

 def where_am_i(lat=0, lon=0, short=False, zip=False):
    whereIam = ""
@@ -154,9 +154,8 @@ def getArtSciRepeaters(lat=0, lon=0):
    else:
        msg = f"no results.. sorry"
    return msg
-    

-def get_tide(lat=0, lon=0):
+def get_NOAAtide(lat=0, lon=0):
    station_id = ""
    if float(lat) == 0 and float(lon) == 0:
        logger.error("Location:No GPS data, try sending location for tide")
@@ -172,7 +171,7 @@ def get_tide(lat=0, lon=0):
        
        if station_json['stationList'] == [] or station_json['stationList'] is None:
            logger.error("Location:No tide station found")
-            return ERROR_FETCHING_DATA
+            return "No tide station found with info provided"
        
        station_id = station_json['stationList'][0]['stationId']

@@ -219,7 +218,7 @@ def get_tide(lat=0, lon=0):
    tide_table = tide_table[:-1]
    return tide_table
    
-def get_weather(lat=0, lon=0, unit=0):
+def get_NOAAweather(lat=0, lon=0, unit=0):
    # get weather report from NOAA for forecast detailed
    weather = ""
    if float(lat) == 0 and float(lon) == 0:
@@ -263,7 +262,7 @@ def get_weather(lat=0, lon=0, unit=0):
    weather = weather[:-1]

    # get any alerts and return the count
-    alerts = getWeatherAlerts(lat, lon)
+    alerts = getWeatherAlertsNOAA(lat, lon)

    if alerts == ERROR_FETCHING_DATA or alerts == NO_DATA_NOGPS or alerts == NO_ALERTS:
        alert = ""
@@ -333,7 +332,7 @@ def abbreviate_noaa(row):
                    
    return line

-def getWeatherAlerts(lat=0, lon=0, useDefaultLatLon=False):
+def getWeatherAlertsNOAA(lat=0, lon=0, useDefaultLatLon=False):
    # get weather alerts from NOAA limited to ALERT_COUNT with the total number of alerts found
    alerts = ""
    if float(lat) == 0 and float(lon) == 0 and not useDefaultLatLon:
@@ -358,11 +357,13 @@ def getWeatherAlerts(lat=0, lon=0, useDefaultLatLon=False):
    
    alerts = ""
    alertxml = xml.dom.minidom.parseString(alert_data.text)
-
    for i in alertxml.getElementsByTagName("entry"):
-        alerts += (
-            i.getElementsByTagName("title")[0].childNodes[0].nodeValue + "\n"
-        )
+        title = i.getElementsByTagName("title")[0].childNodes[0].nodeValue
+        area_desc = i.getElementsByTagName("cap:areaDesc")[0].childNodes[0].nodeValue
+        if enableExtraLocationWx:
+            alerts += f"{title}. {area_desc.replace(' ', '')}\n"
+        else:
+            alerts += f"{title}\n"

    if alerts == "" or alerts == None:
        return NO_ALERTS
@@ -381,26 +382,27 @@ def getWeatherAlerts(lat=0, lon=0, useDefaultLatLon=False):
    data = "\n".join(alerts.split("\n")[:numWxAlerts]), alert_num
    return data

-wxAlertCache = ""
-def alertBrodcast():
+wxAlertCacheNOAA = ""
+def alertBrodcastNOAA():
    # get the latest weather alerts and broadcast them if there are any
-    global wxAlertCache
-    currentAlert = getWeatherAlerts(latitudeValue, longitudeValue)
+    global wxAlertCacheNOAA
+    currentAlert = getWeatherAlertsNOAA(latitudeValue, longitudeValue)
    # check if any reason to discard the alerts
    if currentAlert == ERROR_FETCHING_DATA or currentAlert == NO_DATA_NOGPS:
        return False
    elif currentAlert == NO_ALERTS:
-        wxAlertCache = ""
+        wxAlertCacheNOAA = ""
        return False
    # broadcast the alerts send to wxBrodcastCh
-    elif currentAlert[0] != wxAlertCache:
+    elif currentAlert[0] not in wxAlertCacheNOAA:
+        # Check if the current alert is not in the weather alert cache
        logger.debug("Location:Broadcasting weather alerts")
-        wxAlertCache = currentAlert[0]
+        wxAlertCacheNOAA = currentAlert[0]
        return currentAlert
    
    return False

-def getActiveWeatherAlertsDetail(lat=0, lon=0):
+def getActiveWeatherAlertsDetailNOAA(lat=0, lon=0):
    # get the latest details of weather alerts from NOAA
    alerts = ""
    if float(lat) == 0 and float(lon) == 0:
@@ -457,7 +459,7 @@ def getIpawsAlert(lat=0, lon=0, shortAlerts = False):
    alerts = []
    
    # set the API URL for IPAWS
-    ipawsPIN = "000000"
+    namespace = "urn:oasis:names:tc:emergency:cap:1.2"
    alert_url = "https://apps.fema.gov/IPAWSOPEN_EAS_SERVICE/rest/feed"
    if ipawsPIN != "000000":
        alert_url += "?pin=" + ipawsPIN
@@ -482,6 +484,7 @@ def getIpawsAlert(lat=0, lon=0, shortAlerts = False):
            #pin check
            if ipawsPIN != "000000":
                link += "?pin=" + ipawsPIN
+            # get the linked alert data from FEMA
            linked_data = requests.get(link, timeout=urlTimeoutSeconds)
            if not linked_data.ok:
                #logger.warning(f"System: iPAWS Error fetching linked alert data from {link}")
@@ -495,21 +498,33 @@ def getIpawsAlert(lat=0, lon=0, shortAlerts = False):

        for info in linked_xml.getElementsByTagName("info"):
            # extract values from XML
-            eventCode_table = info.getElementsByTagName("eventCode")[0]
-            alertType = eventCode_table.getElementsByTagName("valueName")[0].childNodes[0].nodeValue
-            alertCode = eventCode_table.getElementsByTagName("value")[0].childNodes[0].nodeValue
-            headline = info.getElementsByTagName("headline")[0].childNodes[0].nodeValue
-            description = info.getElementsByTagName("description")[0].childNodes[0].nodeValue
-
-            area_table = info.getElementsByTagName("area")[0]
-            areaDesc = area_table.getElementsByTagName("areaDesc")[0].childNodes[0].nodeValue
-            
-            geocode_table = area_table.getElementsByTagName("geocode")[0]
-            geocode_type = geocode_table.getElementsByTagName("valueName")[0].childNodes[0].nodeValue
-            geocode_value = geocode_table.getElementsByTagName("value")[0].childNodes[0].nodeValue
            sameVal = "NONE"
-            if geocode_type == "SAME":
-                sameVal = geocode_value
+            geocode_value = "NONE"
+            description = ""
+            try:
+                eventCode_table = info.getElementsByTagName("eventCode")[0]
+                alertType = eventCode_table.getElementsByTagName("valueName")[0].childNodes[0].nodeValue
+                alertCode = eventCode_table.getElementsByTagName("value")[0].childNodes[0].nodeValue
+                headline = info.getElementsByTagName("headline")[0].childNodes[0].nodeValue
+                # use headline if no description
+                if info.getElementsByTagName("description") and info.getElementsByTagName("description")[0].childNodes:
+                    description = info.getElementsByTagName("description")[0].childNodes[0].nodeValue
+                else:
+                    logger.debug(f"System: report this to discord - iPAWS No description for alert: {headline}")
+                    description = headline
+
+                area_table = info.getElementsByTagName("area")[0]
+                areaDesc = area_table.getElementsByTagName("areaDesc")[0].childNodes[0].nodeValue
+                
+                geocode_table = area_table.getElementsByTagName("geocode")[0]
+                geocode_type = geocode_table.getElementsByTagName("valueName")[0].childNodes[0].nodeValue
+                geocode_value = geocode_table.getElementsByTagName("value")[0].childNodes[0].nodeValue
+                if geocode_type == "SAME":
+                    sameVal = geocode_value
+            except Exception as e:
+                logger.debug(f"System: iPAWS Error extracting alert data: {link}")
+                #print(f"DEBUG: {info.toprettyxml()}")
+                continue

            # check if the alert is for the current location, if wanted keep alert
            if (sameVal in mySAME) or (geocode_value in mySAME):
@@ -529,9 +544,9 @@ def getIpawsAlert(lat=0, lon=0, shortAlerts = False):
                    'geocode_value': geocode_value,
                    'description': description
                })
-            else:
-                # these are discarded some day but logged for debugging currently
-                logger.debug(f"Debug iPAWS: Type:{alertType} Code:{alertCode} Desc:{areaDesc} GeoType:{geocode_type} GeoVal:{geocode_value}, Headline:{headline}")
+            # else:
+            #     # these are discarded some day but logged for debugging currently
+            #     logger.debug(f"Debug iPAWS: Type:{alertType} Code:{alertCode} Desc:{areaDesc} GeoType:{geocode_type} GeoVal:{geocode_value}, Headline:{headline}")
    
    # return the numWxAlerts of alerts
    if len(alerts) > 0:
@@ -548,3 +563,52 @@ def getIpawsAlert(lat=0, lon=0, shortAlerts = False):

    return alert

+def get_flood_noaa(lat=0, lon=0, uid=0):
+    # get the latest flood alert from NOAA
+    api_url = "https://api.water.noaa.gov/nwps/v1/gauges/"
+    headers = {'accept': 'application/json'}
+    if uid == 0:
+        return "No flood gauge data found"
+    try:
+        response = requests.get(api_url + str(uid), headers=headers, timeout=urlTimeoutSeconds)
+        if not response.ok:
+            logger.warning("Location:Error fetching flood gauge data from NOAA for " + str(uid))
+            return ERROR_FETCHING_DATA
+    except (requests.exceptions.RequestException):
+        logger.warning("Location:Error fetching flood gauge data from NOAA for " + str(uid))
+        return ERROR_FETCHING_DATA
+    
+    data = response.json()
+    if not data:
+        return "No flood gauge data found"
+    
+    # extract values from JSON
+    try:
+        name = data['name']
+        status_observed_primary = data['status']['observed']['primary']
+        status_observed_primary_unit = data['status']['observed']['primaryUnit']
+        status_observed_secondary = data['status']['observed']['secondary']
+        status_observed_secondary_unit = data['status']['observed']['secondaryUnit']
+        status_observed_floodCategory = data['status']['observed']['floodCategory']
+        status_forecast_primary = data['status']['forecast']['primary']
+        status_forecast_primary_unit = data['status']['forecast']['primaryUnit']
+        status_forecast_secondary = data['status']['forecast']['secondary']
+        status_forecast_secondary_unit = data['status']['forecast']['secondaryUnit']
+        status_forecast_floodCategory = data['status']['forecast']['floodCategory']
+
+        # except KeyError as e:
+        #     print(f"Missing key in data: {e}")
+        # except TypeError as e:
+        #     print(f"Type error in data: {e}")
+    except Exception as e:
+        logger.debug("Location:Error extracting flood gauge data from NOAA for " + str(uid))
+        return ERROR_FETCHING_DATA
+    
+    # format the flood data
+    logger.debug(f"System: NOAA Flood data for {str(uid)}")
+    flood_data = f"Flood Data {name}:\n"
+    flood_data += f"Observed: {status_observed_primary}{status_observed_primary_unit}({status_observed_secondary}{status_observed_secondary_unit}) risk: {status_observed_floodCategory}"
+    flood_data += f"\nForecast: {status_forecast_primary}{status_forecast_primary_unit}({status_forecast_secondary}{status_forecast_secondary_unit}) risk: {status_forecast_floodCategory}"
+
+    return flood_data
+
--- a/modules/log.py
+++ b/modules/log.py
@@ -3,6 +3,11 @@ from logging.handlers import TimedRotatingFileHandler
 import re
 from datetime import datetime
 from modules.settings import *
+# if LOGGING_LEVEL is not set in settings.py, default to DEBUG
+if not LOGGING_LEVEL:
+    LOGGING_LEVEL = "DEBUG"
+
+LOGGING_LEVEL = getattr(logging, LOGGING_LEVEL)

 class CustomFormatter(logging.Formatter):
    grey = '\x1b[38;21m'
@@ -41,7 +46,7 @@ class plainFormatter(logging.Formatter):

 # Create logger
 logger = logging.getLogger("MeshBot System Logger")
-logger.setLevel(logging.DEBUG)
+logger.setLevel(LOGGING_LEVEL)
 logger.propagate = False

 msgLogger = logging.getLogger("MeshBot Messages Logger")
@@ -56,7 +61,7 @@ today = datetime.now()
 # Create stdout handler for logging to the console
 stdout_handler = logging.StreamHandler()
 # Set level for stdout handler (logs DEBUG level and above)
-stdout_handler.setLevel(logging.DEBUG)
+stdout_handler.setLevel(LOGGING_LEVEL)
 # Set format for stdout handler
 stdout_handler.setFormatter(CustomFormatter(logFormat))
 # Add handlers to the logger
@@ -65,7 +70,7 @@ logger.addHandler(stdout_handler)
 if syslog_to_file:
    # Create file handler for logging to a file
    file_handler_sys = TimedRotatingFileHandler('logs/meshbot.log', when='midnight', backupCount=log_backup_count)
-    file_handler_sys.setLevel(logging.DEBUG) # DEBUG used by default for system logs to disk
+    file_handler_sys.setLevel(LOGGING_LEVEL) # DEBUG used by default for system logs to disk
    file_handler_sys.setFormatter(plainFormatter(logFormat))
    logger.addHandler(file_handler_sys)

@@ -74,4 +79,22 @@ if log_messages_to_file:
    file_handler = TimedRotatingFileHandler('logs/messages.log', when='midnight', backupCount=log_backup_count)
    file_handler.setLevel(logging.INFO) # INFO used for messages to disk
    file_handler.setFormatter(logging.Formatter(msgLogFormat))
-    msgLogger.addHandler(file_handler)
+    msgLogger.addHandler(file_handler)
+
+# Pretty Timestamp
+def getPrettyTime(seconds):
+    # convert unix time to minutes, hours, or days, or years for simple display
+    designator = "s"
+    if seconds > 0:
+        seconds = round(seconds / 60)
+        designator = "m"
+    if seconds > 60:
+        seconds = round(seconds / 60)
+        designator = "h"
+    if seconds > 24:
+        seconds = round(seconds / 24)
+        designator = "d"
+    if seconds > 365:
+        seconds = round(seconds / 365)
+        designator = "y"
+    return str(seconds) + designator
--- a/modules/qrz.py
+++ b/modules/qrz.py
@@ -0,0 +1,53 @@
+# Module to respomnd to new nodes we havent seen before with a hello message
+# K7MHI Kelly Keeton 2024
+
+import sqlite3
+from modules.log import *
+
+def initalize_qrz_database():
+    # create the database
+    conn = sqlite3.connect(qrz_db)
+    c = conn.cursor()
+    # Check if the qrz table exists, and create it if it doesn't
+    c.execute('''CREATE TABLE IF NOT EXISTS qrz
+                 (qrz_id INTEGER PRIMARY KEY, qrz_call TEXT, qrz_name TEXT, qrz_qth TEXT, qrz_notes TEXT)''')
+    conn.commit()
+    conn.close()
+
+def never_seen_before(nodeID):
+    # check if we have seen this node before and sent a hello message
+    conn = sqlite3.connect(qrz_db)
+    c = conn.cursor()
+    try:
+        c.execute("SELECT * FROM qrz WHERE qrz_call = ?", (nodeID,))
+        row = c.fetchone()
+        conn.close()
+        if row is None:
+            return True
+        else:
+            return False
+    except sqlite3.OperationalError as e:
+        if "no such table" in str(e):
+            initalize_qrz_database()
+            return True
+        else:
+            raise
+    
+def hello(nodeID, name):
+    # send a hello message
+    conn = sqlite3.connect(qrz_db)
+    c = conn.cursor()
+    try:
+        c.execute("INSERT INTO qrz (qrz_call, qrz_name) VALUES (?, ?)", (nodeID, name))
+    except sqlite3.OperationalError as e:
+        if "no such table" in str(e):
+            initalize_qrz_database()
+            c.execute("INSERT INTO qrz (qrz_call, qrz_name) VALUES (?, ?)", (nodeID, name))
+        else:
+            raise
+    conn.commit()
+    conn.close()
+    return True
+
+
+    
--- a/modules/settings.py
+++ b/modules/settings.py
@@ -28,6 +28,8 @@ retry_int2 = False
 wiki_return_limit = 3 # limit the number of sentences returned off the first paragraph first hit
 playingGame = False
 GAMEDELAY = 28800 # 8 hours in seconds for game mode holdoff
+cmdHistory = [] # list to hold the last commands
+seenNodes = [] # list to hold the last seen nodes

 # Read the config file, if it does not exist, create basic config file
 config = configparser.ConfigParser() 
@@ -89,11 +91,20 @@ if 'smtp' not in config:
    config['smtp'] = {'sysopEmails': '', 'enableSMTP': 'False', 'enableImap': 'False'}
    config.write(open(config_file, 'w'))

+if 'checklist' not in config:
+    config['checklist'] = {'enabled': 'False', 'checklist_db': 'data/checklist.db'}
+    config.write(open(config_file, 'w'))
+
+if 'qrz' not in config:
+    config['qrz'] = {'enabled': 'False', 'qrz_db': 'data/qrz.db', 'qrz_hello_string': 'send CMD or DM me for more info.'}
+    config.write(open(config_file, 'w'))
+
 # interface1 settings
 interface1_type = config['interface'].get('type', 'serial')
 port1 = config['interface'].get('port', '')
 hostname1 = config['interface'].get('hostname', '')
 mac1 = config['interface'].get('mac', '')
+interface1_enabled = True # gotta have at least one interface

 # interface2 settings
 if 'interface2' in config:
@@ -105,6 +116,81 @@ if 'interface2' in config:
 else:
    interface2_enabled = False

+# interface3 settings
+if 'interface3' in config:
+    interface3_type = config['interface3'].get('type', 'serial')
+    port3 = config['interface3'].get('port', '')
+    hostname3 = config['interface3'].get('hostname', '')
+    mac3 = config['interface3'].get('mac', '')
+    interface3_enabled = config['interface3'].getboolean('enabled', False)
+else:
+    interface3_enabled = False
+
+# interface4 settings
+if 'interface4' in config:
+    interface4_type = config['interface4'].get('type', 'serial')
+    port4 = config['interface4'].get('port', '')
+    hostname4 = config['interface4'].get('hostname', '')
+    mac4 = config['interface4'].get('mac', '')
+    interface4_enabled = config['interface4'].getboolean('enabled', False)
+else:
+    interface4_enabled = False
+
+# interface5 settings
+if 'interface5' in config:
+    interface5_type = config['interface5'].get('type', 'serial')
+    port5 = config['interface5'].get('port', '')
+    hostname5 = config['interface5'].get('hostname', '')
+    mac5 = config['interface5'].get('mac', '')
+    interface5_enabled = config['interface5'].getboolean('enabled', False)
+else:
+    interface5_enabled = False
+
+# interface6 settings
+if 'interface6' in config:
+    interface6_type = config['interface6'].get('type', 'serial')
+    port6 = config['interface6'].get('port', '')
+    hostname6 = config['interface6'].get('hostname', '')
+    mac6 = config['interface6'].get('mac', '')
+    interface6_enabled = config['interface6'].getboolean('enabled', False)
+else:
+    interface6_enabled = False
+
+# interface7 settings
+if 'interface7' in config:
+    interface7_type = config['interface7'].get('type', 'serial')
+    port7 = config['interface7'].get('port', '')
+    hostname7 = config['interface7'].get('hostname', '')
+    mac7 = config['interface7'].get('mac', '')
+    interface7_enabled = config['interface7'].getboolean('enabled', False)
+else:
+    interface7_enabled = False
+
+# interface8 settings
+if 'interface8' in config:
+    interface8_type = config['interface8'].get('type', 'serial')
+    port8 = config['interface8'].get('port', '')
+    hostname8 = config['interface8'].get('hostname', '')
+    mac8 = config['interface8'].get('mac', '')
+    interface8_enabled = config['interface8'].getboolean('enabled', False)
+else:
+    interface8_enabled = False
+
+# interface9 settings
+if 'interface9' in config:
+    interface9_type = config['interface9'].get('type', 'serial')
+    port9 = config['interface9'].get('port', '')
+    hostname9 = config['interface9'].get('hostname', '')
+    mac9 = config['interface9'].get('mac', '')
+    interface9_enabled = config['interface9'].getboolean('enabled', False)
+else:
+    interface9_enabled = False
+
+multiple_interface = False
+if interface2_enabled or interface3_enabled or interface4_enabled or interface5_enabled or interface6_enabled or interface7_enabled or interface8_enabled or interface9_enabled:
+    multiple_interface = True
+    
+
 # variables from the config.ini file
 try:
    # general
@@ -115,6 +201,7 @@ try:
    log_messages_to_file = config['general'].getboolean('LogMessagesToFile', False) # default off
    log_backup_count = config['general'].getint('LogBackupCount', 32) # default 32 days
    syslog_to_file = config['general'].getboolean('SyslogToFile', True) # default on
+    LOGGING_LEVEL = config['general'].get('sysloglevel', 'DEBUG') # default DEBUG
    urlTimeoutSeconds = config['general'].getint('urlTimeout', 10) # default 10 seconds
    store_forward_enabled = config['general'].getboolean('StoreForward', True)
    storeFlimit = config['general'].getint('StoreLimit', 3) # default 3 messages for S&F
@@ -122,17 +209,18 @@ try:
    welcome_message = (f"{welcome_message}").replace('\\n', '\n') # allow for newlines in the welcome message
    motd_enabled = config['general'].getboolean('motdEnabled', True)
    MOTD = config['general'].get('motd', MOTD)
+    autoPingInChannel = config['general'].getboolean('autoPingInChannel', False)
    enableCmdHistory = config['general'].getboolean('enableCmdHistory', True)
    lheardCmdIgnoreNode = config['general'].get('lheardCmdIgnoreNode', '').split(',')
    whoami_enabled = config['general'].getboolean('whoami', True)
    dad_jokes_enabled = config['general'].getboolean('DadJokes', False)
    dad_jokes_emojiJokes = config['general'].getboolean('DadJokesEmoji', False)
+    bee_enabled = config['general'].getboolean('bee', False) # 🐝 off by default undocumented
    solar_conditions_enabled = config['general'].getboolean('spaceWeather', True)
    wikipedia_enabled = config['general'].getboolean('wikipedia', False)
    llm_enabled = config['general'].getboolean('ollama', False) # https://ollama.com
    llmModel = config['general'].get('ollamaModel', 'gemma2:2b') # default gemma2:2b
    ollamaHostName = config['general'].get('ollamaHostName', 'http://localhost:11434') # default localhost
-
    # emergency response
    emergency_responder_enabled = config['emergencyHandler'].getboolean('enabled', False)
    emergency_responder_alert_channel = config['emergencyHandler'].getint('alert_channel', 2) # default 2
@@ -153,22 +241,25 @@ try:
    longitudeValue = config['location'].getfloat('lon', -123.0)
    use_meteo_wxApi = config['location'].getboolean('UseMeteoWxAPI', False) # default False use NOAA
    use_metric = config['location'].getboolean('useMetric', False) # default Imperial units
+    repeater_lookup = config['location'].get('repeaterLookup', 'rbook') # default repeater lookup source
+    n2yoAPIKey = config['location'].get('n2yoAPIKey', '') # default empty
+    satListConfig = config['location'].get('satList', '25544').split(',') # default 25544 ISS
+    riverListDefault = config['location'].get('riverList', '').split(',') # default 12061500 Skagit River
+    # location alerts
+    emergencyAlertBrodcastEnabled = config['location'].getboolean('eAlertBroadcastEnabled', False) # default False
+    wxAlertBroadcastEnabled = config['location'].getboolean('wxAlertBroadcastEnabled', 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
+    mySAME = config['location'].get('mySAME', '').split(',') # default empty
+    myRegionalKeysDE = config['location'].get('myRegionalKeysDE', '110000000000').split(',') # default city Berlin
    forecastDuration = config['location'].getint('NOAAforecastDuration', 4) # NOAA forcast days
    numWxAlerts = config['location'].getint('NOAAalertCount', 2) # default 2 alerts
-    wxAlertsEnabled = config['location'].getboolean('NOAAalertsEnabled', True) # default True not enabled yet
-    repeater_lookup = config['location'].get('repeaterLookup', 'rbook') # default repeater lookup source
-    mySAME = config['location'].get('mySAME', '').split(',') # default empty
-    femaAlertBroadcastEnabled = config['location'].getboolean('femaAlertBroadcastEnabled', False) # default False
-    femaAlertBroadcastCh = config['location'].get('femaAlertBroadcastCh', '2').split(',') # default Channel 2
-    wxAlertBroadcastEnabled = config['location'].getboolean('wxAlertBroadcastEnabled', False) # default False
+    enableExtraLocationWx = config['location'].getboolean('enableExtraLocationWx', False) # default False
+    ipawsPIN = config['location'].get('ipawsPIN', '000000') # default 000000
    ignoreFEMAtest = config['location'].getboolean('ignoreFEMAtest', True) # default True
-    # brodcast channel for weather alerts
-    wxAlertBroadcastChannel = config['location'].get('wxAlertBroadcastCh')
-    if wxAlertBroadcastChannel:
-        if ',' in wxAlertBroadcastChannel:
-            wxAlertBroadcastChannel = config['location'].get('wxAlertBroadcastCh').split(',')
-        else:
-            wxAlertBroadcastChannel = config['location'].getint('wxAlertBroadcastCh', 2) # default 2
+    wxAlertBroadcastChannel = config['location'].get('wxAlertBroadcastCh', '2').split(',') # default Channel 2
+    emergencyAlertBroadcastCh = config['location'].get('eAlertBroadcastCh', '2').split(',') # default Channel 2
    
    # bbs
    bbs_enabled = config['bbs'].getboolean('enabled', False)
@@ -177,7 +268,16 @@ try:
    bbs_admin_list = config['bbs'].get('bbs_admin_list', '').split(',')
    bbs_link_enabled = config['bbs'].getboolean('bbslink_enabled', False)
    bbs_link_whitelist = config['bbs'].get('bbslink_whitelist', '').split(',')
+    
+    # checklist
+    checklist_enabled = config['checklist'].getboolean('enabled', False)
+    checklist_db = config['checklist'].get('checklist_db', 'data/checklist.db')

+    # qrz hello
+    qrz_hello_enabled = config['qrz'].getboolean('enabled', False)
+    qrz_db = config['qrz'].get('qrz_db', 'data/qrz.db')
+    qrz_hello_string = config['qrz'].get('qrz_hello_string', 'send CMD or DM me for more info.')
+    
    # E-Mail Settings
    sysopEmails = config['smtp'].get('sysopEmails', '').split(',')
    enableSMTP = config['smtp'].getboolean('enableSMTP', False)
@@ -217,6 +317,8 @@ try:
    file_monitor_broadcastCh = config['fileMon'].getint('broadcastCh', 2) # default 2
    read_news_enabled = config['fileMon'].getboolean('enable_read_news', False) # default disabled
    news_file_path = config['fileMon'].get('news_file_path', 'news.txt') # default news.txt
+    news_random_line_only = config['fileMon'].getboolean('news_random_line', False) # default False
+    enable_runShellCmd = config['fileMon'].getboolean('enable_runShellCmd', False) # default False

    # games
    game_hop_limit = config['messagingSettings'].getint('game_hop_limit', 5) # default 3 hops
--- a/modules/solarconditions.py
+++ b/modules/solarconditions.py
@@ -9,7 +9,7 @@ import ephem # pip install pyephem
 from datetime import timedelta
 from modules.log import *

-trap_list_solarconditions = ("sun", "solar", "hfcond")
+trap_list_solarconditions = ("sun", "moon", "solar", "hfcond", "satpass")

 def hf_band_conditions():
    # ham radio HF band conditions
@@ -140,3 +140,43 @@ def get_moon(lat=0, lon=0):
        + "\nFullMoon:" + moon_table['next_full_moon'] + "\nNewMoon:" + moon_table['next_new_moon']
    
    return moon_data
+
+def getNextSatellitePass(satellite, lat=0, lon=0):
+    pass_data = ''
+    # get the next satellite pass for a given satellite
+    visualPassAPI = "https://api.n2yo.com/rest/v1/satellite/visualpasses/"
+    if lat == 0 and lon == 0:
+        lat = latitudeValue
+        lon = longitudeValue
+    # API URL
+    if n2yoAPIKey == '':
+        logger.error("System: Missing API key free at https://www.n2yo.com/login/")
+        return "not configured, bug your sysop"
+    url = visualPassAPI + str(satellite) + "/" + str(lat) + "/" + str(lon) + "/0/2/300/" + "&apiKey=" + n2yoAPIKey
+    # get the next pass data
+    try:
+        if not int(satellite):
+            raise Exception("Invalid satellite number")
+        next_pass_data = requests.get(url, timeout=urlTimeoutSeconds)
+        if(next_pass_data.ok):
+            pass_json = next_pass_data.json()
+            if 'info' in pass_json and 'passescount' in pass_json['info'] and pass_json['info']['passescount'] > 0:
+                satname = pass_json['info']['satname']
+                pass_time = pass_json['passes'][0]['startUTC']
+                pass_duration = pass_json['passes'][0]['duration']
+                pass_maxEl = pass_json['passes'][0]['maxEl']
+                pass_rise_time = datetime.fromtimestamp(pass_time).strftime('%a %d %I:%M%p')
+                pass_startAzCompass = pass_json['passes'][0]['startAzCompass']
+                pass_set_time = datetime.fromtimestamp(pass_time + pass_duration).strftime('%a %d %I:%M%p')
+                pass__endAzCompass = pass_json['passes'][0]['endAzCompass']
+                pass_data = f"{satname} @{pass_rise_time} Az:{pass_startAzCompass} for{getPrettyTime(pass_duration)}, MaxEl:{pass_maxEl}° Set@{pass_set_time} Az:{pass__endAzCompass}"
+            elif pass_json['info']['passescount'] == 0:
+                satname = pass_json['info']['satname']
+                pass_data = f"{satname} has no upcoming passes"
+        else:
+            logger.error(f"System: Error fetching satellite pass data {satellite}")
+            pass_data = ERROR_FETCHING_DATA
+    except Exception as e:
+        logger.warning(f"System: User supplied value {satellite} unknown or invalid")
+        pass_data = "Provide NORAD# example use:🛰️satpass 25544,33591"
+    return pass_data
--- a/modules/system.py
+++ b/modules/system.py
--- a/modules/web.py
+++ b/modules/web.py
@@ -0,0 +1,51 @@
+#!/usr/bin/env python3
+# This is a simple web server that serves up the content of the webRoot directory
+# The reporting data is all that is currently being served up
+# TODO - add interaction to mesh?
+# to use this today run it seperately and open a browser to http://localhost:8420
+
+import os
+import http.server
+
+# Set the port for the server
+PORT = 8420
+
+# set webRoot index.html location
+webRoot = "etc/www"
+
+# Set to True to enable logging sdtout
+webServerLogs = False
+
+# Generate with: openssl req -new -x509 -keyout server.pem -out server.pem -days 365 -nodes
+SSL = False
+
+if SSL:
+    import ssl
+
+# disable logging
+class QuietHandler(http.server.SimpleHTTPRequestHandler):
+    def log_message(self, format, *args):
+        if webServerLogs:
+            super().log_message(format, *args)
+
+# Change the current working directory to webRoot
+os.chdir(webRoot)
+
+# boot up simple HTTP server
+httpd = http.server.HTTPServer(('127.0.0.1', PORT), QuietHandler)
+
+if SSL:
+    ctx = ssl.create_default_context(ssl.Purpose.CLIENT_AUTH)
+    try:
+        ctx.load_cert_chain(certfile='./server.pem')
+    except FileNotFoundError:
+        print("SSL certificate file not found. Please generate it using the command provided in the comments.")
+        exit(1)
+    httpd.socket = ctx.wrap_socket(httpd.socket, server_side=True)
+
+print(f"Serving reports at http://localhost:{PORT} Press ^C to quit.\n\n")
+if not webServerLogs:
+    print("Server Logs are disabled")
+# Serve forever, that is until the user interrupts the process
+httpd.serve_forever()
+exit(0)
--- a/modules/wx_meteo.py
+++ b/modules/wx_meteo.py
@@ -1,18 +1,19 @@
-import openmeteo_requests # pip install openmeteo-requests
-from retry_requests import retry # pip install retry_requests
-#import requests_cache
+#import openmeteo_requests # pip install openmeteo-requests
+#from retry_requests import retry # pip install retry_requests
+
+import requests
+import json
 from modules.log import *

+def get_weather_data(api_url, params):
+    response = requests.get(api_url, params=params)
+    response.raise_for_status()  # Raise an error for bad status codes
+    return response.json()
+
 def get_wx_meteo(lat=0, lon=0, unit=0):
 	# set forcast days 1 or 3
 	forecastDays = 3

-	# Setup the Open-Meteo API client with cache and retry on error
-	#cache_session = requests_cache.CachedSession('.cache', expire_after = 3600)
-	#retry_session = retry(cache_session, retries = 5, backoff_factor = 0.2)
-	retry_session = retry(retries = 3, backoff_factor = 0.2)
-	openmeteo = openmeteo_requests.Client(session = retry_session)
-
 	# Make sure all required weather variables are listed here
 	# The order of variables in hourly or daily is important to assign them correctly below
 	url = "https://api.open-meteo.com/v1/forecast"
@@ -34,27 +35,29 @@ def get_wx_meteo(lat=0, lon=0, unit=0):

 	try:
 		# Fetch the weather data
-		responses = openmeteo.weather_api(url, params=params)
+		weather_data = get_weather_data(url, params)
 	except Exception as e:
 		logger.error(f"Error fetching meteo weather data: {e}")
 		return ERROR_FETCHING_DATA

 	# Check if we got a response
 	try:
-		# Process location 
-		response = responses[0]
-		logger.debug(f"Got wx data from Open-Meteo in {response.Timezone()} {response.TimezoneAbbreviation()}")
-
+		# Process location
+		logger.debug(f"System: Pulled from Open-Meteo in {weather_data['timezone']} {weather_data['timezone_abbreviation']}")
+		
+		# Ensure response is defined
+		response = weather_data
+		
 		# Process daily data. The order of variables needs to be the same as requested.
-		daily = response.Daily()
-		daily_weather_code = daily.Variables(0).ValuesAsNumpy()
-		daily_temperature_2m_max = daily.Variables(1).ValuesAsNumpy()
-		daily_temperature_2m_min = daily.Variables(2).ValuesAsNumpy()
-		daily_precipitation_hours = daily.Variables(3).ValuesAsNumpy()
-		daily_precipitation_probability_max = daily.Variables(4).ValuesAsNumpy()
-		daily_wind_speed_10m_max = daily.Variables(5).ValuesAsNumpy()
-		daily_wind_gusts_10m_max = daily.Variables(6).ValuesAsNumpy()
-		daily_wind_direction_10m_dominant = daily.Variables(7).ValuesAsNumpy()
+		daily = response['daily']
+		daily_weather_code = daily['weather_code']
+		daily_temperature_2m_max = daily['temperature_2m_max']
+		daily_temperature_2m_min = daily['temperature_2m_min']
+		daily_precipitation_hours = daily['precipitation_hours']
+		daily_precipitation_probability_max = daily['precipitation_probability_max']
+		daily_wind_speed_10m_max = daily['wind_speed_10m_max']
+		daily_wind_gusts_10m_max = daily['wind_gusts_10m_max']
+		daily_wind_direction_10m_dominant = daily['wind_direction_10m_dominant']
 	except Exception as e:
 		logger.error(f"Error processing meteo weather data: {e}")
 		return ERROR_FETCHING_DATA
@@ -191,3 +194,46 @@ def get_wx_meteo(lat=0, lon=0, unit=0):

 	return weather_report

+def get_flood_openmeteo(lat=0, lon=0):
+	# set forcast days 1 or 3
+	forecastDays = 3
+
+	# Flood data
+	url = "https://flood-api.open-meteo.com/v1/flood"
+	params = {
+		"latitude": {lat},
+		"longitude": {lon},
+		"timezone": "auto",
+		"daily": "river_discharge",
+		"forecast_days": forecastDays
+	}
+
+	try:
+		# Fetch the flood data
+		flood_data = get_weather_data(url, params)
+	except Exception as e:
+		logger.error(f"Error fetching meteo flood data: {e}")
+		return ERROR_FETCHING_DATA
+	
+	# Check if we got a response
+	try:
+		# Process location
+		logger.debug(f"System: Pulled River FLow Data from Open-Meteo {flood_data['timezone_abbreviation']}")
+		
+		# Ensure response is defined
+		response = flood_data
+		
+		# Process daily data. The order of variables needs to be the same as requested.
+		daily = response['daily']
+		daily_river_discharge = daily['river_discharge']
+		# check if none
+
+	except Exception as e:
+		logger.error(f"Error processing meteo flood data: {e}")
+		return ERROR_FETCHING_DATA
+	
+	# create a flood report
+	flood_report = ""
+	flood_report += "River Discharge: " + str(daily_river_discharge) + "m3/s"
+
+	return flood_report
--- a/pong_bot.py
+++ b/pong_bot.py
@@ -2,14 +2,19 @@
 # Meshtastic Autoresponder PONG Bot
 # K7MHI Kelly Keeton 2024

+try:
+    from pubsub import pub
+except ImportError:
+    print(f"Important dependencies are not met, try install.sh\n\n Did you mean to './launch.sh pong' using a virtual environment.")
+    exit(1)
+
 import asyncio
 import time # for sleep, get some when you can :)
-from pubsub import pub # pip install pubsub
+import random
 from modules.log import *
 from modules.system import *

 # Global Variables
-cmdHistory = [] # list to hold the last commands
 DEBUGpacket = False # Debug print the packet rx

 def auto_response(message, snr, rssi, hop, pkiStatus, message_from_id, channel_number, deviceID, isDM):
@@ -18,17 +23,19 @@ def auto_response(message, snr, rssi, hop, pkiStatus, message_from_id, channel_n
    bot_response = "I'm sorry, I'm afraid I can't do that."

    command_handler = {
+        # Command List processes system.trap_list. system.messageTrap() sends any commands to here
        "ack": lambda: handle_ping(message_from_id, deviceID, message, hop, snr, rssi, isDM, channel_number),
        "cmd": lambda: help_message,
        "cmd?": lambda: help_message,
        "cq": lambda: handle_ping(message_from_id, deviceID, message, hop, snr, rssi, isDM, channel_number),
        "cqcq": lambda: handle_ping(message_from_id, deviceID, message, hop, snr, rssi, isDM, channel_number),
        "cqcqcq": lambda: handle_ping(message_from_id, deviceID, message, hop, snr, rssi, isDM, channel_number),
-        "lheard": lambda: handle_lheard(interface1, interface2_enabled, myNodeNum1, myNodeNum2),
+        "lheard": lambda: handle_lheard(message, message_from_id, deviceID, isDM),
        "motd": lambda: handle_motd(message, MOTD),
        "ping": lambda: handle_ping(message_from_id, deviceID, message, hop, snr, rssi, isDM, channel_number),
        "pong": lambda: "🏓PING!!🛜",
-        "sitrep": lambda: handle_lheard(interface1, interface2_enabled, myNodeNum1, myNodeNum2),
+        "sitrep": lambda: lambda: handle_lheard(message, message_from_id, deviceID, isDM),
+        "sysinfo": lambda: sysinfo(message, message_from_id, deviceID),
        "test": lambda: handle_ping(message_from_id, deviceID, message, hop, snr, rssi, isDM, channel_number),
        "testing": lambda: handle_ping(message_from_id, deviceID, message, hop, snr, rssi, isDM, channel_number),
    }
@@ -90,6 +97,7 @@ def handle_ping(message_from_id, deviceID,  message, hop, snr, rssi, isDM, chann
        msg = msg + " #" + message.split("#")[1]
        type = type + " #" + message.split("#")[1]

+
    # check for multi ping request
    if " " in message:
        # if stop multi ping
@@ -99,6 +107,7 @@ def handle_ping(message_from_id, deviceID,  message, hop, snr, rssi, isDM, chann
                    multiPingList.pop(i)
                    msg = "🛑 auto-ping"

+
        # if 3 or more entries (2 or more active), throttle the multi-ping for congestion
        if len(multiPingList) > 2:
            msg = "🚫⛔️ auto-ping, service busy. ⏳Try again soon."
@@ -109,6 +118,10 @@ def handle_ping(message_from_id, deviceID,  message, hop, snr, rssi, isDM, chann
                pingCount = int(message.split(" ")[1])
                if pingCount == 123 or pingCount == 1234:
                    pingCount =  1
+                elif not autoPingInChannel and not isDM:
+                    # no autoping in channels
+                    pingCount = 1
+
                if pingCount > 51:
                    pingCount = 50
            except:
@@ -120,6 +133,10 @@ def handle_ping(message_from_id, deviceID,  message, hop, snr, rssi, isDM, chann
                msg = f"🛜Initalizing BufferTest, using chunks of about {int(maxBuffer // pingCount)}, max length {maxBuffer} in {pingCount} messages"
            else:
                msg = f"🚦Initalizing {pingCount} auto-ping"
+
+    # if not a DM add the username to the beginning of msg
+    if not useDMForResponse and not isDM:
+        msg = "@" + get_name_from_number(message_from_id, 'short', deviceID) + " " + msg
            
    return msg

@@ -131,6 +148,12 @@ def handle_motd(message):
        return "MOTD Set to: " + MOTD
    else:
        return MOTD
+    
+def sysinfo(message, message_from_id, deviceID):
+    if "?" in message:
+        return "sysinfo command returns system information."
+    else:
+        return get_sysinfo(message_from_id, deviceID)

 def handle_lheard(message, nodeid, deviceID, isDM):
    if  "?" in message and isDM:
@@ -152,6 +175,7 @@ def handle_lheard(message, nodeid, deviceID, isDM):
    return bot_response

 def onReceive(packet, interface):
+    global seenNodes
    # Priocess the incoming packet, handles the responses to the packet with auto_response()
    # Sends the packet to the correct handler for processing

@@ -161,6 +185,8 @@ def onReceive(packet, interface):
    # Valies assinged to the packet
    rxNode, message_from_id, snr, rssi, hop, hop_away, channel_number = 0, 0, 0, 0, 0, 0, 0
    pkiStatus = (False, 'ABC')
+    replyIDset = False
+    emojiSeen = False
    isDM = False

    if DEBUGpacket:
@@ -173,23 +199,45 @@ def onReceive(packet, interface):
    # set the value for the incomming interface
    if rxType == 'SerialInterface':
        rxInterface = interface.__dict__.get('devPath', 'unknown')
-        if port1 in rxInterface:
-            rxNode = 1
-        elif interface2_enabled and port2 in rxInterface:
-            rxNode = 2
+        if port1 in rxInterface: rxNode = 1
+        elif multiple_interface and port2 in rxInterface: rxNode = 2
+        elif multiple_interface and port3 in rxInterface: rxNode = 3
+        elif multiple_interface and port4 in rxInterface: rxNode = 4
+        elif multiple_interface and port5 in rxInterface: rxNode = 5
+        elif multiple_interface and port6 in rxInterface: rxNode = 6
+        elif multiple_interface and port7 in rxInterface: rxNode = 7
+        elif multiple_interface and port8 in rxInterface: rxNode = 8
+        elif multiple_interface and port9 in rxInterface: rxNode = 9
    
    if rxType == 'TCPInterface':
        rxHost = interface.__dict__.get('hostname', 'unknown')
-        if hostname1 in rxHost and interface1_type == 'tcp':
-            rxNode = 1
-        elif interface2_enabled and hostname2 in rxHost and interface2_type == 'tcp':
-            rxNode = 2
+        if hostname1 in rxHost and interface1_type == 'tcp': rxNode = 1
+        elif multiple_interface and hostname2 in rxHost and interface2_type == 'tcp': rxNode = 2
+        elif multiple_interface and hostname3 in rxHost and interface3_type == 'tcp': rxNode = 3
+        elif multiple_interface and hostname4 in rxHost and interface4_type == 'tcp': rxNode = 4
+        elif multiple_interface and hostname5 in rxHost and interface5_type == 'tcp': rxNode = 5
+        elif multiple_interface and hostname6 in rxHost and interface6_type == 'tcp': rxNode = 6
+        elif multiple_interface and hostname7 in rxHost and interface7_type == 'tcp': rxNode = 7
+        elif multiple_interface and hostname8 in rxHost and interface8_type == 'tcp': rxNode = 8
+        elif multiple_interface and hostname9 in rxHost and interface9_type == 'tcp': rxNode = 9

    if rxType == 'BLEInterface':
-        if interface1_type == 'ble':
-            rxNode = 1
-        elif interface2_enabled and interface2_type == 'ble':
-            rxNode = 2
+        if interface1_type == 'ble': rxNode = 1
+        elif multiple_interface and interface2_type == 'ble': rxNode = 2
+        elif multiple_interface and interface3_type == 'ble': rxNode = 3
+        elif multiple_interface and interface4_type == 'ble': rxNode = 4
+        elif multiple_interface and interface5_type == 'ble': rxNode = 5
+        elif multiple_interface and interface6_type == 'ble': rxNode = 6
+        elif multiple_interface and interface7_type == 'ble': rxNode = 7
+        elif multiple_interface and interface8_type == 'ble': rxNode = 8
+        elif multiple_interface and interface9_type == 'ble': rxNode = 9
+    
+    # check if the packet has a channel flag use it
+    if packet.get('channel'):
+        channel_number = packet.get('channel', 0)
+
+    # set the message_from_id
+    message_from_id = packet['from']

    # check if the packet has a channel flag use it
    if packet.get('channel'):
@@ -200,7 +248,10 @@ def onReceive(packet, interface):
        if 'decoded' in packet and packet['decoded']['portnum'] == 'TEXT_MESSAGE_APP':
            message_bytes = packet['decoded']['payload']
            message_string = message_bytes.decode('utf-8')
-            message_from_id = packet['from']
+
+            # check if the packet is from us
+            if message_from_id == myNodeNum1 or message_from_id == myNodeNum2:
+                logger.warning(f"System: Packet from self {message_from_id} loop or traffic replay deteted")

            # get the signal strength and snr if available
            if packet.get('rxSnr') or packet.get('rxRssi'):
@@ -229,6 +280,9 @@ def onReceive(packet, interface):
            if hop_start == hop_limit:
                hop = "Direct"
                hop_count = 0
+            elif hop_start == 0 and hop_limit > 0:
+                hop = "MQTT"
+                hop_count = 0
            else:
                # set hop to Direct if the message was sent directly otherwise set the hop count
                if hop_away > 0:
@@ -307,21 +361,20 @@ def onReceive(packet, interface):
                        msgLogger.info(f"Device:{rxNode} Channel:{channel_number} | {get_name_from_number(message_from_id, 'long', rxNode)} | " + message_string.replace('\n', '-nl-'))

                     # repeat the message on the other device
-                    if repeater_enabled and interface2_enabled:         
+                    if repeater_enabled and multiple_interface:         
                        # wait a responseDelay to avoid message collision from lora-ack.
                        time.sleep(responseDelay)
                        rMsg = (f"{message_string} From:{get_name_from_number(message_from_id, 'short', rxNode)}")
                        # if channel found in the repeater list repeat the message
                        if str(channel_number) in repeater_channels:
-                            if rxNode == 1:
-                                logger.debug(f"Repeating message on Device2 Channel:{channel_number}")
-                                send_message(rMsg, channel_number, 0, 2)
-                            elif rxNode == 2:
-                                logger.debug(f"Repeating message on Device1 Channel:{channel_number}")
-                                send_message(rMsg, channel_number, 0, 1)
+                            for i in range(1, 10):
+                                if globals().get(f'interface{i}_enabled', False) and i != rxNode:
+                                    logger.debug(f"Repeating message on Device{i} Channel:{channel_number}")
+                                    send_message(rMsg, channel_number, 0, i)
+                                    time.sleep(responseDelay)
        else:
            # Evaluate non TEXT_MESSAGE_APP packets
-            consumeMetadata(packet, rxNode)    
+            consumeMetadata(packet, rxNode)
    except KeyError as e:
        logger.critical(f"System: Error processing packet: {e} Device:{rxNode}")
        logger.debug(f"System: Error Packet = {packet}")
@@ -331,11 +384,12 @@ async def start_rx():
    # Start the receive subscriber using pubsub via meshtastic library
    pub.subscribe(onReceive, 'meshtastic.receive')
    pub.subscribe(onDisconnect, 'meshtastic.connection.lost')
-    logger.info(f"System: Autoresponder Started for Device1 {get_name_from_number(myNodeNum1, 'long', 1)}," 
-                f"{get_name_from_number(myNodeNum1, 'short', 1)}. NodeID: {myNodeNum1}, {decimal_to_hex(myNodeNum1)}")
-    if interface2_enabled:
-        logger.info(f"System: Autoresponder Started for Device2 {get_name_from_number(myNodeNum2, 'long', 2)},"
-                    f"{get_name_from_number(myNodeNum2, 'short', 2)}. NodeID: {myNodeNum2}, {decimal_to_hex(myNodeNum2)}")
+    for i in range(1, 10):
+        if globals().get(f'interface{i}_enabled', False):
+            myNodeNum = globals().get(f'myNodeNum{i}', 0)
+            logger.info(f"System: Autoresponder Started for Device{i} {get_name_from_number(myNodeNum, 'long', i)},"
+                        f"{get_name_from_number(myNodeNum, 'short', i)}. NodeID: {myNodeNum}, {decimal_to_hex(myNodeNum)}")
+    
    if log_messages_to_file:
        logger.debug("System: Logging Messages to disk")
    if syslog_to_file:
@@ -350,7 +404,7 @@ async def start_rx():
        logger.debug(f"System: Store and Forward Enabled using limit: {storeFlimit}")
    if useDMForResponse:
        logger.debug(f"System: Respond by DM only")
-    if repeater_enabled and interface2_enabled:
+    if repeater_enabled and multiple_interface:
        logger.debug(f"System: Repeater Enabled for Channels: {repeater_channels}")
    if file_monitor_enabled:
        logger.debug(f"System: File Monitor Enabled for {file_monitor_file_path}, broadcasting to channels: {file_monitor_broadcastCh}")
--- a/requirements.txt
+++ b/requirements.txt
@@ -6,10 +6,8 @@ requests
 maidenhead
 beautifulsoup4
 dadjokes
-openmeteo_requests
-retry_requests
-numpy
 geopy
 schedule
 wikipedia
 googlesearch-python
+sqlite3
--- a/script/docker/README.md
+++ b/script/docker/README.md
@@ -0,0 +1,25 @@
+# How do I use this thing?
+This is not a full turnkey setup for Docker yet but gets you most of the way there!
+
+## Setup New Image
+`docker build -t meshing-around .`
+
+there is also [script/docker/docker-install.bat](script/docker/docker-install.bat) which will automate this.
+
+## Ollama Image with compose
+still a WIP
+`docker compose up -d`
+
+## Edit the config.ini in the docker
+To edit the config.ini in the docker you can
+`docker run -it --entrypoint /bin/bash meshing-around -c "nano /app/config.ini"`
+
+there is also [script/docker/docker-terminal.bat](script/docker/docker-terminal.bat) which will open nano to edit.
+ctl+o to write out and exit editor in shell
+
+## other info
+1. Ensure your serial port is properly shared.
+2. Run the Docker container:
+    ```sh
+    docker run --rm -it --device=/dev/ttyUSB0 meshing-around
+    ```
--- a/script/docker/compose.yaml
+++ b/script/docker/compose.yaml
@@ -0,0 +1,52 @@
+services:
+  meshing-around:
+    build: 
+      context: ../..
+    depends_on:
+      ollama:
+        condition: service_healthy
+    devices:
+      - /dev/ttyAMA10 # Replace this with your actual device!
+    configs:
+      - source: me_config
+        target: /app/config.ini
+    extra_hosts:
+      - "host.docker.internal:host-gateway" # Used to access a local linux meshtasticd device via tcp
+  ollama:
+    image: ollama/ollama:0.5.1
+    volumes:
+      - ./ollama:/root/.ollama
+      - ./ollama-entrypoint.sh:./entrypoint.sh
+    container_name: ollama
+    pull_policy: always
+    tty: true
+    restart: always
+    entrypoint: 
+      - /usr/bin/bash
+      - /script/docker/entrypoint.sh
+    expose:
+      - 11434
+    healthcheck:
+      test: "apt update && apt install curl -y && curl -f http://localhost:11434/api/tags | grep -q llama3.2:3b"
+      interval: 30s
+      timeout: 10s
+      retries: 20
+  node-exporter:
+    image: quay.io/prometheus/node-exporter:latest
+    volumes:
+      - /proc:/host/proc:ro
+      - /sys:/host/sys:ro
+      - /:/rootfs:ro
+    command:
+      - --path.procfs=/host/proc
+      - --path.rootfs=/rootfs
+      - --path.sysfs=/host/sys
+      - --collector.filesystem.mount-points-exclude=^/(sys|proc|dev|host|etc)($$|/)
+    restart: unless-stopped
+    expose:
+      - 9100
+    network_mode: host
+    pid: host
+configs:
+  me_config:
+    file: ./config.ini
--- a/script/docker/docker-install.bat
+++ b/script/docker/docker-install.bat
@@ -0,0 +1,6 @@
+REM batch file to install docker on windows
+REM docker compose up -d
+cd ../../
+docker build -t meshing-around .
+REM docker-compose up -d
+docker run -it --entrypoint /bin/bash meshing-around -c "nano /app/config.ini"
--- a/script/docker/docker-terminal.bat
+++ b/script/docker/docker-terminal.bat
@@ -0,0 +1,2 @@
+REM launch meshing-around container with a terminal
+docker run -it --entrypoint /bin/bash meshing-around
--- a/script/docker/entrypoint.sh
+++ b/script/docker/entrypoint.sh
@@ -0,0 +1,6 @@
+#!/bin/bash
+# instruction set the meshing-around docker container entrypoint
+# Substitute environment variables in the config file (what is the purpose of this?)
+# envsubst < /app/config.ini > /app/config.tmp && mv /app/config.tmp /app/config.ini
+# Run the bot
+exec python /app/mesh_bot.py
--- a/script/docker/ollama-entrypoint.sh
+++ b/script/docker/ollama-entrypoint.sh
@@ -0,0 +1,16 @@
+#!/bin/bash
+
+# Start Ollama in the background.
+/bin/ollama serve &
+# Record Process ID.
+pid=$!
+
+# Pause for Ollama to start.
+sleep 5
+
+echo "🔴 Retrieve llama3.2:3b model..."
+ollama pull llama3.2:3b
+echo "🟢 Done!"
+
+# Wait for Ollama process to finish.
+wait $pid
--- a/script/runShell.sh
+++ b/script/runShell.sh
@@ -0,0 +1,7 @@
+#!/bin/bash
+# meshing-around demo script for shell scripting
+# runShell.sh
+cd "$(dirname "$0")"
+program_path=$(pwd)
+
+printf "Running meshing-around demo script for shell scripting from $program_path\n"
--- a/script/sysEnv.sh
+++ b/script/sysEnv.sh
@@ -0,0 +1,27 @@
+#!/bin/bash
+# meshing-around shell script for sysinfo
+# runShell.sh
+cd "$(dirname "$0")"
+program_path=$(pwd)
+
+# get basic telemetry data. Free space, CPU, RAM, and temperature for a raspberry pi
+free_space=$(df -h | grep ' /$' | awk '{print $4}')
+cpu_usage=$(top -bn1 | grep "Cpu(s)" | sed "s/.*, *\([0-9.]*\)%* id.*/\1/" | awk '{print 100 - $1}')
+ram_usage=$(free | grep Mem | awk '{print $3/$2 * 100.0}')
+ram_free=$(echo "scale=2; 100 - $ram_usage" | bc)
+
+# if command vcgencmd is found, part of raspberrypi tools, use it to get temperature
+if command -v vcgencmd &> /dev/null
+then
+    # get temperature
+    temp=$(vcgencmd measure_temp | sed "s/temp=//" | sed "s/'C//")
+    # temp in fahrenheit
+    tempf=$(echo "scale=2; $temp * 9 / 5 + 32" | bc)
+else
+    # get temperature from thermal zone
+    temp=$(paste <(cat /sys/class/thermal/thermal_zone*/type) <(cat /sys/class/thermal/thermal_zone*/temp) | grep "temp" | awk '{print $2/1000}' | awk '{s+=$1} END {print s/NR}')
+    tempf=$(echo "scale=2; $temp * 9 / 5 + 32" | bc)
+fi
+
+# print telemetry data rounded to 2 decimal places
+printf "Disk:%s RAM:%.2f%% CPU:%.2f%% CPU-T:%.2f°C (%.2f°F)\n" "$free_space" "$ram_usage" "$cpu_usage" "$temp" "$tempf"