lower

Enhance Packet hop and MQTT detection

.gitignore

@@ -7,8 +7,24 @@ config.ini
 # virtualenv
 venv/
 
+# logs
+logs/
+install_notes.txt
+
 # modified .service files
 etc/*.service
 
 # Python cache
 __pycache__/
+
+# rag data
+data/rag/*
+
+# qrz db
+data/qrz.db
+
+# fileMonitor test file
+bee.txt
+
+# .csv files
+*.csv

CONTRIBUTING.md

@@ -1 +1,2 @@
-currently operating under "Agile software development" aka rolling code; no major structure. meshing about .. get it..
+currently operating under "Agile software development" aka rolling code; no major structure. meshing about .. get it..
+there is some ideas for adding code in modules/README.md

Dockerfile

@@ -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"]

README.md

@@ -1,93 +1,236 @@
-# meshing-around
-Random Mesh Scripts for Network Testing and BBS Activities for Use with [Meshtastic](https://meshtastic.org/docs/introduction/) Nodes
+# Mesh Bot for Network Testing and BBS Activities
 
-![alt text](etc/pong-bot.jpg "Example Use")
+Welcome to the Mesh Bot project! This feature-rich bot is designed to enhance your [Meshtastic](https://meshtastic.org/docs/introduction/) network experience with a variety of powerful tools and fun features, connectivity and utility through text-based message delivery. Whether you're looking to perform network tests, send messages, or even play games, [mesh_bot.py](mesh_bot.py) has you covered. 
 
-## mesh_bot.sh
-The feature-rich bot requires the internet for full functionality. These responder bots will trap keywords like ping and respond to a DM (direct message) with pong! The script will also monitor the group channels for keywords to trap. You can also `Ping @Data to Echo` as an example.
+![Example Use](etc/pong-bot.jpg "Example Use")
 
-Along with network testing, this bot has a lot of other fun features, like simple mail messaging you can leave for another device, and when that device is seen, it can send the mail as a DM. Or a scheduler to send weather or a reminder weekly for the VHF net.
+## Key Features
+![CodeQlBadge](https://github.com/SpudGunMan/meshing-around/actions/workflows/dynamic/github-code-scanning/codeql/badge.svg)
 
-The bot is also capable of using dual radio/nodes, so you can monitor two networks at the same time and send messages to nodes using the same `bbspost @nodeNumber #message` or `bbspost @nodeShortName #message` function. There is a small message board to fit in the constraints of Meshtastic for posting bulletin messages with `bbspost $subject #message`.
+### 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
 
-Look up data using wiki results, or interact with [Ollama](https://ollama.com) LLM AI see the [OllamaDocs](https://github.com/ollama/ollama/tree/main/docs) If Ollama is enabled you can DM the bot directly. The default model for mesh-bot which is currently `gemma2:2b`
+### 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
+- **Network Monitoring**: Alert on noisy nodes, node locations, and best placment for relay nodes.
 
-The bot will report on anyone who is getting close to the configured lat/long, if in a remote location. For example having the bot in your camp site alerts when members arive back at camp.
+### Multi Radio/Node Support
+- **Simultaneous Monitoring**: Monitor up to nine networks at the same time.
+- **Flexible Messaging**: send mail and messages, between networks.
 
-Store and forward-like message re-play with `messages`, and there is a repeater module for dual radio bots to cross post messages. Messages are also logged locally to disk.
+### Advanced Messaging Capabilities
+- **Mail Messaging**: Leave messages for other devices, which are sent as DMs when the device is seen.
+- **Scheduler**: Schedule messages like weather updates or reminders for weekly VHF nets.
+- **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(Email) expanding visibility.
+- **New Node Hello**: Send a hello to any new node seen in text message.
 
-There is a small collection of games to play like DopeWars, Lemonade Stand, and BlackJack or VideoPoker to name a few, issuing `games` displays help
+### Interactive AI and Data Lookup
+- **NOAA/USGS location Data**: Get localized weather(alerts), Earthquake, 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.
+- **Satellite Pass Info**: Get passes for satellite at your location.
+- **GeoMeasuring**: HowFar from point to point using collected GPS packets on the bot to plot a course or space. Find Center of points for Fox&Hound direction finding.
 
-The bot can also be used to monitor a radio frequency and let you know when high SNR RF activity is seen. Using Hamlib(rigctld) to watch the S meter on a connected radio. You can send alerts to channels when a frequency is detected for 20 seconds within the thresholds set in config.ini
+### Proximity Alerts
+- **Location-Based Alerts**: Get notified when members arrive back at a configured lat/long, perfect for remote locations like campsites.
+- **High Flying Alerts**: Get notified when nodes with high altitude are seen on mesh
+- **Voice/Command Triggers**: The following keywords can be used via voice (VOX) to trigger bot functions "Hey Chirpy!"
+  - Say "Hey Chirpy.."
+  - `joke`: Tells a joke
+  - `weather`: Returns local weather forecast
+  - `moon`: Returns moonrise/set and phase info
+  - `daylight`: Returns sunrise/sunset times
+  - `river`: Returns NOAA river flow info
+  - `tide`: Returns NOAA tide information
+  - `satellite`: Returns satellite pass info
 
-Any messages that are over 160 characters are chunked into 160 message bytes to help traverse hops, in testing, this keeps delivery success higher.
+### CheckList / Check In Out
+- **Asset Tracking**: Maintain a list of node/asset checkin and checkout. Useful foraccountability of people, assets. Radio-Net, FEMA, Trailhead.
+
+### Fun and Games
+- **Built-in Games**: Enjoy games like DopeWars, Lemonade Stand, BlackJack, and VideoPoker.
+- **FCC ARRL QuizBot**: The exam question pool quiz-bot.
+- **Command-Based Gameplay**: Issue `games` to display help and start playing.
+- **Telemetry Leaderboard**: Fun stats like lowest 🪫 battery or coldest temp 🥶
+
+#### QuizMaster
+- **Interactive Group Quizzes**: The QuizMaster module allows admins to start and stop quiz games for groups. Players can join, leave, and answer questions directly via DM or channel.
+- **Scoring and Leaderboards**: Players can check their scores and see the top performers with `q: score` and `q: top`.
+- **Easy Participation**: Players answer questions by prefixing their answer with `q:`, e.g., `q: 42`.
+
+#### Survey Module
+- **Custom Surveys**: Easily create and deploy custom surveys by editing JSON files in `data/survey`. Multiple surveys can be managed (e.g., `survey snow`).
+- **User Feedback Collection**: Users can participate in surveys via DM, and responses are logged for later review.
+
+### Radio Frequency Monitoring
+- **SNR RF Activity Alerts**: Monitor a radio frequency and get alerts when high SNR RF activity is detected.
+- **Hamlib Integration**: Use Hamlib (rigctld) to watch the S meter on a connected radio.
+- **Speech to Text Brodcasting to Mesh** Using [vosk](https://alphacephei.com/vosk/models) to translate to text. 
+
+### EAS Alerts
+- **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.
+- **USGS Volcano Alerts via API**: Use an internet-connected node to message Emergency Alerts from USGS.
+- **EAS Alerts over the air**: Utilizing external tools to report EAS alerts offline over mesh.
+- **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.
+- **News File**: On request of news, the contents of the file are returned. Can also call multiple news sources or files.
+- **Shell Command Access**: Pass commands via DM directly to the host OS with replay protection.
+
+### Data Reporting
+- **HTML Generator**: Visualize bot traffic and data flows with a built-in HTML generator for [data reporting](logs/README.md).
+- **RSS and news feeds**: Get data in mesh from many sources!
+
+### Robust Message Handling
+- **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, see projects for embedding, [buildroot](https://github.com/buildroot-meshtastic/buildroot-meshtastic), also see [femtofox](https://github.com/noon92/femtofox) for running on luckfox hardware. If you need a local console consider the [firefly](https://github.com/pdxlocations/firefly) project. 🥔 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.
+
+### Quick Setup 
+#### 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
+```
+- **Automated Installation**: `install.sh` will automate optional venv and requirements installation.
+- **Launch Script**: `launch.sh` only used in a venv install, to launch the bot and the report generator.
 
 ## Full list of commands for the bot
 
-- Various solar details for radio propagation (spaceWeather module)
-  - `sun` and `moon` return info on rise and set local time
-  - `solar` gives an idea of the x-ray flux
-  - `hfcond` returns a table of HF solar conditions
-- Bulletin Board (BBS) functions
-  - `bbshelp` returns the following
-  - `bbslist` list the messages by ID and subject
-  - `bbsread` read a message example use: `bbsread #1`
-  - `bbspost` post a message to public board or send a DM example use: `bbspost $subject #message, or bbspost @nodeNumber #message or bbspost @nodeShortName #message`
-  - `bbsdelete` delete a message example use: `bbsdelete #4`
-  - `bbsinfo` Stats on BBS delivery and messages (sysop)
-- Other functions
-  - `whereami` returns the address of location of sender if known
-  - `whoami` returns some details of the node asking
-  - `tide` returns the local tides, NOAA data source
-  - `wx` and `wxc` returns 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
-  - `joke` tells a joke
-  - `wiki: ` will search wikipedia, return the first few sentances of first result if a match `wiki: lora radio`
-  - `askai` and `ask:` will ask Ollama LLM AI for a response `askai what temp do I cook chicken`
-  - `messages` Replay the last messages heard, like Store and Forward
-  - `motd` or to set the message `motd $New Message Of the day`
-  - `lheard` returns the last 5 heard nodes with SNR, can also use `sitrep`
-  - `history` returns the last commands ran by user(s)
-  - `cmd` returns the list of commands (the help message)
-- Games - via DM
-  - `lemonstand` plays the classic Lemonade Stand Finance 
-  - `dopewars` plays the classic drug trader
-  - `blackjack` BlackJack, Casino 21
-  - `videopoker` Video Poker, basic 5 card hold
-  - `mastermind` Classic code-breaking game
-  - `golfsim` Golf Simulator, 9 Hole
+### Networking
+| Command | Description | ✅ Works Off-Grid |
+|---------|-------------|-
+| `ping`, `ack` | Return data for signal. Example: `ping 15 #DrivingI5` (activates auto-ping every 20 seconds for count 15 via DM only) | ✅ |
+| `cmd` | Returns the list of commands (the help message) | ✅ |
+| `history` | Returns the last commands run by user(s) | ✅ |
+| `leaderboard` | Shows extreme mesh metrics like lowest battery 🪫 `leaderboard reset` allows admin reset | ✅ |
+| `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 200 charcters) via DM only | ✅ |
+| `whereami` | Returns the address of the sender's location if known |
+| `whoami` | Returns details of the node asking, also returned when position exchanged 📍 | ✅ |
+| `whois` | Returns details known about node, more data with bbsadmin node | ✅ |
+| `echo` | Echo string back, disabled by default | ✅ |
+| `bannode` | Admin option to prevent a node from using bot. `bannode list` will load and use the data/bbs_ban_list.txt db | ✅ |
 
-## pong_bot.sh
-Stripped-down bot, mostly around for archive purposes. The mesh-bot enhanced modules can be disabled by config to disable features.
+### Radio Propagation & Weather Forecasting
+| Command | Description | |
+|---------|-------------|-------------------
+| `ea` and `ealert` | Return FEMA iPAWS/EAS alerts in USA or DE Headline or expanded details for USA | |
+| `earthquake` | Returns the largest and number of USGS events for the location | |
+| `hfcond` | Returns a table of HF solar conditions | |
+| `rlist` | Returns a table of nearby repeaters from RepeaterBook | |
+| `riverflow` | Return information from NOAA for river flow info. | |
+| `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) | |
+| `valert` | Returns USGS Volcano Data | |
+| `wx` | Return local weather forecast, NOAA or Open Meteo (which also has `wxc` for metric and imperial) | |
+| `wxa` and `wxalert` | Return NOAA alerts. Short title or expanded details | |
+| `mwx` | Return the NOAA Coastal Marine Forecast data | |
 
-## Hardware
-The project is written on Linux on a Pi and should work anywhere [Meshtastic](https://meshtastic.org/docs/software/python/cli/) Python modules will function, with any supported [Meshtastic](https://meshtastic.org/docs/getting-started/) hardware. While BLE and TCP will work, they are not as reliable as serial connections.
+### Bulletin Board & Mail
+| Command | Description | |
+|---------|-------------|-
+| `bbshelp` | Returns the following help message | ✅ |
+| `bbslist` | Lists the messages by ID and subject | ✅ |
+| `bbsread` | Reads a message. Example: `bbsread #1` | ✅ |
+| `bbspost` | Posts a message to the public board or sends a DM(Mail) Examples: `bbspost $subject #message`, `bbspost @nodeNumber #message`, `bbspost @nodeShortName #message` | ✅ |
+| `bbsdelete` | Deletes a message. Example: `bbsdelete #4` | ✅ |
+| `bbsinfo` | Provides stats on BBS delivery and messages (sysop) | ✅ |
+| `bbslink` | Links Bulletin Messages between BBS Systems | ✅ |
+| `email:`  | Sends email to address on file for the node or `email: bob@test.net # hello from mesh` | |
+| `sms:`    | Send sms-email to multiple address on file | |
+| `setemail`| Sets the email for easy communications | |
+| `setsms` | Adds the SMS-Email for quick communications | |
+| `clearsms` | Clears all SMS-Emails on file for node | |
 
-## Install
-Clone the project with `git clone https://github.com/spudgunman/meshing-around`
-code is under a lot of development, so check back often with `git pull`
-Copy [config.template](config.template) to `config.ini` and edit for your needs.
-`pip install -r requirements.txt` 
+### Data Lookup 
+| Command | Description | |
+|---------|-------------|-
+| `askai` and `ask:` | Ask Ollama LLM AI for a response. Example: `askai what temp do I cook chicken` | ✅ |
+| `messages` | Replays the last messages heard on device, like Store and Forward, returns the PublicChannel and Current | ✅ |
+| `readnews` | returns the contents of a file (data/news.txt, by default) can also `news mesh` via the chunker on air | ✅ |
+| `readrss` | returns a set RSS feed on air | |
+| `satpass` | returns the pass info from API for defined NORAD ID in config or Example: `satpass 25544,33591`| |
+| `wiki:` | Searches Wikipedia (or local Kiwix server) and returns the first few sentences of the first result if a match. Example: `wiki: lora radio` |
+| `howfar` | returns the distance you have traveled since your last HowFar. `howfar reset` to start over | ✅ |
+| `howtall` | returns height of something you give a shadow by using sun angle | ✅ |
 
-Optionally:
-- `install.sh` will automate optional venv and requirements installation.
-- `launch.sh` will activate and launch the app in the venv if built.
+### CheckList
+| Command | Description | |
+|---------|-------------|-
+| `checkin` | Check in the node to the checklist database, you can add a note like `checkin ICO` or `checkin radio4` | ✅ |
+| `checkout` | Checkout the node in the checklist database, checkout all from node | ✅ |
+| `checklist` | Display the checklist database, with note | ✅ |
 
-For Docker:
-Check you have serial port properly shared and the GPU if using LLM with [NVidia](https://docs.nvidia.com/datacenter/cloud-native/container-toolkit/latest/docker-specialized.html)
-- `git clone https://github.com/spudgunman/meshing-around`
-- `cd meshing-around && docker build -t meshing-around`
-- `docker run meshing-around`
+### Games (via DM only)
+| Command | Description | |
+|---------|-------------|-
+| `blackjack` | Plays Blackjack (Casino 21) | ✅ |
+| `dopewars` | Plays the classic drug trader game | ✅ |
+| `golfsim` | Plays a 9-hole Golf Simulator | ✅ |
+| `hamtest` | FCC/ARRL Quiz `hamtest general` or `hamtest extra` and `score` | ✅ |
+| `hangman` | Plays the classic word guess game | ✅ |
+| `joke` | Tells a joke | |
+| `lemonstand` | Plays the classic Lemonade Stand finance game | ✅ |
+| `mastermind` | Plays the classic code-breaking game | ✅ |
+| `survey` | Issues out a survey to the user | ✅ |
+| `quiz` | QuizMaster Bot `q: ?` for more | ✅ |
+| `tic-tac-toe`| Plays the game classic game | ✅ |
+| `videopoker` | Plays basic 5-card hold Video Poker | ✅ |
 
-### Configurations
-Copy the [config.template](config.template) to `config.ini` and set the appropriate interface for your method (serial/ble/tcp). While BLE and TCP will work, they are not as reliable as serial connections. There is a watchdog to reconnect tcp if possible. To get BLE mac `meshtastic --ble-scan` **NOTE** I have only tested with a single BLE device and the code is written to only have one interface be a BLE port
+#### QuizMaster
+To use QuizMaster the bbs_admin_list is the QuizMaster, who can `q: start` and `q: stop` to start and stop the game,  `q: broadcast <message>` to send a message to all players.
+Players can `q: join` to join the game, `q: leave` to leave the game, `q: score` to see their score, and `q: top` to see the top 3 players.
+To Answer a question, just type the answer prefixed with `q: <answer>`
 
+#### Survey
+To use the Survey feature edit the json files in data/survey multiple surveys are possible such as `survey snow`
+
+## Other Install Options
+
+### Docker Installation - handy for windows
+See further info on the [docker.md](script/docker/README.md)
+
+### Manual Install
+Install the required dependencies using pip:
+```sh
+pip install -r requirements.txt
 ```
-#config.ini
+
+Copy the configuration template to `config.ini` and edit it to suit your needs:
+```sh
+cp config.template config.ini
+```
+
+### Configuration Guide
+The following is documentation for the config.ini file
+
+If you have not done so, or want to 'factory reset', copy the [config.template](config.template) to `config.ini` and set the appropriate interface for your method (serial/ble/tcp). While BLE and TCP will work, they are not as reliable as serial connections. There is a watchdog to reconnect TCP if possible. To get the BLE MAC address, use:
+```sh
+meshtastic --ble-scan
+```
+
+**Note**: The code has been tested with a single BLE device and is written to support only one BLE port.
+
+```ini
+# config.ini
 # type can be serial, tcp, or ble.
 # port is the serial port to use; commented out will try to auto-detect
-# hostname is the IP address of the device to connect to for TCP type
-# mac is the MAC address of the device to connect to for ble type
+# hostname is the IP/DNS and port for tcp type default is host:4403
+# mac is the MAC address of the device to connect to for BLE type
 
 [interface]
 type = serial
@@ -95,29 +238,50 @@ type = serial
 # hostname = 192.168.0.1
 # mac = 00:11:22:33:44:55
 
-# Additional interface for dual radio support See config.template for more.
+# Additional interface for dual radio support. See config.template for more.
 [interface2]
 enabled = False
 ```
-The following pair of settings determine how to respond: The default action is to not spam the default channel. Setting'respond_by_DM_only'` will force all messages to be sent to DM, which may not be wanted. Setting the value to False will allow responses in the channel for all to see.
 
-Setting the default channel is the channel that won't be spammed by the bot. It's the public default channel 0 on the new Meshtastic firmware. Anti-Spam is hard-coded into the responder to prevent abuse of the public channel.
-```
+### General Settings
+The following settings determine how the bot responds. By default, the bot will not spam the default channel. Setting `respond_by_dm_only` to `True` will force all messages to be sent via DM, which may not be desired. Setting it to [`False`] will allow responses in the channel for all to see. If you have no default channel you can set this value to `-1` or any unused channel index. You can also have the bot ignore the defaultChannel for any commands, but still observe the channel.
+
+```ini
 [general]
 respond_by_dm_only = True
 defaultChannel = 0
+ignoreDefaultChannel = False # ignoreDefaultChannel, the bot will ignore the default channel set above
+ignoreChannels = # ignoreChannels is a comma separated list of channels to ignore, e.g. 4,5
+cmdBang = False # require ! to be the first character in a command
+explicitCmd = True # require explicit command, the message will only be processed if it starts with a command word disable to get more activity
 ```
-The weather forecasting defaults to NOAA but for outside the USA you can set UseMeteoWxAPI `True` to use a world weather API. The lat and lon are for defaults when a node has no location data to use.
-```
+
+### 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, as well as the default for all NOAA, repeater lookup. It is also the center of radius for Sentry.
+
+```ini
 [location]
 enabled = True
 lat = 48.50
 lon = -123.0
+# To fuzz the location of the above
+fuzzConfigLocation = True
+# Fuzz all values in all data
+fuzzItAll = False
+
 UseMeteoWxAPI = True
+
+coastalEnabled = False # NOAA Coastal Data Enable NOAA Coastal Waters Forecasts and Tide
+# Find the correct coastal weather directory at https://tgftp.nws.noaa.gov/data/forecasts/marine/coastal/
+# this map can help https://www.weather.gov/marine select location and then look at the 'Forecast-by-Zone Map'
+myCoastalZone = https://tgftp.nws.noaa.gov/data/forecasts/marine/coastal/pz/pzz135.txt # myCoastalZone is the .txt file with the forecast data
+coastalForecastDays = 3 # number of data points to return, default is 3
 ```
 
-Modules can be disabled or enabled.
-```
+### Module Settings
+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]
 enabled = False
 
@@ -125,137 +289,350 @@ enabled = False
 DadJokes = False
 StoreForward = False
 ```
-History command is like a linix terminal, shows the last commands the user ran and the `lheard` reflects last users on the bot.
-```
-# history command 
-enableCmdHistory = True
-# command history ignore list ex: 2813308004,4258675309
-lheardCmdIgnoreNodes =
-```
-Sentry Bot detects anyone coming close to the bot-node
-```
-# detect anyone close to the bot
-SentryEnabled = True
-# radius in meters to detect someone close to the bot
-SentryRadius = 100
-# holdoff time multiplied by seconds(20) of the watchdog
-SentryChannel = 9
-# channel to send a message to when the watchdog is triggered
-SentryHoldoff = 2
-# list of ignored nodes numbers ex: 2813308004,4258675309
-sentryIgnoreList = 
-```
-The BBS has admin and block lists; see the [config.template](config.template)
 
-A repeater function for two different nodes and cross-posting messages. The'repeater_channels` is a list of repeater channel(s) that will be consumed and rebroadcast on the same number channel on the other device, node, or interface. Each node should have matching channel numbers. The channel names and PSK do not need to be the same on the nodes. With great power comes great responsibility; danger could lurk in the use of this feature! If you have the two nodes in the same radio configuration, you could create a feedback loop!!!
+### History 
+The history command shows the last commands the user ran, and [`lheard`] reflects the last users on the bot.
 
+```ini
+enableCmdHistory = True # history command enabler
+lheardCmdIgnoreNodes = # command history ignore list ex: 2813308004,4258675309
 ```
-# repeater module
-[repeater]
+
+### Sentry Settings
+
+Sentry Bot detects anyone coming close to the bot-node. uses the Location Lat/Lon value.
+
+```ini
+SentryEnabled = True # detect anyone close to the bot
+emailSentryAlerts = True # if SMTP enabled send alert to sysop email list
+SentryRadius = 100 # radius in meters to detect someone close to the bot
+SentryChannel = 9 # holdoff time multiplied by seconds(20) of the watchdog
+SentryHoldoff = 2 # channel to send a message to when the watchdog is triggered
+sentryIgnoreList = # list of ignored nodes numbers ex: 2813308004,4258675309
+highFlyingAlert = True # HighFlying Node alert
+highFlyingAlertAltitude = 2000 # Altitude in meters to trigger the alert
+highflyOpenskynetwork = True # check with OpenSkyNetwork if highfly detected for aircraft
+```
+
+### E-Mail / SMS Settings
+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]
+# enable or disable the SMTP module, minimum required for outbound notifications
+enableSMTP = True # enable or disable the IMAP module for inbound email, not implemented yet
+enableImap = False # list of Sysop Emails separate with commas, used only in emergency responder currently
+sysopEmails =
+# See config.template for all the SMTP settings
+SMTP_SERVER = smtp.gmail.com
+SMTP_AUTH = True
+EMAIL_SUBJECT = Meshtastic✉️
+```
+
+### Emergency Response Handler
+Traps the following ("emergency", "911", "112", "999", "police", "fire", "ambulance", "rescue") keywords. Responds to the user, and calls attention to the text message in logs and via another network or channel.
+
+```ini
+[emergencyHandler]
+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 and NINA
+This uses USA: SAME, FIPS, to locate the alerts in the feed. By default ignoring Test messages.
+
+```ini
+eAlertBroadcastEnabled = False # Goverment IPAWS/CAP Alert Broadcast
+eAlertBroadcastCh = 2,3 # Goverment Emergency IPAWS/CAP Alert Broadcast Channels
+ignoreFEMAenable = True # Ignore any headline that includes followig word list
+ignoreFEMAwords = test,exercise
+# comma separated list of FIPS codes to trigger local alert. find your FIPS codes at https://en.wikipedia.org/wiki/Federal_Information_Processing_Standard_state_code
+myFIPSList = 57,58,53
+# find your SAME https://www.weather.gov/nwr/counties comma separated list of SAME code to further refine local alert.
+mySAMEList = 053029,053073
+
+# To use other country services enable only a single optional serivce
+enableDEalerts = False # Use DE Alert Broadcast Data see template for filters
+myRegionalKeysDE = 110000000000,120510000000
+```
+
+#### NOAA EAS
+ This uses the defined lat-long of the bot for collecting of data from the API. see [File-Monitoring](#File-Monitoring) for ideas to collect EAS alerts from a RTL-SDR.
+
+```ini
+
+wxAlertBroadcastEnabled = True # EAS Alert Broadcast 
+wxAlertBroadcastCh = 2,4 # EAS Alert Broadcast Channels
+ignoreEASenable = True # Ignore any headline that includes followig word list
+ignoreEASwords = test,advisory
+```
+
+#### USGS River flow data and Volcano alerts
+Using the USGS water data page locate a water flow device, for example Columbia River at Vancouver, WA - USGS-14144700
+
+Volcano Alerts use lat/long to determine ~1000km radius
+```ini
+[location]
+# USGS Hydrology unique identifiers, LID or USGS ID https://waterdata.usgs.gov
+riverList = 14144700 # example Mouth of Columbia River
+
+# USGS Volcano alerts Enable USGS Volcano Alert Broadcast
+volcanoAlertBroadcastEnabled = False
+volcanoAlertBroadcastCh = 2
+```
+
+### Repeater Settings
+A repeater function for two different nodes and cross-posting messages. The `repeater_channels` is a list of repeater channels that will be consumed and rebroadcast on the same number channel on the other device, node, or interface. Each node should have matching channel numbers. The channel names and PSK do not need to be the same on the nodes. Use this feature responsibly to avoid creating a feedback loop.
+
+```ini
+[repeater] # repeater module
 enabled = True
 repeater_channels = [2, 3]
 ```
-A module allowing a Hamlib compatible radio to connect to the bot, when functioning it will message the channel configured with a message of in use. **Requires hamlib/rigctld to be running as a service.**
 
+### Ollama (LLM/AI) Settings
+For Ollama to work, the command line `ollama run 'model'` needs to work properly. Ensure you have enough RAM and your GPU is working as expected. The default model for this project is set to `gemma3:270m`. Ollama can be remote [Ollama Server](https://github.com/ollama/ollama/blob/main/docs/faq.md#how-do-i-configure-ollama-server) works on a pi58GB with 40 second or less response time.
+
+```ini
+# Enable ollama LLM see more at https://ollama.com
+ollama = True # Ollama model to use (defaults to gemma2:2b)
+ollamaModel = gemma3:latest # Ollama model to use (defaults to gemma3:270m)
+ollamaHostName = http://localhost:11434 # server instance to use (defaults to local machine install)
 ```
+
+Also see `llm.py` for changing the defaults of:
+
+```ini
+# LLM System Variables
+rawQuery = True # if True, the input is sent raw to the LLM if False, it is processed by the meshBotAI template
+
+# Used in the meshBotAI template (legacy)
+llmEnableHistory = True # enable history for the LLM model to use in responses adds to compute time
+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. 
+
+### Wikipedia Search Settings
+The Wikipedia search module can use either the online Wikipedia API or a local Kiwix server for offline wiki access. Kiwix is especially useful for mesh networks operating in remote or offline environments.
+
+```ini
+# Enable or disable the wikipedia search module
+wikipedia = True
+
+# Use local Kiwix server instead of online Wikipedia
+# Set to False to use online Wikipedia (default)
+useKiwixServer = False
+
+# Kiwix server URL (only used if useKiwixServer is True)
+kiwixURL = http://127.0.0.1:8080
+
+# Kiwix library name (e.g., wikipedia_en_100_nopic_2024-06)
+# Find available libraries at https://library.kiwix.org/
+kiwixLibraryName = wikipedia_en_100_nopic_2024-06
+```
+
+To set up a local Kiwix server:
+1. Install Kiwix tools: https://kiwix.org/en/ `sudo apt install kiwix-tools -y`
+2. Download a Wikipedia ZIM file to `data/`: https://library.kiwix.org/ `wget https://download.kiwix.org/zim/wikipedia/wikipedia_en_100_nopic_2025-09.zim`
+3. Run the server: `kiwix-serve --port 8080 wikipedia_en_100_nopic_2025-09.zim`
+4. Set `useKiwixServer = True` in your config.ini
+
+The bot will automatically extract and truncate content to fit Meshtastic's message size limits (~500 characters).
+
+### 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.**
+
+```ini
 [radioMon]
-enabled = False
+enabled = True
 rigControlServerAddress = localhost:4532
-# channel to broadcast to can be 2,3
-sigWatchBroadcastCh = 2
-# minimum SNR as reported by radio via hamlib
-signalDetectionThreshold = -10
-# hold time for high SNR
-signalHoldTime = 10
-# the following are combined to reset the monitor
-signalCooldown = 5
+sigWatchBroadcastCh = 2 # channel to broadcast to can be 2,3
+signalDetectionThreshold = -10 # minimum SNR as reported by radio via hamlib
+signalHoldTime = 10 # hold time for high SNR
+signalCooldown = 5 # the following are combined to reset the monitor
 signalCycleLimit = 5
 ```
-Ollama Settings, for Ollama to work the command line `ollama run 'model'` needs to work properly. Check that you have enough RAM and your GPU are working as expected. The default model for this project, is set to `gemma2:2b` (run `ollama pull gemma2:2b` on command line, to download and setup) 
- - From the command terminal of your system with mesh-bot, download the default model for mesh-bot which is currently `ollama pull gemma2:2b`
 
-Enable History, set via code readme Ollama Config in [Settings](https://github.com/SpudGunMan/meshing-around?tab=readme-ov-file#configurations) and [llm.py](https://github.com/SpudGunMan/meshing-around/blob/eb3bbdd3c5e0f16fe3c465bea30c781bd132d2d3/modules/llm.py#L12)
+### File Monitoring
+Some dev notes for ideas of use
 
-Tested models are `llama3.1, gemma2 (and variants), phi3.5, mistrial` other models may not handle the template as well.
-
-```
-# Enable ollama LLM see more at https://ollama.com
-ollama = True
-# Ollama model to use (defaults to gemma2:2b)
-ollamaModel = gemma2
-#ollamaModel = llama3.1
+```ini
+[fileMon]
+filemon_enabled = True
+file_path = alert.txt # text file to monitor for changes
+broadcastCh = 2 # channel to send the message to can be 2,3 multiple channels comma separated
+enable_read_news = False # news  command will return the contents of a text file
+news_file_path = news.txt
+news_random_line = False # only return a single random line from the news file
+enable_runShellCmd = False # enable the use of exernal shell commands, this enables some data in `sysinfo`
+# if runShellCmd and you think it is safe to allow the x: command to run
+# direct shell command handler the x: command in DMs user must be in bbs_admin_list
+allowXcmd = True
 ```
 
-also see llm.py for changing the defaults of
+#### Offline EAS
+
+To Monitor EAS with no internet connection see the following notes
+- [samedec](https://crates.io/crates/samedec) rust decoder much like multimon-ng
+  - [sameold](https://crates.io/crates/sameold) rust SAME message translator much like EAS2Text and dsame3
+
+no examples yet for these tools
+
+- [EAS2Text](https://github.com/A-c0rN/EAS2Text)
+  - depends on [multimon-ng](https://github.com/EliasOenal/multimon-ng), [direwolf](https://github.com/wb2osz/direwolf), [samedec](https://crates.io/crates/samedec) rust decoder much like multimon-ng
+- [dsame3](https://github.com/jamieden/dsame3)
+  - has a sample .ogg file for testing alerts
+
+The following example shell command can pipe the data using [etc/eas_alert_parser.py](etc/eas_alert_parser.py) to alert.txt
+```bash
+sox -t ogg WXR-RWT.ogg -esigned-integer -b16 -r 22050 -t raw - | multimon-ng -a EAS -v 1 -t raw - | python eas_alert_parser.py
 ```
-# LLM System Variables
-llmEnableHistory = False # enable history for the LLM model to use in responses adds to compute time
-llmContext_fromGoogle = True # enable context from google search results adds to compute time but really helps with responses accuracy
-googleSearchResults = 3 # number of google search results to include in the context more results = more compute time
-llm_history_limit = 6 # limit the history to 3 messages (come in pairs) more results = more compute time
+The following example shell command will pipe rtl_sdr to alert.txt
+```bash
+rtl_fm -f 162425000 -s 22050 | multimon-ng -t raw -a EAS /dev/stdin | python eas_alert_parser.py
 ```
 
-The Scheduler is enabled in the [settings.py](modules/settings.py) by setting `scheduler_enabled = True` the actions and settings are via code only at this time. see [mesh_bot.py](mesh_bot.py) around line [425](https://github.com/SpudGunMan/meshing-around/blob/22983133ee4db3df34f66699f565e506de296197/mesh_bot.py#L425-L435) to edit schedule its most flexible to edit raw code right now.  See https://schedule.readthedocs.io/en/stable/ for more.
+#### Newspaper on mesh
+Maintain multiple news sources. Each source should be a file named `{source}_news.txt` in the `data/` directory (for example, `data/mesh_news.txt`).
+- To read the default news, use the `readnews` command (reads from `data/news.txt`.
+- To read a specific source, use `readnews abc` to read from `data/abc_news.txt`.
 
+This allows you to organize and access different news feeds or categories easily.  
+External scripts can update these files as needed, and the bot will serve the latest content on request.
+
+### 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
+training = True # Training mode will not send the hello message to new nodes, use this to build up database
 ```
-# Send WX every Morning at 08:00 using handle_wxc function to channel 2 on device 1
-#schedule.every().day.at("08:00").do(lambda: send_message(handle_wxc(0, 1, 'wx'), 2, 0, 1))
 
-# Send a Net Starting Now Message Every Wednesday at 19:00 using send_message function to channel 2 on device 1
-#schedule.every().wednesday.at("19:00").do(lambda: send_message("Net Starting Now", 2, 0, 1))
+### Scheduler
+In the config.ini enable the module
+```ini
+[scheduler]
+enabled = False # enable or disable the scheduler module
+interface = 1 # channel to send the message to
+channel = 2
+message = "MeshBot says Hello! DM for more info."
+value = # value can be min,hour,day,mon,tue,wed,thu,fri,sat,sun
+interval =  # interval to use when time is not set (e.g. every 2 days)
+time = # time of day in 24:00 hour format when value is 'day' and interval is not set
 ```
-# requirements
-Python 3.10 minimally is needed, developed on latest release.
+ The basic brodcast message can be setup in condig.ini. For advanced, See the [modules/scheduler.py](modules/scheduler.py) to edit the schedule. See [schedule documentation](https://schedule.readthedocs.io/en/stable/) for more. Recomend to backup changes so they dont get lost.
 
-The following can also be installed with `pip install -r requirements.txt` or using the install.sh script for venv and automation
+```python
+#Send WX every Morning at 08:00 using handle_wxc function to channel 2 on device 1
+schedule.every().day.at("08:00").do(lambda: send_message(handle_wxc(0, 1, 'wx'), 2, 0, 1))
 
+#Send a Net Starting Now Message Every Wednesday at 19:00 using send_message function to channel 2 on device 1
+schedule.every().wednesday.at("19:00").do(lambda: send_message("Net Starting Now", 2, 0, 1))
 ```
+
+#### BBS Link
+The scheduler also handles the BBS Link Broadcast message, this would be an example of a mesh-admin channel on 8 being used to pass BBS post traffic between two bots as the initiator, one direction pull. The message just needs to have bbslink
+```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))
+```
+```ini
+bbslink_enabled = True
+bbslink_whitelist = # list of whitelisted nodes numbers ex: 2813308004,4258675309 empty list allows all
+```
+
+### Firmware 2.6 DM Key, and 2.7 CLIENT_BASE Favorite Nodes
+Firmware 2.6 introduced [PKC](https://meshtastic.org/blog/introducing-new-public-key-cryptography-in-v2_5/), enabling secure private messaging by adding necessary keys to each node. To fully utilize this feature, you should add favorite nodes—such as BBS admins—to your node’s favorites list to ensure their keys are retained. A helper script is provided to simplify this process:
+- Run the helper script from the main program directory: `python3 script/addFav.py`
+- By default, this script adds nodes from `bbs_admin_list` and `bbslink_whitelist`
+- If using a virtual environment, run: `launch.sh addfav`
+
+To configure favorite nodes, add their numbers to your config file:
+```conf
+[general]
+favoriteNodeList = # list of favorite nodes numbers ex: 2813308004,4258675309 used by script/addFav.py
+```
+
+### 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. Tested working fully Firmware:2.6.11 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~~ 
+
+# Recognition
+
+I used ideas and snippets from other responder bots and want to call them out!
+
+### Inspiration and Code Snippets
+- [MeshLink](https://github.com/Murturtle/MeshLink)
+- [Meshtastic Python Examples](https://github.com/pdxlocations/meshtastic-Python-Examples)
+- [Meshtastic Matrix Relay](https://github.com/geoffwhittington/meshtastic-matrix-relay)
+
+### Games Ported From
+- [Lemonade Stand](https://github.com/tigerpointe/Lemonade-Stand/)
+- [Drug Wars](https://github.com/Reconfirefly/drugwars)
+- [BlackJack](https://github.com/Himan10/BlackJack)
+- [Video Poker Terminal Game](https://github.com/devtronvarma/Video-Poker-Terminal-Game)
+- [Python Mastermind](https://github.com/pwdkramer/pythonMastermind/)
+- [Golf](https://github.com/danfriedman30/pythongame)
+- ARRL Question Pool Data from https://github.com/russolsen/ham_radio_question_pool
+
+### Special Thanks
+- **xdep**: For the reporting tools.
+- **Nestpebble**: For new ideas and enhancements.
+- **mrpatrick1991**: For Docker configurations.
+- **[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, Volcano Alerts 🌋
+- **Josh**: For more bashing on installer!
+- **dj505**: trying it on windows!
+- **mikecarper**: ideas, and testing. hamtest
+- **c.merphy360**: high altitude alerts
+- **Iris**: testing and finding 🐞
+- **FJRPiolt**: testing bugs out!!
+- **Cisien, bitflip, Woof, propstg, snydermesh, trs2982, F0X, mesb1, and Hailo1999**: For testing and feature ideas on Discord and GitHub.
+- **Meshtastic Discord Community**: For tossing out ideas and testing code.
+
+### Tools
+- **Node Backup Management**: [Node Slurper](https://github.com/SpudGunMan/node-slurper)
+
+### Requirements
+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
 pip install pubsub
 ```
-mesh-bot enhancements
 
-```
+Mesh-bot enhancements:
+
+```sh
 pip install pyephem
 pip install requests
 pip install geopy
 pip install maidenhead
 pip install beautifulsoup4
 pip install dadjokes
-pip install geopy
 pip install schedule
 pip install wikipedia
 ```
-The following is needed for open-meteo use
-```
-pip install openmeteo_requests
-pip install retry_requests
-pip install numpy
-```
-The following is for the Ollama LLM
-```
-pip install langchain
-pip install langchain-ollama
-pip install ollama
+
+For the Ollama LLM:
+
+```sh
 pip install googlesearch-python
 ```
 
-To enable emoji in the Debian console, install the fonts `sudo apt-get install fonts-noto-color-emoji`
+To enable emoji in the Debian console, install the fonts:
 
-# Recognition
-I used ideas and snippets from other responder bots and want to call them out!
-- https://github.com/Murturtle/MeshLink
-- https://github.com/pdxlocations/meshtastic-Python-Examples
-- https://github.com/geoffwhittington/meshtastic-matrix-relay
-
-Games Ported from..
-- https://github.com/tigerpointe/Lemonade-Stand/
-- https://github.com/Reconfirefly/drugwars
-- https://github.com/Himan10/BlackJack
-- https://github.com/devtronvarma/Video-Poker-Terminal-Game
-- https://github.com/pwdkramer/pythonMastermind/
-- https://github.com/danfriedman30/pythongame (Golf)
-
-GitHub user Nestpebble, for new ideas and enhancments, mrpatrick1991 For Docker configs, PiDiBi looking at test functions and other suggestions like wxc, CPU use, and alerting ideas
-Discord and Mesh user Cisien, bitflip, and github Hailo1999, for testing and feature ideas! Lots of individuals on the Meshtastic discord who have tossed out ideas and tested code!
+```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.

config.template

@@ -1,85 +1,158 @@
 #config.ini
 # type can be serial, tcp, or ble
 # port is the serial port to use, commented out will try to auto-detect
-# hostname is the IP address of the device to connect to for tcp type
+# hostname is the IP/DNS and port for tcp type default is host:4403
 # mac is the MAC address of the device to connect to for ble type
 
 [interface]
 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
-# defaultChannel is the meshtastic default public channel, e.g. LongFast
+# 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
 ignoreDefaultChannel = False
+# ignoreChannels is a comma separated list of channels to ignore, e.g. 4,5
+ignoreChannels = 
+# require ! to be the first character in a command
+cmdBang = False
+# require explicit command, the message will only be processed if it starts with a command word
+explicitCmd = True
+# list of favorite nodes numbers ex: 2813308004,4258675309 used by script/addFav.py
+favoriteNodeList = 
+
 # motd is reset to this value on boot
 motd = Thanks for using MeshBOT! Have a good day!
 welcome_message = MeshBot, here for you like a friend who is not. Try sending: ping @foo or, cmd
+
 # whoami
 whoami = True
+
 # enable or disable the Joke module
 DadJokes = True
+DadJokesEmoji = False
+
 # enable or disable the Solar module
 spaceWeather = True
+
+# enable or disable the RSS module, and truncate the story
+rssEnable = True
+rssFeedURL = http://www.hackaday.com/rss.xml,http://rss.slashdot.org/Slashdot/slashdotMain
+# RSS feed names must match the order of the URLs above, default is used if no match
+rssFeedNames = default,slashdot
+rssMaxItems = 3
+rssTruncate = 100
+
 # enable or disable the wikipedia search module
 wikipedia = True
+# Use local Kiwix server instead of online Wikipedia
+# Set to False to use online Wikipedia, or provide Kiwix server URL
+useKiwixServer = False
+# Kiwix server URL (e.g., http://127.0.0.1:8080)
+kiwixURL = http://127.0.0.1:8080
+# Kiwix library name (e.g., wikipedia_en_100_nopic_2025-09)
+kiwixLibraryName = wikipedia_en_100_nopic_2025-09
+
 # Enable ollama LLM see more at https://ollama.com
 ollama = False
-# Ollama model to use (defaults to gemma2:2b)
-# ollamaModel = llama3.1
+# Ollama model to use (defaults to gemma3:270m)
+# ollamaModel = gemma3:latest
+# server instance to use (defaults to local machine install)
+ollamaHostName = http://localhost:11434
+# Produce LLM replies to messages that aren't commands?
+# If False, the LLM only replies to the "ask:" and "askai" commands.
+llmReplyToNonCommands = True
+# if True, the input is sent raw to the LLM, if False uses legacy template query
+rawLLMQuery = True 
+
 # StoreForward Enabled and Limits
 StoreForward = True
 StoreLimit = 3
+reverseSF = False
+
 # history command 
 enableCmdHistory = True
 # command history ignore list ex: 2813308004,4258675309
 lheardCmdIgnoreNodes =
+
 # 24 hour clock
 zuluTime = False
 # wait time for URL requests
-urlTimeout = 10
+urlTimeout = 15
+
 # logging to file of the non Bot messages
 LogMessagesToFile = False
 # Logging of system messages to file
-SyslogToFile = False
+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
 
-[games]
-# enable or disable the games module(s)
-dopeWars = True
-lemonade = True
-blackjack = True
-videopoker = True
-mastermind = True
-golfsim = True
+#Do not retry enabling interface if it fails, just exit to let OS restart the bot
+dont_retry_disconnect = False
+
+#echo command, will echo back your message as the bot
+enableEcho = False
+# command will only echo 1:1 if sent on this channel, otherwise it will prepend @yourname
+echoChannel = 9
+
+[emergencyHandler]
+# enable or disable the emergency response handler
+enabled = False
+# channel to send a message to when the emergency handler is triggered
+alert_channel = 2
+alert_interface = 1
 
 [sentry]
 # detect anyone close to the bot
 SentryEnabled = True
+reqLocationEnabled = False
+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
+# device interface and channel to send the alert message to
+SentryInterface = 1
+SentryChannel = 2
 # holdoff time multiplied by seconds(20) of the watchdog
 SentryHoldoff = 9
 # list of ignored nodes numbers ex: 2813308004,4258675309
-sentryIgnoreList = 
+sentryIgnoreList =
+# Enable detection sensor alert, requires external sensor connected to node
+detectionSensorAlert = False
+
+# HighFlying Node alert
+highFlyingAlert = True
+# Altitude in meters to trigger the alert
+highFlyingAlertAltitude = 2000
+# check with OpenSkyNetwork if highfly detected for aircraft
+highflyOpenskynetwork = True
+# Channel to send Alert when the high flying node is detected
+highFlyingAlertInterface = 1
+# to disable OTA alert set to unused channel like 9
+highFlyingAlertChannel = 2
+# list of nodes numbers to ignore high flying alert ex: 2813308004,4258675309
+highFlyingIgnoreList =
 
 [bbs]
 enabled = True
@@ -87,21 +160,104 @@ enabled = True
 bbs_ban_list = 
 # list of admin nodes numbers ex: 2813308004,4258675309
 bbs_admin_list = 
+# enable bbs synchronization with other nodes
+bbslink_enabled = False
+# list of whitelisted nodes numbers ex: 2813308004,4258675309 empty list allows all
+bbslink_whitelist =
+# enable API script access (increases disk i/o)
+bbsAPI_enabled = False 
 
 # location module
 [location]
 enabled = True
 lat = 48.50
 lon = -123.0
-# 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
+fuzzConfigLocation = True
+fuzzItAll = False
+
 # Default to metric units rather than imperial
 useMetric = False
 
+# repeaterList lookup location (rbook / artsci / False)
+repeaterLookup = rbook
+
+# NOAA weather forecast days
+NOAAforecastDuration = 3
+# number of weather alerts to display
+NOAAalertCount = 2
+
+# use Open-Meteo API for weather data not NOAA useful for non US locations
+UseMeteoWxAPI = False
+
+# NOAA Coastal Data Enable NOAA Coastal Waters Forecasts and Tide
+coastalEnabled = False
+# Find the correct costal weather directory at https://tgftp.nws.noaa.gov/data/forecasts/marine/coastal/
+# pz = Puget Sound, ph = Honolulu HI, gm = Florida Keys, pk = Alaska
+# this map can help https://www.weather.gov/marine select location and then look at the 'Forecast-by-Zone Map'
+# myCoastalZone is the .txt file with the forecast data
+myCoastalZone = https://tgftp.nws.noaa.gov/data/forecasts/marine/coastal/pz/pzz135.txt
+# number of data points to return, default is 3
+coastalForecastDays = 3
+
+# NOAA USGS Hydrology river identifiers, LID or USGS ID https://waterdata.usgs.gov 12484500 Columbia River at The Dalles, OR
+# for multiple rivers use comma separated list e.g. 12484500,14105700
+riverList = 
+
+# NOAA EAS Alert Broadcast
+wxAlertBroadcastEnabled = False
+#  Enable Ignore any message that includes following word list
+ignoreEASenable = False
+ignoreEASwords = test,advisory
+# EAS Alert Broadcast Channels
+wxAlertBroadcastCh = 2
+# Add extra location to the weather alert
+enableExtraLocationWx = False
+
+# Goverment Alert Broadcast defaults to FEMA IPAWS
+eAlertBroadcastEnabled = False
+# comma separated list of FIPS codes to trigger local alert. find your FIPS codes at https://en.wikipedia.org/wiki/Federal_Information_Processing_Standard_state_code
+myFIPSList = 57,58,53
+# find your SAME https://www.weather.gov/nwr/counties comma separated list of SAME code to further refine local alert.
+mySAMEList = 053029,053073
+# Goverment Alert Broadcast Channels
+eAlertBroadcastCh = 2
+#  Enable Ignore, headline that includes following word list
+ignoreFEMAenable = True
+ignoreFEMAwords = test,exercise
+
+# USGS Volcano alerts Enable USGS Volcano Alert Broadcast
+volcanoAlertBroadcastEnabled = False
+volcanoAlertBroadcastCh = 2
+# Enable Ignore any message that includes following word list
+ignoreUSGSEnable = False
+ignoreUSGSWords = test,advisory
+
+# Use DE Alert Broadcast Data
+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
+reverse_in_out = False
+
+[qrz]
+# QRZ Hello to new nodes with message
+enabled = False
+qrz_db = data/qrz.db
+qrz_hello_string = "MeshBot says Hello! DM for more info."
+# Training mode will not send the hello message to new nodes
+training = True
+
 # repeater module
 [repeater]
 enabled = False
@@ -109,13 +265,32 @@ enabled = False
 # and rebroadcasted on the same channel on the other device/node/interface
 # with great power comes great responsibility, danger could be lurking in use of this feature
 # if you have the two nodes on the same radio configurations, you could create a feedback loop
-repeater_channels = 
+repeater_channels =
+
+[scheduler]
+# enable or disable the scheduler module
+enabled = False
+# interface to send the message to
+interface = 1
+# channel to send the message to
+channel = 2
+message = "MeshBot says Hello! DM for more info."
+# enable overides the above and uses the motd as the message
+schedulerMotd = False
+# value can be min,hour,day,mon,tue,wed,thu,fri,sat,sun. or custom for module/scheduler.py
+value =
+# interval to use when time is not set (e.g. every 2 days)
+interval = 
+# time of day in 24:00 hour format when value is 'day' and interval is not set
+time =
 
 [radioMon]
 # using Hamlib rig control will monitor and alert on channel use
 enabled = False
 rigControlServerAddress = localhost:4532
-# broadcast to all nodes on the channel can also be  = 2,3
+# device interface to send the message to
+sigWatchBroadcastInterface = 1
+# broadcast channel can also be a comma separated list of channels
 sigWatchBroadcastCh = 2
 # minimum SNR as reported by radio via hamlib
 signalDetectionThreshold = -10
@@ -124,11 +299,113 @@ signalHoldTime = 10
 # the following are combined to reset the monitor
 signalCooldown = 5
 signalCycleLimit = 5
+# enable VOX detection using default input
+voxDetectionEnabled = False
+# description to use in the alert message
+voxDescription = VOX
+useLocalVoxModel = False
+voxLanguage = en-us
+voxInputDevice = default
+voxOnTrapList = True
+voxTrapList = chirpy
+voxEnableCmd = True
+
+
+[fileMon]
+filemon_enabled = False
+# text file to monitor for changes
+file_path = alert.txt
+# channel to send the message to can be 2,3 multiple channels comma separated
+broadcastCh = 2
+
+# news  command will return the contents of a text file
+enable_read_news = False
+news_file_path = ../data/news.txt
+# only return a single random line from the news file
+news_random_line = False
+
+# enable the use of exernal shell commands, this enables some data in `sysinfo`
+enable_runShellCmd = False
+# if runShellCmd and you think it is safe to allow the x: command to run
+# direct shell command handler the x: command in DMs
+allowXcmd = False
+# Enable 2 factor authentication for x: commands
+2factor_enabled = True
+# time in seconds to wait for the correct 2FA answer
+2factor_timeout = 100
+
+[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
+game_hop_limit = 5
+disable_emojis = False
+# enable or disable the games module(s)
+dopeWars = True
+lemonade = True
+blackjack = True
+videopoker = True
+mastermind = True
+golfsim = True
+hangman = True
+hamtest = True
+tictactoe = True
+
+# enable or disable the quiz game module questions are in data/quiz.json
+quiz = False
+
+# enable or disable the survey game module questions are in data/survey/*_survey.json
+survey = False
+# this is the default survey to use when command givcen, from data/survey/example_survey.json
+defaultSurvey = example
+# Whether to record user ID in responses
+surveyRecordID=True
+# Whether to record location on start of survey
+surveyRecordLocation=True
 
 [messagingSettings]
-# delay in seconds for response to avoid message collision
-responseDelay = 0.7
-# delay in seconds for splits in messages to avoid message collision
-splitDelay = 0.0
-# message chunk size for sending at high success rate
+# delay in seconds for response to avoid message collision /throttling
+responseDelay = 2.2
+# delay in seconds for splits in messages to avoid message collision /throttling
+splitDelay = 2.5
+# message chunk size in charcters, chunkr allows exceeding by 3 characters
 MESSAGE_CHUNK_SIZE = 160
+# Request Acknowledgement of message OTA
+wantAck = False
+# Max limit buffer for radio testing in bytes
+maxBuffer = 200
+#Enable Extra logging of Hop count data
+enableHopLogs = False
+# Noisy Node Telemetry Logging and packet threshold
+noisyNodeLogging = False
+noisyTelemetryLimit = 5
+logMetaStats = True
+# Enable detailed packet logging all packets
+DEBUGpacket = False
+# metaPacket detailed logging, the filter negates the port ID
+debugMetadata = False
+metadataFilter = TELEMETRY_APP,POSITION_APP

data/README.md

@@ -0,0 +1 @@
+database admin tool is in [./etc/db_admin.py](../etc/db_admin.py)

data/mesh_news.txt

@@ -0,0 +1 @@
+Today in meshtastic you are looking at the coolest bot on the block.

data/news.txt

@@ -0,0 +1 @@
+no new news is good news!

data/quiz_questions.json

@@ -0,0 +1,16 @@
+[
+  {
+    "question": "Which RFband is commonly used by Meshtastic devices in US regions?",
+    "answers": ["2.4 GHz", "433 MHz", "900 MHz", "5.8 GHz"],
+    "correct": 2
+  },
+  {
+    "question": "Yogi the bear 🐻 likes what food?",
+    "answers": ["Picnic baskets", "Fish", "Burgers", "Hot dogs"],
+    "correct": 0
+  },
+  {
+    "question": "What is the password for the Meshtastic MQTT broker?",
+    "answer": "large4cats"
+  }
+]

data/surveys/example_survey.json

@@ -0,0 +1,15 @@
+[
+  {
+    "type": "multiple_choice",
+    "question": "How Did you hear about us?",
+    "options": ["Meshtastic", "Discord", "Friend", "Other"]
+  },
+  {
+    "type": "integer",
+    "question": "How many nodes do you own?"
+  },
+  {
+    "type": "text",
+    "question": "What feature would you like to see next?"
+  }
+]

data/surveys/snow_survey.json

@@ -0,0 +1,15 @@
+[
+  {
+    "type": "multiple_choice",
+    "question": "How often do you experience snowfall in your area?",
+    "options": ["Never", "Rarely", "Sometimes", "Often", "Every winter"]
+  },
+  {
+    "type": "integer",
+    "question": "What was the deepest snowfall (in inches) you've measured at your location?"
+  },
+  {
+    "type": "text",
+    "question": "Describe any challenges you face during heavy snowfall."
+  }
+]

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

etc/db_admin.py

@@ -4,65 +4,86 @@ import pickle # pip install pickle
 
 # load the bbs messages from the database file
 try:
-    with open('../bbsdb.pkl', 'rb') as f:
+    with open('../data/bbsdb.pkl', 'rb') as f:
         bbs_messages = pickle.load(f)
 except Exception as e:
     try:
-        with open('bbsdb.pkl', 'rb') as f:
+        with open('data/bbsdb.pkl', 'rb') as f:
             bbs_messages = pickle.load(f)
     except Exception as e:
-        bbs_messages = "System: bbsdb.pkl not found"
+        bbs_messages = "System: data/bbsdb.pkl not found"
 
 try:
-    with open('../bbsdm.pkl', 'rb') as f:
+    with open('../data/bbsdm.pkl', 'rb') as f:
         bbs_dm = pickle.load(f)
 except Exception as e:
     try:
-        with open('bbsdm.pkl', 'rb') as f:
+        with open('data/bbsdm.pkl', 'rb') as f:
             bbs_dm = pickle.load(f)
     except Exception as e:
-        bbs_dm = "System: bbsdm.pkl not found"
+        bbs_dm = "System: data/bbsdm.pkl not found"
+
+try:
+    with open('../data/email_db.pickle', 'rb') as f:
+        email_db = pickle.load(f)
+except Exception as e:
+    try:
+        with open('data/email_db.pickle', 'rb') as f:
+            email_db = pickle.load(f)
+    except Exception as e:
+        email_db = "System: data/email_db.pickle not found"
+
+try:
+    with open('../data/sms_db.pickle', 'rb') as f:
+        sms_db = pickle.load(f)
+except Exception as e:
+    try:
+        with open('data/sms_db.pickle', 'rb') as f:
+            sms_db = pickle.load(f)
+    except Exception as e:
+        sms_db = "System: data/sms_db.pickle not found"
+
 
 # Game HS tables
 try:
-    with open('../lemonade_hs.pkl', 'rb') as f:
+    with open('../data/lemonstand.pkl', 'rb') as f:
        lemon_score = pickle.load(f)
 except Exception as e:
     try:
-        with open('lemonade_hs.pkl', 'rb') as f:
+        with open('data/lemonstand.pkl', 'rb') as f:
             lemon_score = pickle.load(f)
     except Exception as e:
-        lemon_score = "System: lemonade_hs.pkl not found"
+        lemon_score = "System: data/lemonstand.pkl not found"
 
 try:
-    with open('../dopewar_hs.pkl', 'rb') as f:
+    with open('../data/dopewar_hs.pkl', 'rb') as f:
         dopewar_score = pickle.load(f)
 except Exception as e:
     try:
-        with open('dopewar_hs.pkl', 'rb') as f:
+        with open('data/dopewar_hs.pkl', 'rb') as f:
             dopewar_score = pickle.load(f)
     except Exception as e:
-        dopewar_score = "System: dopewar_hs.pkl not found"
+        dopewar_score = "System: data/dopewar_hs.pkl not found"
 
 try:
-    with open('../blackjack_hs.pkl', 'rb') as f:
+    with open('../data/blackjack_hs.pkl', 'rb') as f:
         blackjack_score = pickle.load(f)
 except Exception as e:
     try:
-        with open('blackjack_hs.pkl', 'rb') as f:
+        with open('data/blackjack_hs.pkl', 'rb') as f:
             blackjack_score = pickle.load(f)
     except Exception as e:
-        blackjack_score = "System: blackjack_hs.pkl not found"
+        blackjack_score = "System: data/blackjack_hs.pkl not found"
 
 try:
-    with open('../videopoker_hs.pkl', 'rb') as f:
+    with open('../data/videopoker_hs.pkl', 'rb') as f:
         videopoker_score = pickle.load(f)
 except Exception as e:
     try:
-        with open('videopoker_hs.pkl', 'rb') as f:
+        with open('data/videopoker_hs.pkl', 'rb') as f:
             videopoker_score = pickle.load(f)
     except Exception as e:
-        videopoker_score = "System: videopoker_hs.pkl not found"
+        videopoker_score = "System: data/videopoker_hs.pkl not found"
 
 try:
     with open('../mmind_hs.pkl', 'rb') as f:
@@ -75,14 +96,14 @@ except Exception as e:
         mmind_score = "System: mmind_hs.pkl not found"
 
 try:
-    with open('../golfsim_hs.pkl', 'rb') as f:
+    with open('../data/golfsim_hs.pkl', 'rb') as f:
         golfsim_score = pickle.load(f)
 except Exception as e:
     try:
-        with open('golfsim_hs.pkl', 'rb') as f:
+        with open('data/golfsim_hs.pkl', 'rb') as f:
             golfsim_score = pickle.load(f)
     except Exception as e:
-        golfsim_score = "System: golfsim_hs.pkl not found"
+        golfsim_score = "System: data/golfsim_hs.pkl not found"
 
 
 print ("\n Meshing-Around Database Admin Tool\n")
@@ -90,6 +111,10 @@ print ("System: bbs_messages")
 print (bbs_messages)
 print ("\nSystem: bbs_dm")
 print (bbs_dm)
+print ("\nSystem: email_db")
+print (email_db)
+print ("\nSystem: sms_db")
+print (sms_db)
 print (f"\n\nGame HS tables\n")
 print (f"lemon:{lemon_score}")
 print (f"dopewar:{dopewar_score}")

etc/eas_alert_parser.py

@@ -0,0 +1,49 @@
+# Super sloppy multimon-ng output cleaner for processing by EAS2Text
+# I maed dis, sorta, mostly just mashed code I found or that chatGPT hallucinated
+# by Mike O'Connell/skrrt, no licence or whatever just be chill yo
+# enhanced by sheer.cold
+
+import re
+from EAS2Text import EAS2Text
+
+buff=[] # store messages for writing
+seen=set()
+pattern = re.compile(r'ZCZC.*?NWS-')
+
+# alternate regex for parsing multimon-ng output
+# provided by https://github.com/A-c0rN
+#reg = r"^.*?(NNNN|ZCZC)(?:-([A-Za-z0-9]{3})-([A-Za-z0-9]{3})-((?:-?[0-9]{6})+)\+([0-9]{4})-([0-9]{7})-(.{8})-)?.*?$"
+#prog = re.compile(reg, re.MULTILINE)
+#groups = prog.match(sameData).groups()
+
+while True:
+  try:
+    # Handle piped input
+    inp=input().strip()
+  except EOFError:
+    break
+  # potentially take multiple lines in one buffered input
+  for line in inp.splitlines():
+    # only want EAS lines
+    if line.startswith("EAS:") or line.startswith("EAS (part):"):
+      content=line.split(":", maxsplit=1)[1].strip()
+      if content=="NNNN": # end of EAS message
+        # write if we have something
+        if buff:
+          print("writing")
+          with open("alert.txt","w") as fh:
+            fh.write('\n'.join(buff))
+          # prepare for new data
+          buff.clear()
+          seen.clear()
+      elif content in seen:
+        # don't need repeats
+        continue
+      else:
+        # check for national weather service
+        match=pattern.search(content)
+        if match:
+          seen.add(content)
+          msg=EAS2Text(content).EASText
+          print("got message", msg)
+          buff.append(msg)

etc/mesh_bot.tmp

@@ -1,5 +1,6 @@
 # /etc/systemd/system/mesh_bot.service
 # sudo systemctl daemon-reload
+# sudo systemctl enable mesh_bot.service
 # sudo systemctl start mesh_bot.service
 
 [Unit]

etc/mesh_bot_reporting.timer

@@ -0,0 +1,10 @@
+[Unit]
+Description=MeshingAround-ReportingTask
+
+[Timer]
+OnUnitActiveSec=1h
+OnbootSec=5min
+Unit=mesh_bot_reporting.service
+
+[Install]
+WantedBy=timers.target

etc/mesh_bot_reporting.tmp

@@ -0,0 +1,26 @@
+# /etc/systemd/system/mesh_bot_reporting.service
+# sudo systemctl daemon-reload
+# sudo systemctl enable mesh_bot_reporting.service
+# sudo systemctl start mesh_bot_reporting.service
+
+[Unit]
+Description=MeshingAround-Reporting
+After=network.target
+
+[Service]
+Type=oneshot
+User=pi
+Group=pi
+WorkingDirectory=/dir/
+ExecStart=python3 etc/report_generator5.py
+ExecStop=pkill -f report_generator5.py
+
+# Disable Python's buffering of STDOUT and STDERR, so that output from the
+# service shows up immediately in systemd's logs
+Environment=PYTHONUNBUFFERED=1
+
+Restart=on-failure
+Type=notify #try simple if any problems
+
+[Install]
+WantedBy=default.target

etc/mesh_bot_w3.tmp

@@ -0,0 +1,23 @@
+# /etc/systemd/system/mesh_bot_w3.service
+# sudo systemctl daemon-reload
+# sudo systemctl enable mesh_bot_w3.service
+# sudo systemctl start mesh_bot_w3.service
+
+[Unit]
+Description=MeshingAround-W3Server
+After=network.target
+
+[Service]
+Type=simple
+User=pi
+Group=pi
+WorkingDirectory=/dir/
+ExecStart=python3 modules/web.py
+ExecStop=pkill -f mesh_bot_w3.py
+
+# Disable Python's buffering of STDOUT and STDERR, so that output from the
+# service shows up immediately in systemd's logs
+Environment=PYTHONUNBUFFERED=1
+
+Restart=on-failure
+Type=notify #try simple if any problems

etc/meshview.ino

@@ -0,0 +1,224 @@
+// Example to receive and decode Meshtastic UDP packets
+// Make sure to install the meashtastic library and generate the .pb.h and .pb.c files from the Meshtastic .proto definitions
+// https://github.com/meshtastic/protobufs/tree/master/meshtastic
+
+// Example to receive and decode Meshtastic UDP packets
+
+#include <WiFi.h>
+#include <WiFiUdp.h>
+// #include <AESLib.h> // or another AES library
+
+#include "pb_decode.h"
+#include "meshtastic/mesh.pb.h"      // MeshPacket, Position, etc.
+#include "meshtastic/portnums.pb.h"  // Port numbers enum
+#include "meshtastic/telemetry.pb.h" // Telemetry message
+
+const char* ssid = "YOUR_WIFI_SSID";
+const char* password = "YOUR_WIFI_PASSWORD";
+
+const char* default_key = "1PG7OiApB1nwvP+rz05pAQ=="; // Your network key here
+uint8_t aes_key[16]; // Buffer for decoded key
+
+const char* MCAST_GRP = "224.0.0.69";
+const uint16_t MCAST_PORT = 4403;
+
+unsigned long udpPacketCount = 0;
+
+WiFiUDP udp;
+IPAddress multicastIP;
+
+void setup() {
+  Serial.begin(115200);
+  delay(1000);
+
+  Serial.println("Scanning for WiFi networks...");
+  int n = WiFi.scanNetworks();
+  if (n == 0) {
+    Serial.println("No networks found.");
+  } else {
+    Serial.print(n);
+    Serial.println(" networks found:");
+    for (int i = 0; i < n; ++i) {
+      Serial.print(i + 1);
+      Serial.print(": ");
+      Serial.print(WiFi.SSID(i));
+      Serial.print(" (RSSI ");
+      Serial.print(WiFi.RSSI(i));
+      Serial.print(")");
+      Serial.println((WiFi.encryptionType(i) == WIFI_AUTH_OPEN) ? " [OPEN]" : " [SECURED]");
+      delay(10);
+    }
+  }
+
+  Serial.println("Connecting to WiFi...");
+  WiFi.mode(WIFI_STA);
+  WiFi.begin(ssid, password);
+
+  unsigned long startAttemptTime = millis();
+  const unsigned long wifiTimeout = 20000;
+
+  while (WiFi.status() != WL_CONNECTED && millis() - startAttemptTime < wifiTimeout) {
+    delay(500);
+    Serial.print(".");
+  }
+
+  if (WiFi.status() == WL_CONNECTED) {
+    Serial.println("\nWiFi connected.");
+    Serial.print("IP address: ");
+    Serial.println(WiFi.localIP());
+
+    multicastIP.fromString(MCAST_GRP);
+    if (udp.beginMulticast(multicastIP, MCAST_PORT)) {
+      Serial.println("UDP multicast listener started.");
+    } else {
+      Serial.println("Failed to start UDP multicast listener.");
+    }
+  } else {
+    Serial.print("\nFailed to connect to WiFi. SSID: ");
+    Serial.println(ssid);
+    Serial.println("Check SSID, range, and password.");
+  }
+}
+
+void printHex(const uint8_t* buf, size_t len) {
+  for (size_t i = 0; i < len; i++) {
+    Serial.printf("%02X ", buf[i]);
+  }
+  Serial.println();
+}
+
+void printAscii(const uint8_t* buf, size_t len) {
+  for (size_t i = 0; i < len; i++) {
+    char c = static_cast<char>(buf[i]);
+    Serial.print(isprint(c) ? c : '.');
+  }
+  Serial.println();
+}
+
+void decodeKey() {
+  // Convert base64 key to raw bytes
+  // You may need to add a base64 decoding function/library
+  // Example: decode_base64(default_key, aes_key, sizeof(aes_key));
+}
+
+void decryptPayload(const uint8_t* encrypted, size_t len, uint8_t* decrypted) {
+  // Use AESLib or similar to decrypt
+  // Example: aes128_dec_single(decrypted, encrypted, aes_key);
+}
+
+void loop() {
+  int packetSize = udp.parsePacket();
+  if (!packetSize) {
+    delay(50);
+    return;
+  }
+
+  udpPacketCount++;
+  Serial.print("UDP packets seen: ");
+  Serial.println(udpPacketCount);
+
+  uint8_t buffer[512];
+  int len = udp.read(buffer, sizeof(buffer));
+  if (len <= 0) {
+    Serial.println("Failed to read UDP packet.");
+    delay(50);
+    return;
+  }
+
+  // Always show raw payload
+  Serial.print("Raw UDP payload (hex): ");
+  printHex(buffer, len);
+  Serial.print("Raw UDP payload (ASCII): ");
+  printAscii(buffer, len);
+
+  // Decode outer MeshPacket
+  meshtastic_MeshPacket pkt = meshtastic_MeshPacket_init_zero;
+  pb_istream_t stream = pb_istream_from_buffer(buffer, len);
+
+  if (!pb_decode(&stream, meshtastic_MeshPacket_fields, &pkt)) {
+    Serial.println("Failed to decode meshtastic_MeshPacket.");
+    delay(50);
+    return;
+  }
+
+  // Basic MeshPacket fields
+  Serial.print("id: "); Serial.println(pkt.id);
+  Serial.print("rx_time: "); Serial.println(pkt.rx_time);
+  Serial.print("rx_snr: "); Serial.println(pkt.rx_snr, 2);
+  Serial.print("rx_rssi: "); Serial.println(pkt.rx_rssi);
+  Serial.print("hop_limit: "); Serial.println(pkt.hop_limit);
+  Serial.print("priority: "); Serial.println(pkt.priority);
+  Serial.print("from: "); Serial.println(pkt.from);
+  Serial.print("to: "); Serial.println(pkt.to);
+  Serial.print("channel: "); Serial.println(pkt.channel);
+
+  // Only proceed if we have a decoded Data variant
+  if (pkt.which_payload_variant != meshtastic_MeshPacket_decoded_tag) {
+    Serial.println("Packet does not contain decoded Data (maybe encrypted or other variant).");
+    delay(50);
+    return;
+  }
+
+  const meshtastic_Data& data = pkt.decoded;
+  Serial.print("Portnum: "); Serial.println(data.portnum);
+  Serial.print("Payload size: "); Serial.println(data.payload.size);
+
+  if (data.payload.size == 0) {
+    Serial.println("No inner payload bytes.");
+    delay(50);
+    return;
+  }
+
+  // Decode by portnum
+  switch (data.portnum) {
+
+    case meshtastic_PortNum_TEXT_MESSAGE_APP: {
+      // Current schemas do not use a separate user.pb.h. Text payload is plain bytes.
+      Serial.print("Decoded text message: ");
+      printAscii(data.payload.bytes, data.payload.size);
+      break;
+    }
+
+    case meshtastic_PortNum_POSITION_APP: {
+      meshtastic_Position pos = meshtastic_Position_init_zero;
+      pb_istream_t ps = pb_istream_from_buffer(data.payload.bytes, data.payload.size);
+      if (pb_decode(&ps, meshtastic_Position_fields, &pos)) {
+        Serial.print("Position lat="); Serial.print(pos.latitude_i / 1e7, 7);
+        Serial.print(" lon="); Serial.print(pos.longitude_i / 1e7, 7);
+        Serial.print(" alt="); Serial.println(pos.altitude);
+      } else {
+        Serial.println("Failed to decode Position payload.");
+      }
+      break;
+    }
+
+    case meshtastic_PortNum_TELEMETRY_APP: {
+      meshtastic_Telemetry tel = meshtastic_Telemetry_init_zero;
+      pb_istream_t ts = pb_istream_from_buffer(data.payload.bytes, data.payload.size);
+      if (pb_decode(&ts, meshtastic_Telemetry_fields, &tel)) {
+        // Print a few common fields if present
+        if (tel.which_variant == meshtastic_Telemetry_device_metrics_tag) {
+          const meshtastic_DeviceMetrics& m = tel.variant.device_metrics;
+          Serial.print("Telemetry battery_level="); Serial.print(m.battery_level);
+          Serial.print(" voltage="); Serial.print(m.voltage);
+          Serial.print(" air_util_tx="); Serial.println(m.air_util_tx);
+        } else {
+          Serial.println("Telemetry decoded, different variant. Raw bytes:");
+          printHex(data.payload.bytes, data.payload.size);
+        }
+      } else {
+        Serial.println("Failed to decode Telemetry payload.");
+      }
+      break;
+    }
+
+    default: {
+      Serial.print("Unhandled portnum "); Serial.print((int)data.portnum);
+      Serial.println(", showing payload as hex:");
+      printHex(data.payload.bytes, data.payload.size);
+      break;
+    }
+  }
+
+  delay(50);
+}

etc/pong_bot.tmp

@@ -1,5 +1,6 @@
 # /etc/systemd/system/pong_bot.service
 # sudo systemctl daemon-reload
+# sudo systemctl enable pong_bot.service
 # sudo systemctl start pong_bot.service
 
 [Unit]

etc/send-environment-metrics.py

@@ -0,0 +1,53 @@
+# file name: send-environment-metrics.py
+# https://github.com/pdxlocations/Meshtastic-Python-Examples/blob/main/send-environment-metrics.py
+
+from meshtastic.protobuf import portnums_pb2, telemetry_pb2
+from meshtastic import BROADCAST_ADDR
+import time
+
+# For connection over serial
+# import meshtastic.serial_interface
+# interface = meshtastic.serial_interface.SerialInterface()
+
+# For connection over TCP
+import meshtastic.tcp_interface
+interface = meshtastic.tcp_interface.TCPInterface(hostname='127.0.0.1', noProto=False)
+
+# Create a telemetry data object
+telemetry_data = telemetry_pb2.Telemetry()
+telemetry_data.time = int(time.time())
+#telemetry_data.local_stats.upTime = 0
+telemetry_data.environment_metrics.temperature = 0
+# telemetry_data.environment_metrics.voltage = 0
+# telemetry_data.environment_metrics.current = 0
+# telemetry_data.environment_metrics.relative_humidity = 0
+# telemetry_data.environment_metrics.barometric_pressure = 0
+# telemetry_data.environment_metrics.gas_resistance = 0
+# telemetry_data.environment_metrics.iaq = 0
+# telemetry_data.environment_metrics.distance = 0
+# telemetry_data.environment_metrics.lux = 0
+# telemetry_data.environment_metrics.white_lux = 0
+# telemetry_data.environment_metrics.ir_lux = 0
+# telemetry_data.environment_metrics.uv_lux = 0
+# telemetry_data.environment_metrics.wind_direction = 0
+# telemetry_data.environment_metrics.wind_speed = 0
+# telemetry_data.environment_metrics.wind_gust = 0
+# telemetry_data.environment_metrics.wind_lull = 0
+# telemetry_data.environment_metrics.weight = 0
+
+# Read the uptime
+# with open('/proc/uptime', 'r') as uptime:
+#     telemetry_data.local_stats.upTime = int(float(uptime.readline().split()[0]))
+
+# Read the CPU temperature
+with open('/sys/class/thermal/thermal_zone0/temp', 'r') as cpu_temp:
+    telemetry_data.environment_metrics.temperature = int(cpu_temp.read()) / 1000
+
+interface.sendData(
+    telemetry_data,
+    destinationId=BROADCAST_ADDR,
+    portNum=portnums_pb2.PortNum.TELEMETRY_APP,
+    wantResponse=False,
+)
+
+interface.close()

etc/simulator.py

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # # Simulate meshing-around de K7MHI 2024
-from modules.log import * # err? Move .py out of etc/ and place it in the root of the project
+from modules.log import * # Import the logger; ### --> If you are reading this put the script in the project root <-- ###
 import time
 import random
 
@@ -9,6 +9,7 @@ projectName = "example_handler" # name of _handler function to match the functio
 randomNode = False # Set to True to use random node IDs
 
 # bot.py Simulated functions
+deviceID = 1 # represents the device/node number
 def get_NodeID():
     nodeList = [4258675309, 1212121212, 1234567890, 9876543210]
     if randomNode: 
@@ -16,22 +17,43 @@ def get_NodeID():
     else:
         nodeID = nodeList[0]
     return nodeID
+nodeID = get_NodeID() # assign a nodeID
 def get_name_from_number(nodeID, length='short', interface=1):
     # return random name for nodeID
     names = ["Max","Molly","Jake","Kelly"]
     return names[nodeID % len(names)]
+#simulate GPS locations for testing
+locations = [
+        (48.200909, -123.25719),
+        (48.330283,-123.260703),
+        (48.342735,-122.987911),
+        (48.205591,-122.998448)
+    ]
+lat, lon = random.choice(locations) # pick a random location
+location = f"{lat},{lon}"
 # # end Initialization of the tool
 
+
+
+
+
 # # Function to handle, or the project in test
+#from modules.llm import * # Import the LLM module
+# # Project handler function code here
+
+# example handler function canada()
+def example_handler(message, nodeID, deviceID):
+    if message != "":
+        # put code in test here
+        msg = f"Hello {get_name_from_number(nodeID)}, simulator ready for testing {projectName} project! on device {deviceID}"
+        msg += f" Your location is {location}"
+        msg += f" you said: {message}"
+
+
+        return msg
+
 
 
-def example_handler(nodeID, message):
-    readableTime = time.ctime(time.time())
-    msg = "Hello World! "
-    msg += f" You are Node ID: {nodeID} "
-    msg += f" Its: {readableTime} "
-    msg += f" You just sent: {message}"
-    return msg
 
 
 # # end of function test code
@@ -42,7 +64,7 @@ if __name__ == '__main__': # represents the bot's main loop
     nodeInt = 1 # represents the device/node number
     logger.info(f"System: Meshing-Around Simulator Starting for {projectName}")
     nodeID = get_NodeID() # assign a nodeID
-    projectResponse = globals()[projectName](0, 0, " ") # Call the project handler under test
+    projectResponse = globals()[projectName]("", nodeID, deviceID) # call the handler function once to start
     while True: # represents the onReceive() loop in the bot.py
         projectResponse = ""
         responseLength = 0
@@ -51,7 +73,7 @@ if __name__ == '__main__': # represents the bot's main loop
         packet = input(f"CLIENT {nodeID} INPUT: " ) # Emulate the client input
         if packet != "":
             #try:
-            projectResponse = globals()[projectName](nodeID, deviceID=nodeInt, message=packet) # Call the project handler under test
+            projectResponse = globals()[projectName](message = packet, nodeID = nodeID, deviceID = deviceID) # call the handler function
             # except Exception as e:
             #     logger.error(f"System: Handler: {e}")
             #     projectResponse = "Error in handler"

etc/www/localscripts/css2

@@ -0,0 +1,252 @@
+/* cyrillic-ext */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 300;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa2JL7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+0460-052F, U+1C80-1C88, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;
+}
+/* cyrillic */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 300;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa0ZL7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
+}
+/* greek-ext */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 300;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa2ZL7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+1F00-1FFF;
+}
+/* greek */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 300;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa1pL7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+0370-0377, U+037A-037F, U+0384-038A, U+038C, U+038E-03A1, U+03A3-03FF;
+}
+/* vietnamese */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 300;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa2pL7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
+}
+/* latin-ext */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 300;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa25L7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+0100-02AF, U+0304, U+0308, U+0329, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
+}
+/* latin */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 300;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa1ZL7W0Q5nw.woff2) format('woff2');
+  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+/* cyrillic-ext */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa2JL7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+0460-052F, U+1C80-1C88, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;
+}
+/* cyrillic */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa0ZL7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
+}
+/* greek-ext */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa2ZL7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+1F00-1FFF;
+}
+/* greek */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa1pL7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+0370-0377, U+037A-037F, U+0384-038A, U+038C, U+038E-03A1, U+03A3-03FF;
+}
+/* vietnamese */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa2pL7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
+}
+/* latin-ext */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa25L7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+0100-02AF, U+0304, U+0308, U+0329, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
+}
+/* latin */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 400;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa1ZL7W0Q5nw.woff2) format('woff2');
+  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+/* cyrillic-ext */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 600;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa2JL7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+0460-052F, U+1C80-1C88, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;
+}
+/* cyrillic */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 600;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa0ZL7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
+}
+/* greek-ext */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 600;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa2ZL7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+1F00-1FFF;
+}
+/* greek */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 600;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa1pL7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+0370-0377, U+037A-037F, U+0384-038A, U+038C, U+038E-03A1, U+03A3-03FF;
+}
+/* vietnamese */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 600;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa2pL7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
+}
+/* latin-ext */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 600;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa25L7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+0100-02AF, U+0304, U+0308, U+0329, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
+}
+/* latin */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 600;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa1ZL7W0Q5nw.woff2) format('woff2');
+  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}
+/* cyrillic-ext */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 700;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa2JL7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+0460-052F, U+1C80-1C88, U+20B4, U+2DE0-2DFF, U+A640-A69F, U+FE2E-FE2F;
+}
+/* cyrillic */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 700;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa0ZL7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+0301, U+0400-045F, U+0490-0491, U+04B0-04B1, U+2116;
+}
+/* greek-ext */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 700;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa2ZL7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+1F00-1FFF;
+}
+/* greek */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 700;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa1pL7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+0370-0377, U+037A-037F, U+0384-038A, U+038C, U+038E-03A1, U+03A3-03FF;
+}
+/* vietnamese */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 700;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa2pL7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+0102-0103, U+0110-0111, U+0128-0129, U+0168-0169, U+01A0-01A1, U+01AF-01B0, U+0300-0301, U+0303-0304, U+0308-0309, U+0323, U+0329, U+1EA0-1EF9, U+20AB;
+}
+/* latin-ext */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 700;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa25L7W0Q5n-wU.woff2) format('woff2');
+  unicode-range: U+0100-02AF, U+0304, U+0308, U+0329, U+1E00-1E9F, U+1EF2-1EFF, U+2020, U+20A0-20AB, U+20AD-20C0, U+2113, U+2C60-2C7F, U+A720-A7FF;
+}
+/* latin */
+@font-face {
+  font-family: 'Inter';
+  font-style: normal;
+  font-weight: 700;
+  font-display: swap;
+  src: url(https://fonts.gstatic.com/s/inter/v18/UcC73FwrK3iLTeHuS_nVMrMxCp50SjIa1ZL7W0Q5nw.woff2) format('woff2');
+  unicode-range: U+0000-00FF, U+0131, U+0152-0153, U+02BB-02BC, U+02C6, U+02DA, U+02DC, U+0304, U+0308, U+0329, U+2000-206F, U+2074, U+20AC, U+2122, U+2191, U+2193, U+2212, U+2215, U+FEFF, U+FFFD;
+}

etc/www/localscripts/leaflet.css

@@ -0,0 +1,640 @@
+/* required styles */
+
+.leaflet-pane,
+.leaflet-tile,
+.leaflet-marker-icon,
+.leaflet-marker-shadow,
+.leaflet-tile-container,
+.leaflet-pane > svg,
+.leaflet-pane > canvas,
+.leaflet-zoom-box,
+.leaflet-image-layer,
+.leaflet-layer {
+	position: absolute;
+	left: 0;
+	top: 0;
+	}
+.leaflet-container {
+	overflow: hidden;
+	}
+.leaflet-tile,
+.leaflet-marker-icon,
+.leaflet-marker-shadow {
+	-webkit-user-select: none;
+	   -moz-user-select: none;
+	        user-select: none;
+	  -webkit-user-drag: none;
+	}
+/* Prevents IE11 from highlighting tiles in blue */
+.leaflet-tile::selection {
+	background: transparent;
+}
+/* Safari renders non-retina tile on retina better with this, but Chrome is worse */
+.leaflet-safari .leaflet-tile {
+	image-rendering: -webkit-optimize-contrast;
+	}
+/* hack that prevents hw layers "stretching" when loading new tiles */
+.leaflet-safari .leaflet-tile-container {
+	width: 1600px;
+	height: 1600px;
+	-webkit-transform-origin: 0 0;
+	}
+.leaflet-marker-icon,
+.leaflet-marker-shadow {
+	display: block;
+	}
+/* .leaflet-container svg: reset svg max-width decleration shipped in Joomla! (joomla.org) 3.x */
+/* .leaflet-container img: map is broken in FF if you have max-width: 100% on tiles */
+.leaflet-container .leaflet-overlay-pane svg,
+.leaflet-container .leaflet-marker-pane img,
+.leaflet-container .leaflet-shadow-pane img,
+.leaflet-container .leaflet-tile-pane img,
+.leaflet-container img.leaflet-image-layer,
+.leaflet-container .leaflet-tile {
+	max-width: none !important;
+	max-height: none !important;
+	}
+
+.leaflet-container.leaflet-touch-zoom {
+	-ms-touch-action: pan-x pan-y;
+	touch-action: pan-x pan-y;
+	}
+.leaflet-container.leaflet-touch-drag {
+	-ms-touch-action: pinch-zoom;
+	/* Fallback for FF which doesn't support pinch-zoom */
+	touch-action: none;
+	touch-action: pinch-zoom;
+}
+.leaflet-container.leaflet-touch-drag.leaflet-touch-zoom {
+	-ms-touch-action: none;
+	touch-action: none;
+}
+.leaflet-container {
+	-webkit-tap-highlight-color: transparent;
+}
+.leaflet-container a {
+	-webkit-tap-highlight-color: rgba(51, 181, 229, 0.4);
+}
+.leaflet-tile {
+	filter: inherit;
+	visibility: hidden;
+	}
+.leaflet-tile-loaded {
+	visibility: inherit;
+	}
+.leaflet-zoom-box {
+	width: 0;
+	height: 0;
+	-moz-box-sizing: border-box;
+	     box-sizing: border-box;
+	z-index: 800;
+	}
+/* workaround for https://bugzilla.mozilla.org/show_bug.cgi?id=888319 */
+.leaflet-overlay-pane svg {
+	-moz-user-select: none;
+	}
+
+.leaflet-pane         { z-index: 400; }
+
+.leaflet-tile-pane    { z-index: 200; }
+.leaflet-overlay-pane { z-index: 400; }
+.leaflet-shadow-pane  { z-index: 500; }
+.leaflet-marker-pane  { z-index: 600; }
+.leaflet-tooltip-pane   { z-index: 650; }
+.leaflet-popup-pane   { z-index: 700; }
+
+.leaflet-map-pane canvas { z-index: 100; }
+.leaflet-map-pane svg    { z-index: 200; }
+
+.leaflet-vml-shape {
+	width: 1px;
+	height: 1px;
+	}
+.lvml {
+	behavior: url(#default#VML);
+	display: inline-block;
+	position: absolute;
+	}
+
+
+/* control positioning */
+
+.leaflet-control {
+	position: relative;
+	z-index: 800;
+	pointer-events: visiblePainted; /* IE 9-10 doesn't have auto */
+	pointer-events: auto;
+	}
+.leaflet-top,
+.leaflet-bottom {
+	position: absolute;
+	z-index: 1000;
+	pointer-events: none;
+	}
+.leaflet-top {
+	top: 0;
+	}
+.leaflet-right {
+	right: 0;
+	}
+.leaflet-bottom {
+	bottom: 0;
+	}
+.leaflet-left {
+	left: 0;
+	}
+.leaflet-control {
+	float: left;
+	clear: both;
+	}
+.leaflet-right .leaflet-control {
+	float: right;
+	}
+.leaflet-top .leaflet-control {
+	margin-top: 10px;
+	}
+.leaflet-bottom .leaflet-control {
+	margin-bottom: 10px;
+	}
+.leaflet-left .leaflet-control {
+	margin-left: 10px;
+	}
+.leaflet-right .leaflet-control {
+	margin-right: 10px;
+	}
+
+
+/* zoom and fade animations */
+
+.leaflet-fade-anim .leaflet-tile {
+	will-change: opacity;
+	}
+.leaflet-fade-anim .leaflet-popup {
+	opacity: 0;
+	-webkit-transition: opacity 0.2s linear;
+	   -moz-transition: opacity 0.2s linear;
+	        transition: opacity 0.2s linear;
+	}
+.leaflet-fade-anim .leaflet-map-pane .leaflet-popup {
+	opacity: 1;
+	}
+.leaflet-zoom-animated {
+	-webkit-transform-origin: 0 0;
+	    -ms-transform-origin: 0 0;
+	        transform-origin: 0 0;
+	}
+.leaflet-zoom-anim .leaflet-zoom-animated {
+	will-change: transform;
+	}
+.leaflet-zoom-anim .leaflet-zoom-animated {
+	-webkit-transition: -webkit-transform 0.25s cubic-bezier(0,0,0.25,1);
+	   -moz-transition:    -moz-transform 0.25s cubic-bezier(0,0,0.25,1);
+	        transition:         transform 0.25s cubic-bezier(0,0,0.25,1);
+	}
+.leaflet-zoom-anim .leaflet-tile,
+.leaflet-pan-anim .leaflet-tile {
+	-webkit-transition: none;
+	   -moz-transition: none;
+	        transition: none;
+	}
+
+.leaflet-zoom-anim .leaflet-zoom-hide {
+	visibility: hidden;
+	}
+
+
+/* cursors */
+
+.leaflet-interactive {
+	cursor: pointer;
+	}
+.leaflet-grab {
+	cursor: -webkit-grab;
+	cursor:    -moz-grab;
+	cursor:         grab;
+	}
+.leaflet-crosshair,
+.leaflet-crosshair .leaflet-interactive {
+	cursor: crosshair;
+	}
+.leaflet-popup-pane,
+.leaflet-control {
+	cursor: auto;
+	}
+.leaflet-dragging .leaflet-grab,
+.leaflet-dragging .leaflet-grab .leaflet-interactive,
+.leaflet-dragging .leaflet-marker-draggable {
+	cursor: move;
+	cursor: -webkit-grabbing;
+	cursor:    -moz-grabbing;
+	cursor:         grabbing;
+	}
+
+/* marker & overlays interactivity */
+.leaflet-marker-icon,
+.leaflet-marker-shadow,
+.leaflet-image-layer,
+.leaflet-pane > svg path,
+.leaflet-tile-container {
+	pointer-events: none;
+	}
+
+.leaflet-marker-icon.leaflet-interactive,
+.leaflet-image-layer.leaflet-interactive,
+.leaflet-pane > svg path.leaflet-interactive,
+svg.leaflet-image-layer.leaflet-interactive path {
+	pointer-events: visiblePainted; /* IE 9-10 doesn't have auto */
+	pointer-events: auto;
+	}
+
+/* visual tweaks */
+
+.leaflet-container {
+	background: #ddd;
+	outline: 0;
+	}
+.leaflet-container a {
+	color: #0078A8;
+	}
+.leaflet-container a.leaflet-active {
+	outline: 2px solid orange;
+	}
+.leaflet-zoom-box {
+	border: 2px dotted #38f;
+	background: rgba(255,255,255,0.5);
+	}
+
+
+/* general typography */
+.leaflet-container {
+	font: 12px/1.5 "Helvetica Neue", Arial, Helvetica, sans-serif;
+	}
+
+
+/* general toolbar styles */
+
+.leaflet-bar {
+	box-shadow: 0 1px 5px rgba(0,0,0,0.65);
+	border-radius: 4px;
+	}
+.leaflet-bar a,
+.leaflet-bar a:hover {
+	background-color: #fff;
+	border-bottom: 1px solid #ccc;
+	width: 26px;
+	height: 26px;
+	line-height: 26px;
+	display: block;
+	text-align: center;
+	text-decoration: none;
+	color: black;
+	}
+.leaflet-bar a,
+.leaflet-control-layers-toggle {
+	background-position: 50% 50%;
+	background-repeat: no-repeat;
+	display: block;
+	}
+.leaflet-bar a:hover {
+	background-color: #f4f4f4;
+	}
+.leaflet-bar a:first-child {
+	border-top-left-radius: 4px;
+	border-top-right-radius: 4px;
+	}
+.leaflet-bar a:last-child {
+	border-bottom-left-radius: 4px;
+	border-bottom-right-radius: 4px;
+	border-bottom: none;
+	}
+.leaflet-bar a.leaflet-disabled {
+	cursor: default;
+	background-color: #f4f4f4;
+	color: #bbb;
+	}
+
+.leaflet-touch .leaflet-bar a {
+	width: 30px;
+	height: 30px;
+	line-height: 30px;
+	}
+.leaflet-touch .leaflet-bar a:first-child {
+	border-top-left-radius: 2px;
+	border-top-right-radius: 2px;
+	}
+.leaflet-touch .leaflet-bar a:last-child {
+	border-bottom-left-radius: 2px;
+	border-bottom-right-radius: 2px;
+	}
+
+/* zoom control */
+
+.leaflet-control-zoom-in,
+.leaflet-control-zoom-out {
+	font: bold 18px 'Lucida Console', Monaco, monospace;
+	text-indent: 1px;
+	}
+
+.leaflet-touch .leaflet-control-zoom-in, .leaflet-touch .leaflet-control-zoom-out  {
+	font-size: 22px;
+	}
+
+
+/* layers control */
+
+.leaflet-control-layers {
+	box-shadow: 0 1px 5px rgba(0,0,0,0.4);
+	background: #fff;
+	border-radius: 5px;
+	}
+.leaflet-control-layers-toggle {
+	background-image: url(images/layers.png);
+	width: 36px;
+	height: 36px;
+	}
+.leaflet-retina .leaflet-control-layers-toggle {
+	background-image: url(images/layers-2x.png);
+	background-size: 26px 26px;
+	}
+.leaflet-touch .leaflet-control-layers-toggle {
+	width: 44px;
+	height: 44px;
+	}
+.leaflet-control-layers .leaflet-control-layers-list,
+.leaflet-control-layers-expanded .leaflet-control-layers-toggle {
+	display: none;
+	}
+.leaflet-control-layers-expanded .leaflet-control-layers-list {
+	display: block;
+	position: relative;
+	}
+.leaflet-control-layers-expanded {
+	padding: 6px 10px 6px 6px;
+	color: #333;
+	background: #fff;
+	}
+.leaflet-control-layers-scrollbar {
+	overflow-y: scroll;
+	overflow-x: hidden;
+	padding-right: 5px;
+	}
+.leaflet-control-layers-selector {
+	margin-top: 2px;
+	position: relative;
+	top: 1px;
+	}
+.leaflet-control-layers label {
+	display: block;
+	}
+.leaflet-control-layers-separator {
+	height: 0;
+	border-top: 1px solid #ddd;
+	margin: 5px -10px 5px -6px;
+	}
+
+/* Default icon URLs */
+.leaflet-default-icon-path {
+	background-image: url(images/marker-icon.png);
+	}
+
+
+/* attribution and scale controls */
+
+.leaflet-container .leaflet-control-attribution {
+	background: #fff;
+	background: rgba(255, 255, 255, 0.7);
+	margin: 0;
+	}
+.leaflet-control-attribution,
+.leaflet-control-scale-line {
+	padding: 0 5px;
+	color: #333;
+	}
+.leaflet-control-attribution a {
+	text-decoration: none;
+	}
+.leaflet-control-attribution a:hover {
+	text-decoration: underline;
+	}
+.leaflet-container .leaflet-control-attribution,
+.leaflet-container .leaflet-control-scale {
+	font-size: 11px;
+	}
+.leaflet-left .leaflet-control-scale {
+	margin-left: 5px;
+	}
+.leaflet-bottom .leaflet-control-scale {
+	margin-bottom: 5px;
+	}
+.leaflet-control-scale-line {
+	border: 2px solid #777;
+	border-top: none;
+	line-height: 1.1;
+	padding: 2px 5px 1px;
+	font-size: 11px;
+	white-space: nowrap;
+	overflow: hidden;
+	-moz-box-sizing: border-box;
+	     box-sizing: border-box;
+
+	background: #fff;
+	background: rgba(255, 255, 255, 0.5);
+	}
+.leaflet-control-scale-line:not(:first-child) {
+	border-top: 2px solid #777;
+	border-bottom: none;
+	margin-top: -2px;
+	}
+.leaflet-control-scale-line:not(:first-child):not(:last-child) {
+	border-bottom: 2px solid #777;
+	}
+
+.leaflet-touch .leaflet-control-attribution,
+.leaflet-touch .leaflet-control-layers,
+.leaflet-touch .leaflet-bar {
+	box-shadow: none;
+	}
+.leaflet-touch .leaflet-control-layers,
+.leaflet-touch .leaflet-bar {
+	border: 2px solid rgba(0,0,0,0.2);
+	background-clip: padding-box;
+	}
+
+
+/* popup */
+
+.leaflet-popup {
+	position: absolute;
+	text-align: center;
+	margin-bottom: 20px;
+	}
+.leaflet-popup-content-wrapper {
+	padding: 1px;
+	text-align: left;
+	border-radius: 12px;
+	}
+.leaflet-popup-content {
+	margin: 13px 19px;
+	line-height: 1.4;
+	}
+.leaflet-popup-content p {
+	margin: 18px 0;
+	}
+.leaflet-popup-tip-container {
+	width: 40px;
+	height: 20px;
+	position: absolute;
+	left: 50%;
+	margin-left: -20px;
+	overflow: hidden;
+	pointer-events: none;
+	}
+.leaflet-popup-tip {
+	width: 17px;
+	height: 17px;
+	padding: 1px;
+
+	margin: -10px auto 0;
+
+	-webkit-transform: rotate(45deg);
+	   -moz-transform: rotate(45deg);
+	    -ms-transform: rotate(45deg);
+	        transform: rotate(45deg);
+	}
+.leaflet-popup-content-wrapper,
+.leaflet-popup-tip {
+	background: white;
+	color: #333;
+	box-shadow: 0 3px 14px rgba(0,0,0,0.4);
+	}
+.leaflet-container a.leaflet-popup-close-button {
+	position: absolute;
+	top: 0;
+	right: 0;
+	padding: 4px 4px 0 0;
+	border: none;
+	text-align: center;
+	width: 18px;
+	height: 14px;
+	font: 16px/14px Tahoma, Verdana, sans-serif;
+	color: #c3c3c3;
+	text-decoration: none;
+	font-weight: bold;
+	background: transparent;
+	}
+.leaflet-container a.leaflet-popup-close-button:hover {
+	color: #999;
+	}
+.leaflet-popup-scrolled {
+	overflow: auto;
+	border-bottom: 1px solid #ddd;
+	border-top: 1px solid #ddd;
+	}
+
+.leaflet-oldie .leaflet-popup-content-wrapper {
+	-ms-zoom: 1;
+	}
+.leaflet-oldie .leaflet-popup-tip {
+	width: 24px;
+	margin: 0 auto;
+
+	-ms-filter: "progid:DXImageTransform.Microsoft.Matrix(M11=0.70710678, M12=0.70710678, M21=-0.70710678, M22=0.70710678)";
+	filter: progid:DXImageTransform.Microsoft.Matrix(M11=0.70710678, M12=0.70710678, M21=-0.70710678, M22=0.70710678);
+	}
+.leaflet-oldie .leaflet-popup-tip-container {
+	margin-top: -1px;
+	}
+
+.leaflet-oldie .leaflet-control-zoom,
+.leaflet-oldie .leaflet-control-layers,
+.leaflet-oldie .leaflet-popup-content-wrapper,
+.leaflet-oldie .leaflet-popup-tip {
+	border: 1px solid #999;
+	}
+
+
+/* div icon */
+
+.leaflet-div-icon {
+	background: #fff;
+	border: 1px solid #666;
+	}
+
+
+/* Tooltip */
+/* Base styles for the element that has a tooltip */
+.leaflet-tooltip {
+	position: absolute;
+	padding: 6px;
+	background-color: #fff;
+	border: 1px solid #fff;
+	border-radius: 3px;
+	color: #222;
+	white-space: nowrap;
+	-webkit-user-select: none;
+	-moz-user-select: none;
+	-ms-user-select: none;
+	user-select: none;
+	pointer-events: none;
+	box-shadow: 0 1px 3px rgba(0,0,0,0.4);
+	}
+.leaflet-tooltip.leaflet-clickable {
+	cursor: pointer;
+	pointer-events: auto;
+	}
+.leaflet-tooltip-top:before,
+.leaflet-tooltip-bottom:before,
+.leaflet-tooltip-left:before,
+.leaflet-tooltip-right:before {
+	position: absolute;
+	pointer-events: none;
+	border: 6px solid transparent;
+	background: transparent;
+	content: "";
+	}
+
+/* Directions */
+
+.leaflet-tooltip-bottom {
+	margin-top: 6px;
+}
+.leaflet-tooltip-top {
+	margin-top: -6px;
+}
+.leaflet-tooltip-bottom:before,
+.leaflet-tooltip-top:before {
+	left: 50%;
+	margin-left: -6px;
+	}
+.leaflet-tooltip-top:before {
+	bottom: 0;
+	margin-bottom: -12px;
+	border-top-color: #fff;
+	}
+.leaflet-tooltip-bottom:before {
+	top: 0;
+	margin-top: -12px;
+	margin-left: -6px;
+	border-bottom-color: #fff;
+	}
+.leaflet-tooltip-left {
+	margin-left: -6px;
+}
+.leaflet-tooltip-right {
+	margin-left: 6px;
+}
+.leaflet-tooltip-left:before,
+.leaflet-tooltip-right:before {
+	top: 50%;
+	margin-top: -6px;
+	}
+.leaflet-tooltip-left:before {
+	right: 0;
+	margin-right: -12px;
+	border-left-color: #fff;
+	}
+.leaflet-tooltip-right:before {
+	left: 0;
+	margin-left: -12px;
+	border-right-color: #fff;
+	}

install.sh

@@ -1,155 +1,378 @@
 #!/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
-
+chronjob="0 1 * * * /usr/bin/python3 $program_path/etc/report_generator5.py"
+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
+cp etc/mesh_bot_w3.tmp etc/mesh_bot_w3.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"
-            exxt 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 == "pong" ]]; then
+    bot="pong"
+elif [[ $1 == "mesh" ]] || [[ $(echo "${embedded}" | grep -i "^y") ]]; then
+    bot="mesh"
+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"
 sed -i $replace etc/pong_bot.service
 sed -i $replace etc/mesh_bot.service
+sed -i $replace etc/mesh_bot_reporting.service
+sed -i $replace etc/mesh_bot_w3.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"
+else
+    whoami=$(whoami)
+fi
+# set basic permissions for the bot user
+sudo usermod -a -G dialout $whoami
+sudo usermod -a -G tty $whoami
+sudo usermod -a -G bluetooth $whoami
+echo "Added user $whoami to dialout, tty, and bluetooth groups"
+
+sudo chown -R $whoami:$whoami $program_path/logs
+sudo chown -R $whoami:$whoami $program_path/data
+echo "Permissions set for meshbot on logs and data directories"
+
+# 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
+sed -i $replace etc/mesh_bot_reporting.service
+sed -i $replace etc/mesh_bot_w3.service
 replace="s|Group=pi|Group=$whoami|g"
 sed -i $replace etc/pong_bot.service
 sed -i $replace etc/mesh_bot.service
-sudo systemctl daemon-reload
+sed -i $replace etc/mesh_bot_reporting.service
+sed -i $replace etc/mesh_bot_w3.service
 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 LLM Ollama compnents we will execute the following commands\n"
+    printf "\ncurl -fsSL https://ollama.com/install.sh | sh\n"
+    printf "ollama pull gemma3:270m\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 gemma3:latest
+        printf "\n Ollama install done now we can install the gemma3:270m components\n"
+        echo "Do you want to install the gemma3:270m components? (y/n)"
+        read gemma
+        if [[ $(echo "${gemma}" | grep -i "^y") ]]; then
+            ollama pull gemma3:270m
+        fi
     fi
+
+    # ask if the user wants to edit the ollama service for API access
+    if [[ -f /etc/systemd/system/ollama.service ]]; then
+        printf "\nEdit /etc/systemd/system/ollama.service and add Environment=OLLAMA_HOST=0.0.0.0 for API? (y/n)"
+        read editollama
+        if [[ $(echo "${editollama}" | grep -i "^y") ]]; then
+            replace="s|\[Service\]|\[Service\]\nEnvironment=\"OLLAMA_HOST=0.0.0.0\"|g"
+            sudo sed -i "$replace" /etc/systemd/system/ollama.service
+            sudo systemctl daemon-reload
+            sudo systemctl restart ollama.service
+            printf "\nOllama service updated and restarted\n"
+        fi
+        # assume we want to enable ollama in config.ini
+        if [[ -f config.ini ]]; then
+            replace="s|ollama = False|ollama = True|g"
+            sed -i "$replace" config.ini
+            printf "\nOllama enabled in config.ini\n"
+        fi
+    fi
+
+    # 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/%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" "$service" >> install_notes.txt
+    printf "sudo systemctl restart %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
+    printf "Reporting chron job added to run report_generator5.py\n" >> install_notes.txt
+    printf "chronjob: %s\n" "$chronjob" >> install_notes.txt
+    
+    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"
+    # add service dependency for meshtasticd into service file
+    #replace="s|After=network.target|After=network.target meshtasticd.service|g"
+
+    # 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
+    # check if the cron job already exists
+    if ! crontab -l | grep -q "$chronjob"; then
+        # add the cron job to run the report_generator5.py script
+        (crontab -l 2>/dev/null; echo "$chronjob") | crontab -
+        printf "\nAdded cron job to run report_generator5.py\n"
+    else
+        printf "\nCron job already exists, skipping\n"
+    fi
+    printf "Reference following commands:\n\n" "$service" > install_notes.txt
+    printf "sudo systemctl status %s.service\n" "$service" >> install_notes.txt
+    printf "sudo systemctl start %s.service\n" "$service" >> install_notes.txt
+    printf "sudo systemctl restart %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_w3.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.
+# wget https://gist.github.com/MattIPv4/045239bc27b16b2bcf7a3a9a4648c08a -O bee.txt

launch.sh

@@ -1,24 +1,36 @@
 #!/bin/bash
+# This script launches the meshing-around bot or the report generator in python virtual environment
 
 # launch.sh
 cd "$(dirname "$0")"
 
-# activate the virtual environment if it exists
-if [ -d "venv" ]; then
-    source venv/bin/activate
-fi
 
 if [ ! -f "config.ini" ]; then
     cp config.template config.ini
 fi
 
-# launch the application
-if [ "$1" == "pong" ]; then
-    python3 pong_bot.py
-elif [ "$1" == "mesh" ]; then
-    python3 mesh_bot.py
+# activate the virtual environment if it exists
+if [ -d "venv" ]; then
+    source venv/bin/activate
 else
-    printf "\nPlease provide a bot to launch (pong/mesh)"
+    echo "Virtual environment not found, this tool just launches the .py in venv"
+    exit 1
+fi
+
+# launch the application
+if [[ "$1" == pong* ]]; then
+    python3 pong_bot.py
+elif [[ "$1" == mesh* ]]; then
+    python3 mesh_bot.py
+elif [ "$1" == "html" ]; then
+    python3 etc/report_generator.py
+elif [ "$1" == "html5" ]; then
+    python3 etc/report_generator5.py
+elif [[ "$1" == add* ]]; then
+    python3 script/addFav.py
+else
+    echo "Please provide a bot to launch (pong/mesh) or a report to generate (html/html5) or addFav"
+    exit 1
 fi
 
 deactivate

logs/README.md

@@ -1,15 +1,41 @@
-Logs will collect here.
+# Logs and Reports
+Logs will collect here. Give a day of logs or a bunch of messages to have good reports.
 
-Logging messages to disk or Syslog to disk uses the python native logging function. Take a look at the [/modules/log.py](/modules/log.py) you can set the file logger for syslog to INFO for example to not log DEBUG messages to file log, or modify the stdOut level.
-```
+## 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! ‼️
+ - If you are in a venv and using launch.sh you can `launch.sh html5`
+
+![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
-LogMessagesToFile = True
-# Logging of system messages to file
+# 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
 ```
-Example to log to disk only INFO and higher (ignore DEBUG)
+## 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.
+
+find it at. http://localhost:8420
+
+If you have linux-native running and errors such as..
+```bash
+  File "/usr/lib/python3.11/http/server.py", line 136, in server_bind
+    socketserver.TCPServer.server_bind(self)
+  File "/usr/lib/python3.11/socketserver.py", line 472, in server_bind
+    self.socket.bind(self.server_address)
+```
+modify the modules/web.py to use a real IP address, meshtasticD-native is binding to 127.0.0.1
+
+```python
+# Set the desired IP address
+server_ip = '127.0.0.1'
 ```
-*log.py
-file_handler.setLevel(logging.INFO) # DEBUG used by default for system logs to disk example here shows INFO
-```

modules/README.md

@@ -0,0 +1,54 @@
+# Modules and Adding stuff
+
+To help with code testing see `etc/simulator.py` to simulate a bot. I also enjoy meshtasticd(linux-native) in noradio with MQTT server and client to just emulate a mesh.
+
+## By following these steps, you can add a new bbs option to the bot.
+
+1. **Define the Command Handler**:
+   Add a new function in mesh_bot.py to handle the new command. For example, if you want to add a command `newcommand`:
+   ```python
+   def handle_newcommand(message, message_from_id, deviceID):
+       return "This is a response from the new command."
+   ```
+   Additionally you can add a whole new module.py, I recommend doing this if you need to import more stuff, try and wedge it into similar spots if you can. You will need to import the file as well, look further at `modules/system.py` for more.
+2. **Add the Command to the Auto Response**:
+   Update the auto_response function in mesh_bot.py to include the new command:
+   ```python
+   def auto_response(message, snr, rssi, hop, pkiStatus, message_from_id, channel_number, deviceID, isDM):
+       #...
+       "newcommand": lambda: handle_newcommand(message, message_from_id, deviceID),
+       #...
+   ```
+3. **Update the Trap List and Help**:
+    A quick way to do this is to edit the line 16/17 in `modules/system.py` to include the new command:
+    ```python
+    #...
+    trap_list = ("cmd", "cmd?", "newcommand")  # default trap list, with the new command added
+    help_message = "Bot CMD?:newcommand, "
+    #...
+    ```
+
+    **If looking to merge** the prefered way would be to update `modules/system.py` Adding this block below `ping` which ends around line 28:
+    ```python
+    # newcommand Configuration
+    newcommand_enabled = True  # settings.py handles the config.ini values; this is a placeholder
+    if newcommand_enabled:
+         trap_list_newcommand = ("newcommand",)
+         trap_list = trap_list + trap_list_newcommand
+         help_message = help_message + ", newcommand"
+    ```
+
+5. **Test the New Command**:
+   Run MeshBot and test the new command by sending a message with the command `newcommand` to ensure it responds correctly.
+
+
+### Running a Shell command
+
+Using the above example and enabling the filemon module, you can make a command which calls a bash file to do things on the system.
+
+```python
+def auto_response(message, snr, rssi, hop, pkiStatus, message_from_id, channel_number, deviceID, isDM):
+    #...
+    "switchON": lambda: call_external_script(message)
+```
+This would call the default script located in script/runShell.sh and return its output.

modules/bbstools.py

@@ -3,31 +3,57 @@
 
 import pickle # pip install pickle
 from modules.log import *
+import time
 
-trap_list_bbs = ("bbslist", "bbspost", "bbsread", "bbsdelete", "bbshelp", "bbsinfo")
+useSynchCompression = False
+
+if useSynchCompression:
+    import zlib
+    from modules.system import send_raw_bytes
+
+trap_list_bbs = ("bbslist", "bbspost", "bbsread", "bbsdelete", "bbshelp", "bbsinfo", "bbslink", "bbsack")
 
 # global message list, later we will use a pickle on disk
 bbs_messages = []
 bbs_dm = []
 
+
 def load_bbsdb():
     global bbs_messages
     # load the bbs messages from the database file
     try:
-        with open('bbsdb.pkl', 'rb') as f:
-            bbs_messages = pickle.load(f)
-    except Exception as e:
+        with open('data/bbsdb.pkl', 'rb') as f:
+            new_bbs_messages = pickle.load(f)
+            if isinstance(new_bbs_messages, list):
+                for msg in new_bbs_messages:
+                    #example [1, 'Welcome to meshBBS', 'Welcome to the BBS, please post a message!', 0]
+                    msgHash = hash(tuple(msg[1:3]))  # Create a hash of the message content (subject and body)
+                    # Check if the message already exists in bbs_messages
+                    if all(hash(tuple(existing_msg[1:3])) != msgHash for existing_msg in bbs_messages):
+                        # if the message is not a duplicate, add it to bbs_messages Maintain the message ID sequence
+                        new_id = len(bbs_messages) + 1
+                        bbs_messages.append([new_id, msg[1], msg[2], msg[3]])
+    except FileNotFoundError:
+        logger.debug("System: bbsdb.pkl not found, creating new one")
+        bbs_messages = [[1, "Welcome to meshBBS", "Welcome to the BBS, please post a message!",0]]
+        try:
+            with open('data/bbsdb.pkl', 'wb') as f:
+                pickle.dump(bbs_messages, f)
+        except Exception as e:
+            logger.error(f"System: Error creating bbsdb.pkl: {e}")
+    except Exception as e:
+        logger.error(f"System: Error loading bbsdb.pkl: {e}")
         bbs_messages = [[1, "Welcome to meshBBS", "Welcome to the BBS, please post a message!",0]]
-        logger.debug("System: Creating new bbsdb.pkl")
-        with open('bbsdb.pkl', 'wb') as f:
-            pickle.dump(bbs_messages, f)
 
 def save_bbsdb():
     global bbs_messages
     # save the bbs messages to the database file
-    logger.debug("System: Saving bbsdb.pkl")
-    with open('bbsdb.pkl', 'wb') as f:
-        pickle.dump(bbs_messages, f)
+    try:
+        logger.debug("System: Saving data/bbsdb.pkl")
+        with open('data/bbsdb.pkl', 'wb') as f:
+            pickle.dump(bbs_messages, f)
+    except Exception as e:
+        logger.error(f"System: Error saving bbsdb: {e}")
 
 def bbs_help():
     # help message
@@ -39,7 +65,7 @@ def bbs_list_messages():
     message_list = ""
     for message in bbs_messages:
         # message[0] is the messageID, message[1] is the subject
-        message_list += "Msg #" + str(message[0]) + " " + message[1] + "\n"
+        message_list += "[#" + str(message[0]) + "] " + message[1] + "\n"
 
     # last newline removed
     message_list = message_list[:-1]
@@ -69,7 +95,11 @@ def bbs_delete_message(messageID = 0, fromNode = 0):
     else:
         return "Please specify a message number to delete."
 
-def bbs_post_message(subject, message, fromNode):
+def bbs_post_message(subject, message, fromNode, threadID=0, replytoID=0):
+    # post a message to the bbsdb
+    now = today.strftime('%Y-%m-%d %H:%M:%S')
+    thread = threadID
+    replyto = replytoID
     # post a message to the bbsdb and assign a messageID
     messageID = len(bbs_messages) + 1
 
@@ -77,9 +107,17 @@ def bbs_post_message(subject, message, fromNode):
     if str(fromNode) in bbs_ban_list:
         logger.warning(f"System: Naughty node {fromNode}, tried to post a message: {subject}, {message} and was dropped.")
         return "Message posted. ID is: " + str(messageID)
-
+    # validate message length isnt three times the MESSAGE_CHUNK_SIZE
+    if len(message) > (3 * MESSAGE_CHUNK_SIZE):
+        return "Message too long, max length is " + str(3 * MESSAGE_CHUNK_SIZE) + " characters."
+    # validate not a duplicate message
+    for msg in bbs_messages:
+        if msg[1].strip().lower() == subject.strip().lower() and msg[2].strip().lower() == message.strip().lower():
+            messageID = msg[0]
+            return "Message posted. ID is: " + str(messageID)
+    # validate its not overlength by keeping in chunker limit
     # append the message to the list
-    bbs_messages.append([messageID, subject, message, fromNode])
+    bbs_messages.append([messageID, subject, message, fromNode, now, thread, replyto])
     logger.info(f"System: NEW Message Posted, subject: {subject}, message: {message} from {fromNode}")
 
     # save the bbsdb
@@ -92,28 +130,34 @@ def bbs_read_message(messageID = 0):
     if (messageID - 1) >= len(bbs_messages):
         return "Message not found."
     if messageID > 0:
+        fromNode = bbs_messages[messageID - 1][3]
+        fromNodeHex = hex(fromNode)[-4:]
         message = bbs_messages[messageID - 1]
-        return f"Msg #{message[0]}\nMsg Body: {message[2]}"
+        return f"Msg #{message[0]}\nFrom:{fromNodeHex}\n{message[2]}"
     else:
         return "Please specify a message number to read."
    
 def save_bbsdm():
     global bbs_dm
     # save the bbs messages to the database file
-    logger.debug("System: Saving Updated BBS Direct Messages bbsdm.pkl")
-    with open('bbsdm.pkl', 'wb') as f:
+    logger.debug("System: Saving Updated BBS Direct Messages data/bbsdm.pkl")
+    with open('data/bbsdm.pkl', 'wb') as f:
         pickle.dump(bbs_dm, f)
 
 def load_bbsdm():
     global bbs_dm
     # load the bbs messages from the database file
     try:
-        with open('bbsdm.pkl', 'rb') as f:
-            bbs_dm = pickle.load(f)
+        with open('data/bbsdm.pkl', 'rb') as f:
+            new_bbs_dm = pickle.load(f)
+            if isinstance(new_bbs_dm, list):
+                for msg in new_bbs_dm:
+                    if msg not in bbs_dm:
+                        bbs_dm.append(msg)
     except:
         bbs_dm = [[1234567890, "Message", 1234567890]]
-        logger.debug("System: Creating new bbsdm.pkl")
-        with open('bbsdm.pkl', 'wb') as f:
+        logger.debug("System: Creating new data/bbsdm.pkl")
+        with open('data/bbsdm.pkl', 'wb') as f:
             pickle.dump(bbs_dm, f)
 
 def bbs_post_dm(toNode, message, fromNode):
@@ -122,6 +166,14 @@ def bbs_post_dm(toNode, message, fromNode):
     if str(fromNode) in bbs_ban_list:
         logger.warning(f"System: Naughty node {fromNode}, tried to post a message: {message} and was dropped.")
         return "DM Posted for node " + str(toNode)
+    
+    # validate message length isnt three times the MESSAGE_CHUNK_SIZE
+    if len(message) > (3 * MESSAGE_CHUNK_SIZE):
+        return "Message too long, max length is " + str(3 * MESSAGE_CHUNK_SIZE) + " characters."
+    # validate not a duplicate message
+    for msg in bbs_dm:
+        if msg[0] == int(toNode) and msg[1].strip().lower() == message.strip().lower():
+            return "DM Posted for node " + str(toNode)
 
     # append the message to the list
     bbs_dm.append([int(toNode), message, int(fromNode)])
@@ -133,7 +185,7 @@ def bbs_post_dm(toNode, message, fromNode):
 def get_bbs_stats():
     global bbs_messages, bbs_dm
     # Return some stats on the bbs pending messages and total posted messages
-    return f"📡BBSdb has {len(bbs_messages)} messages. Direct ✉️ Messages waiting: {(len(bbs_dm) - 1)}"
+    return f"📡BBSdb has {len(bbs_messages)} messages.\nDirect ✉️ Messages waiting: {(len(bbs_dm) - 1)}"
 
 def bbs_check_dm(toNode):
     global bbs_dm
@@ -156,6 +208,87 @@ def bbs_delete_dm(toNode, message):
             return "System: cleared mail for" + str(toNode)
     return "System: No DM found for node " + str(toNode)
 
+def compress_data(data_to_compress):
+    # Prepare message as bytes
+    compressed = zlib.compress(data_to_compress.encode('utf-8'))
+    return compressed
+
+def decompress_data(data_bytes):
+    try:
+        decompressed = zlib.decompress(data_bytes)
+        msg = decompressed.decode('utf-8')
+        return msg
+    except Exception as e:
+        logger.warning(f"Error decompressing data: {e}")
+        return False
+
+def bbs_receive_compressed(data_bytes, fromNode, RxNode):
+    try:
+        decompressed = zlib.decompress(data_bytes)
+        msg = decompressed.decode('utf-8')
+        
+        bbs_sync_posts(msg, fromNode, RxNode)
+
+        return msg
+    except Exception as e:
+        logger.error(f"Error decompressing BBS message: {e}")
+        return None
+
+def bbs_sync_posts(input, peerNode, RxNode):
+    messageID =  0
+
+    # check if the bbs link is enabled
+    if bbs_link_whitelist != ['']:
+        if str(peerNode) not in bbs_link_whitelist:
+            logger.warning(f"System: BBS Link is disabled for node {peerNode}.")
+            return "System: BBS Link is disabled for your node."
+    if bbs_link_enabled == False:
+        return "System: BBS Link is disabled."
+    
+    # respond when another bot asks for the bbs posts to sync
+    if "bbslink" in input.lower():
+        if "$" in input and "#" in input:
+            #store the message
+            subject = input.split("$")[1].split("#")[0]
+            body = input.split("#")[1]
+            fromNodeHex = input.split("@")[1]
+            try:
+                bbs_post_message(subject, body, int(fromNodeHex, 16))
+            except:
+                logger.error(f"System: Error parsing bbslink from node {peerNode}: {input}")
+                fromNodeHex = hex(peerNode)
+            messageID = input.split(" ")[1]
+            return f"bbsack {messageID}"
+    elif "bbsack" in input.lower():
+        # increment the messageID
+        if len(input.split(" ")) > 1:
+            try:
+                messageID = int(input.split(" ")[1]) + 1
+            except:
+                return "link error"
+        else:
+            return "link error"
+
+    # send message with delay to keep chutil happy
+    if messageID < len(bbs_messages):
+        logger.debug(f"System: wait to bbslink with peer " + str(peerNode))
+        fromNodeHex = hex(bbs_messages[messageID][3])
+        time.sleep(5 + responseDelay)
+        # every 5 messages add extra delay
+        if messageID % 5 == 0:
+            time.sleep(10 + responseDelay)
+        logger.debug(f"System: Sending bbslink message {messageID} of {len(bbs_messages)} to peer " + str(peerNode))
+        msg = f"bbslink {messageID} ${bbs_messages[messageID][1]} #{bbs_messages[messageID][2]} @{fromNodeHex}"
+        if useSynchCompression:
+            compressed = compress_data(msg)
+            send_raw_bytes(peerNode, compressed)
+            logger.debug("System: Sent compressed bbslink message to peer " + str(peerNode))
+        else:
+            return msg
+    else:
+        logger.debug("System: bbslink sync complete with peer " + str(peerNode))
+
+
 #initialize the bbsdb's
 load_bbsdb()
 load_bbsdm()

modules/checklist.py

@@ -0,0 +1,179 @@
+# 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()
+    if reverse_in_out:
+        return "Checked✅Out: " + str(name)
+    else:
+        return "Checked✅In: " + str(name)
+
+def delete_checkin(checkin_id):
+    # delete a checkin
+    conn = sqlite3.connect(checklist_db)
+    c = conn.cursor()
+    c.execute("DELETE FROM checkin WHERE checkin_id = ?", (checkin_id,))
+    conn.commit()
+    conn.close()
+    return "Checkin deleted." + str(checkin_id)
+
+def checkout(name, date, time_str, location, notes):
+    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:
+        if reverse_in_out:
+            return "Checked⌛️In: " + str(name) + " duration " + timeCheckedIn
+        else:
+            return "Checked⌛️Out: " + str(name) + " duration " + timeCheckedIn
+    else:
+        return "None found for " + str(name)
+
+def delete_checkout(checkout_id):
+    # delete a checkout
+    conn = sqlite3.connect(checklist_db)
+    c = conn.cursor()
+    c.execute("DELETE FROM checkout WHERE checkout_id = ?", (checkout_id,))
+    conn.commit()
+    conn.close()
+    return "Checkout deleted." + str(checkout_id)
+
+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, including days
+        total_seconds = time.time() - time.mktime(time.strptime(row[2] + " " + row[3], "%Y-%m-%d %H:%M:%S"))
+        days = int(total_seconds // 86400)
+        hours = int((total_seconds % 86400) // 3600)
+        minutes = int((total_seconds % 3600) // 60)
+        seconds = int(total_seconds % 60)
+        if days > 0:
+            timeCheckedIn = f"{days}d {hours:02}:{minutes:02}:{seconds:02}"
+        else:
+            timeCheckedIn = f"{hours:02}:{minutes:02}:{seconds:02}"
+        checkin_list += "ID: " + row[1] + " checked-In for " + timeCheckedIn
+        if row[5] != "":
+            checkin_list += "📝" + 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")
+    # if user on bbs_ban_list reject command
+    if str(nodeID) in bbs_ban_list:
+        logger.warning("System: Checklist attempt from the ban list")
+        return "unable to process command"
+    try:
+        comment = message.split(" ", 1)[1]
+    except IndexError:
+        comment = ""
+    # handle checklist commands
+    if ("checkin" in message.lower() and not reverse_in_out) or ("checkout" in message.lower() and reverse_in_out):
+        return checkin(name, current_date, current_time, location, comment)
+    elif ("checkout" in message.lower() and not reverse_in_out) or ("checkin" in message.lower() and reverse_in_out):
+        return checkout(name, current_date, current_time, location, comment)
+    elif "purgein" in message.lower():
+        return delete_checkin(nodeID)
+    elif "purgeout" in message.lower():
+        return delete_checkout(nodeID)
+    elif "?" in message.lower():
+        if not reverse_in_out:
+            return ("Command: checklist followed by\n"
+                    "checkout to check out\n"
+                    "purgeout to delete your checkout record\n"
+                    "Example: checkin Arrived at park")
+        else:
+            return ("Command: checklist followed by\n"
+                    "checkin to check out\n"
+                    "purgeout to delete your checkin record\n"
+                    "Example: checkout Leaving park")
+    elif "checklist" in message.lower():
+        return list_checkin()
+    else:
+        return "Invalid command."

modules/filemon.py

@@ -0,0 +1,177 @@
+# File monitor module for the meshing-around bot
+# 2024 Kelly Keeton K7MHI
+
+from modules.log import *
+import asyncio
+import random
+import os
+import subprocess
+
+trap_list_filemon = ("readnews",)
+
+NEWS_DATA_DIR = os.path.join(os.path.dirname(__file__), '..', 'data')
+newsSourcesList = []
+
+def read_file(file_monitor_file_path, random_line_only=False):
+    try:
+        if not os.path.exists(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', encoding='utf-8') as f:
+                lines = f.readlines()
+                return random.choice(lines)
+        else:
+            # read the whole file
+            with open(file_monitor_file_path, 'r', encoding='utf-8') 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(source=None):
+    # Reads the news file. If a source is provided, reads {source}_news.txt.
+    if source:
+        file_path = os.path.join(NEWS_DATA_DIR, f"{source}_news.txt")
+    else:
+        file_path = os.path.join(NEWS_DATA_DIR, news_file_path)
+    return read_file(file_path, news_random_line_only)
+
+def write_news(content, append=False):
+    # write the news file on demand
+    try:
+        file_path = os.path.join(NEWS_DATA_DIR, news_file_path)
+        with open(file_path, 'a' if append else 'w', encoding='utf-8') as f:
+            #f.write(content)
+            logger.info(f"FileMon: Updated {file_path}")
+        return True
+    except Exception as e:
+        logger.warning(f"FileMon: Error writing file: {file_path}")
+        return False
+
+async def watch_file():
+    # Watch the file for changes and return the new content when it changes
+    if not os.path.exists(file_monitor_file_path):
+        return None
+    else:
+        last_modified_time = os.path.getmtime(file_monitor_file_path)
+        while True:
+            current_modified_time = os.path.getmtime(file_monitor_file_path)
+            if current_modified_time != last_modified_time:
+                # File has been modified
+                content = read_file(file_monitor_file_path)
+                last_modified_time = current_modified_time
+                # Cleanup the content
+                content = content.replace('\n', ' ').replace('\r', '').strip()
+                if content:
+                    return content
+            await asyncio.sleep(1)  # Check every
+
+def call_external_script(message, script="script/runShell.sh"):
+    # Call an external script with the message as an argument this is a example only
+    try:
+        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"
+
+        # Use subprocess.run for better resource management
+        result = subprocess.run(
+            ["bash", script_path, message],
+            capture_output=True,
+            text=True,
+            timeout=10
+        )
+        output = result.stdout.strip()
+        return output
+    except Exception as e:
+        logger.warning(f"FileMon: Error calling external script: {e}")
+        return None
+
+
+waitingXroom = {}   # {message_from_id: (expected_answer, original_command, timestamp)}
+def handleShellCmd(message, message_from_id, channel_number, isDM, deviceID):
+    if not allowXcmd:
+        return "x: command is disabled"
+    if str(message_from_id) not in bbs_admin_list:
+        logger.warning(f"FileMon: Unauthorized x: command attempt from {message_from_id}")
+        return "x: command not authorized"
+    if not isDM:
+        return "x: command not authorized in group chat"
+
+    # 2FA logic
+    if xCmd2factorEnabled:
+        timeNOW = datetime.utcnow()
+        # If user is waiting for 2FA, treat message as answer
+        if message_from_id in waitingXroom:
+            answer = message[2:].strip() if message.lower().startswith("x:") else message.strip()
+            expected, orig_command, ts = waitingXroom[message_from_id]
+            if timeNOW - ts > timedelta(seconds=xCmd2factor_timeout):
+                del waitingXroom[message_from_id]
+                return "x2FA timed out, please try again"
+            if answer == str(expected):
+                del waitingXroom[message_from_id]
+                # Run the original command
+                try:
+                    logger.info(f"FileMon: Running shell command from {message_from_id}: {orig_command}")
+                    result = subprocess.run(orig_command, shell=True, capture_output=True, text=True, timeout=10, start_new_session=True)
+                    output = result.stdout.strip()
+                    return output if output else "✅ x: processed finished, no output"
+                except Exception as e:
+                    logger.warning(f"FileMon: Error running shell command: {e}")
+                    logger.debug(f"FileMon: This command is not good for use over the mesh network")
+                    return "x: error running command"
+            else:
+                logger.warning(f"FileMon: 🚨Incorrect 2FA answer from {message_from_id}")
+                return "x2FA incorrect, try again"
+        # If not waiting, treat as new command and issue challenge
+        if message.lower().startswith("x:"):
+            command = message[2:].strip()
+            # Generate two random numbers, seed with message_from_id and time of day
+            seed = timeNOW.second + timeNOW.minute * 60 + timeNOW.hour * 3600 + int(message_from_id)
+            rnd = random.Random(seed)
+            a = rnd.randint(10, 99)
+            b = rnd.randint(10, 99)
+            expected = a + b
+            waitingXroom[message_from_id] = (expected, command, timeNOW)
+            return f"x2FA required.\nReply `x: answer`\nWhat is {a} + {b}? "
+        else:
+            return "invalid command format"
+
+    # If we reach here, 2FA is disabled or passed
+    if enable_runShellCmd:
+        if message.lower().startswith("x:"):
+            command = message[2:].strip()
+        else:
+            return "invalid command format"
+        try:
+            logger.info(f"FileMon: Running shell command from {message_from_id}: {command}")
+            result = subprocess.run(command, shell=True, capture_output=True, text=True, timeout=10, start_new_session=True)
+            output = result.stdout.strip()
+            return output if output else "x: command executed with no output"
+        except Exception as e:
+            logger.warning(f"FileMon: Error running shell command: {e}")
+            logger.debug(f"FileMon: This command is not good for use over the mesh network")
+            return "error running command"
+    else:
+        logger.debug("FileMon: x: command is disabled by no enable_runShellCmd")
+        return "command is disabled"
+
+def initNewsSources():
+    #check for the files _news.txt and add to the newsHeadlines list
+    global newsSourcesList
+    newsSourcesList = []
+    for file in os.listdir(NEWS_DATA_DIR):
+        if file.endswith('_news.txt'):
+            source = file[:-9]  # remove _news.txt
+            newsSourcesList.append(source)
+
+#initialize the headlines on startup
+initNewsSources()

modules/games/blackjack.py

@@ -7,8 +7,7 @@ import time
 import pickle
 
 jack_starting_cash = 100  # Replace 100 with your desired starting cash value
-jackTracker= [{'nodeID': 0, 'cmd': 'new', 'time': time.time(), 'cash': jack_starting_cash,\
-                'bet': 0, 'gameStats': {'p_win': 0, 'd_win': 0, 'draw': 0}, 'p_cards':[], 'd_cards':[], 'p_hand':[], 'd_hand':[], 'next_card':[]}]
+from modules.settings import jackTracker
 
 SUITS = ("♥️", "♦️", "♠️", "♣️")
 RANKS = (
@@ -114,22 +113,35 @@ class jackChips:
         self.total -= self.bet
         self.winnings -= 1
 
-def success_rate(card, obj_h):
-    """ Calculate Success rate of 'HIT' new cards """
-    msg = ""
-    rate = 0
-    diff = 21 - obj_h.value
-    if diff != 0:
-        rate = (VALUES[card[0][1]] / diff) * 100
+def success_rate(next_card, player_hand):
+    # Estimate the chance of a successful 'HIT' (not busting) in blackjack.
 
-    if rate < 100:
-        msg += f"If Hit, chance {int(rate)}% failure, {100-int(rate)}% success."
-    else:
-        l_rate = int(rate - (rate - 99))  # Round to 99
-        if card[0][1] == "A":
-            l_rate -= 99
-        msg += f"If Hit, chance {100-l_rate}% failure, and {l_rate}% success"
-    return msg
+    # If player already has 21 or more, hitting will always bust
+    if player_hand.value >= 21:
+        return "\n🧠 What do you think?"
+
+    # Calculate how much more the player can add without busting
+    max_safe = 21 - player_hand.value
+
+    safe_cards = 0
+    total_cards = 0
+    for rank in VALUES:
+        # 4 cards of each rank in a standard deck
+        count = 4
+        card_value = VALUES[rank]
+        # Ace can be 1 or 11, but here we treat it as 1 if 11 would bust
+        if rank == "A":
+            card_value = 1 if player_hand.value + 11 > 21 else 11
+        # Count as safe if it won't bust the player
+        if card_value <= max_safe:
+            safe_cards += count
+        total_cards += count
+
+    # Calculate probability
+    success_chance = int((safe_cards / total_cards) * 100)
+    fail_chance = 100 - success_chance
+
+    return f"\n🧠Hit: {fail_chance}% 👎, {success_chance}% 👍"
 
 def hits(obj_de):
     new_card = [obj_de.deal_cards()[0][0]]
@@ -147,12 +159,12 @@ def display_hand(hand):
 
 def show_some(player_cards, dealer_cards, obj_h):
     msg = f"Player[{obj_h.value}] {display_hand(player_cards)}  "
-    msg += f"Dealer[{VALUES[dealer_cards[1][1]]}] {dealer_cards[1][1]}{dealer_cards[1][0]} "
+    msg += f"\nDealer[{VALUES[dealer_cards[1][1]]}] {dealer_cards[1][1]}{dealer_cards[1][0]} "
     return msg
 
 def show_all(player_cards, dealer_cards, obj_h, obj_d):
     msg = f"Player[{obj_h.value}] {display_hand(player_cards)}  "
-    msg += f"Dealer[{obj_d.value}] {display_hand(dealer_cards)}"
+    msg += f"\nDealer[{obj_d.value}] {display_hand(dealer_cards)}"
     return msg
 
 def player_bust(obj_h, obj_c):
@@ -210,26 +222,26 @@ def saveHSJack(nodeID, highScore):
     # Save the game state to pickle
     highScore = {'nodeID': nodeID, 'highScore': highScore}
     try:
-        with open('blackjack_hs.pkl', 'wb') as file:
+        with open('data/blackjack_hs.pkl', 'wb') as file:
             pickle.dump(highScore, file)
     except FileNotFoundError:
-        logger.debug("System: BlackJack: Creating new blackjack_hs.pkl file")
-        with open('blackjack_hs.pkl', 'wb') as file:
+        logger.debug("System: BlackJack: Creating new data/blackjack_hs.pkl file")
+        with open('data/blackjack_hs.pkl', 'wb') as file:
             pickle.dump(highScore, file)
 
 def loadHSJack():
     try:
-        with open('blackjack_hs.pkl', 'rb') as file:
+        with open('data/blackjack_hs.pkl', 'rb') as file:
             highScore = pickle.load(file)
             return highScore
     except FileNotFoundError:
-        logger.debug("System: BlackJack: Creating new blackjack_hs.pkl file")
+        logger.debug("System: BlackJack: Creating new data/blackjack_hs.pkl file")
         highScore = {'nodeID': 0, 'highScore': 0}
-        with open('blackjack_hs.pkl', 'wb') as file:
+        with open('data/blackjack_hs.pkl', 'wb') as file:
             pickle.dump(highScore, file)
         return 0
 
-def playBlackJack(nodeID, message):
+def playBlackJack(nodeID, message, last_cmd=None):
     # Initalize the Game
     msg, last_cmd = '', None
     blackJack = False
@@ -267,10 +279,12 @@ def playBlackJack(nodeID, message):
 
     if last_cmd is None:
         # create new player if not in tracker
-        logger.debug(f"System: BlackJack: New Player {nodeID}")
-        jackTracker.append({'nodeID': nodeID, 'cmd': 'new', 'time': time.time(), 'cash': jack_starting_cash,\
-            'bet': 0, 'gameStats': {'p_win': p_win, 'd_win': d_win, 'draw': draw}, 'p_cards':p_cards, 'd_cards':d_cards, 'p_hand':p_hand.cards, 'd_hand':d_hand.cards, 'next_card':next_card})
-        return f"Welcome to ♠️♥️BlackJack♣️♦️ you have {p_chips.total} chips.   Whats your bet?"
+        if nodeID != 0:
+            #logger.debug(f"System: BlackJack: New Player {nodeID}")
+            jackTracker.append({'nodeID': nodeID, 'cmd': 'new', 'last_played': time.time(), 'cash': jack_starting_cash,\
+                'bet': 0, 'gameStats': {'p_win': p_win, 'd_win': d_win, 'draw': draw}, 'p_cards':p_cards, 'd_cards':d_cards, 'p_hand':p_hand.cards, 'd_hand':d_hand.cards, 'next_card':next_card})
+            return f"You have {p_chips.total} chips.   Whats your bet?"
+        return "Error: Player not found."
 
     if getLastCmdJack(nodeID) == "new":
         # Place Bet
@@ -283,24 +297,26 @@ def playBlackJack(nodeID, message):
                 #resend the hand
                 msg += show_some(p_cards, d_cards, p_hand)
                 return msg
+            elif "blackjack" in message.lower():
+                return f"\nTo place a bet, enter the amount you wish to wager."
             else:
                 try:
                     bet_money = int(message)
                 except ValueError:
-                    return "Invalid Bet, please enter a valid number."
+                    return f"\nInvalid Bet, please enter a valid number."
 
             if bet_money <= p_chips.total and bet_money >= 1:
                 p_chips.bet = bet_money
             else:
-                return f"Invalid Bet, the maximum bet you can place is {p_chips.total} and the minimum bet is 1."
+                return f"\nInvalid Bet, the maximum bet you can place is {p_chips.total} and the minimum bet is 1."
         except ValueError:
-            return f"Invalid Bet, the maximum bet, {p_chips.total}"
+            return f"\nInvalid Bet, the maximum bet, {p_chips.total}"
 
         # Show the cards
         msg += show_some(p_cards, d_cards, p_hand)
         # check for blackjack 21 and only two cards
         if p_hand.value == 21 and len(p_hand.cards) == 2:
-            msg += "Player 🎰 BLAAAACKJACKKKK 💰"
+            msg += f"\n🎰 BLAAAACKJACKKKK 💰"
             p_chips.total += round(p_chips.bet * 1.5)
             setLastCmdJack(nodeID, "dealerTurn")
             blackJack = True
@@ -317,7 +333,7 @@ def playBlackJack(nodeID, message):
 
     if getLastCmdJack(nodeID) == "betPlaced":
         setLastCmdJack(nodeID, "playing")
-        msg += "(H)it,(S)tand,(F)orfit,(D)ouble,(R)esend,(L)eave table"
+        msg += f"\n(H)it,(S)tand,(F)orfit,(D)ouble,(R)esend,(L)eave table"
 
         # save the game state
         for i in range(len(jackTracker)):
@@ -367,7 +383,7 @@ def playBlackJack(nodeID, message):
         # Check if player bust
         if player_bust(p_hand, p_chips):
             d_win += 1
-            msg += "💥PlayerBUST💥"
+            msg += f"\n💥PlayerBUST💥"
             setLastCmdJack(nodeID, "dealerTurn")
         
         if getLastCmdJack(nodeID) == "playing":
@@ -419,7 +435,7 @@ def playBlackJack(nodeID, message):
                 d_hand.add_cards(d_card)
                 if dealer_bust(d_hand, p_hand, p_chips):
                     p_win += 1
-                    msg += "💰DealerBUST💥"
+                    msg += f"\n💰DealerBUST💥"
                     break
             # Show all cards
             msg += show_all(p_hand.cards, d_hand.cards, p_hand, d_hand)
@@ -427,15 +443,15 @@ def playBlackJack(nodeID, message):
             # Check who wins
             if push(p_hand, d_hand):
                 draw += 1
-                msg += "👌PUSH"
+                msg += f"\n👌PUSH"
             elif player_wins(p_hand, d_hand, p_chips):
                 p_win += 1
-                msg += "🎉PLAYER WINS🎰"
+                msg += f"\n🎉PLAYER WINS🎰"
             elif dealer_wins(p_hand, d_hand, p_chips):
                 d_win += 1
-                msg += "👎DEALER WINS"
+                msg += f"\n👎DEALER WINS"
         else:
-            msg += "👎DEALER WINS"
+            msg += f"\n👎DEALER WINS"
 
         # Display the Game Stats
         msg += gameStats(str(p_win), str(d_win), str(draw))
@@ -443,20 +459,20 @@ def playBlackJack(nodeID, message):
         # Display the chips left
         if p_chips.total < 1:
             if p_chips.total > 0:
-                msg += "🪙Keep the change you filthy animal!"
+                msg += f"\n🪙Keep the change you filthy animal!"
             else:
-                msg += "💸NO MORE CHIPS!🏧💳"
+                msg += f"\n💸NO MORE CHIPS!🏧💳"
                 p_chips.total = jack_starting_cash
         else:
             # check high score
             highScore = loadHSJack()
             if highScore != 0 and p_chips.total > highScore['highScore']:
-                msg += f"💰HighScore💰{p_chips.total} "
+                msg += f"\n💰HighScore💰{p_chips.total} "
                 saveHSJack(nodeID, p_chips.total)
             else:
-                msg += f"💰You have {p_chips.total} chips "
+                msg += f"\n💰You have {p_chips.total} chips "
 
-        msg += " Bet or Leave?"
+        msg += f"\nBet or Leave?"
 
         # Reset the game
         setLastCmdJack(nodeID, "new")
@@ -468,6 +484,6 @@ def playBlackJack(nodeID, message):
         jackTracker[i]['d_cards'] = []
         jackTracker[i]['p_hand'] = []
         jackTracker[i]['d_hand'] = []
-        jackTracker[i]['time'] = time.time()
+        jackTracker[i]['last_played'] = time.time()
 
     return msg

modules/games/dopewar.py

@@ -14,7 +14,7 @@ dwInventoryDb = [{'userID': 1234567890, 'inventory': 0, 'priceList': [], 'amount
 dwCashDb = [{'userID': 1234567890, 'cash': starting_cash},]
 dwGameDayDb = [{'userID': 1234567890, 'day': 0},]
 dwLocationDb = [{'userID': 1234567890, 'location': 'USA', 'loc_choice': 0},]
-dwPlayerTracker = [{'userID': 1234567890, 'last_played': time.time(), 'cmd': 'start'},]
+from modules.settings import dwPlayerTracker
 # high score is saved in a pickle file
 dwHighScore = {}
 
@@ -110,38 +110,67 @@ def officer(nodeID):
             cash = dwCashDb[i].get('cash')
 
     # rolls to see if the officer takes drugs from you
-    # odds are (1 - event chance) * (officer chance) * (confiscation chance)
-    # currently (1 - 0.35) * (0.20) * (0.35) = 4.55%
-    # chance is approximate, not sure how randint handles endpoints, close enough for my purposes
-    if random.randint(0, 100) > 65: # confiscation chance
-        k = 0
-        j = 0
-        # removes all drugs from inventory tally and individual class attirbute
+    if random.randint(0, 100) > 65: # confiscation chance is 35%
+        j, k = 0, 0
         for i in range(0, len(my_drugs)):
             j = amount[i]
             amount[i] = 0
             k += j
-        inventory -= k
-        # sends 'conf' for confiscated. sending a string is better than a number here
+        # set the cash_taken to conf for confiscation not of cash
         cash_taken = 'conf'
+        # Update the inventory_db
+        inventory -= k
+        for i in range(0, len(dwInventoryDb)):
+            if dwInventoryDb[i].get('userID') == nodeID:
+                dwInventoryDb[i]['inventory'] = inventory
+                amount = dwInventoryDb[i].get('amount')
         return cash_taken
-    # rolls to see if the officer takes cash from you
-    # odds are (1 - event chance) * (officer chance) * (1 - confiscation chance)
-    # currently (1 - 0.35) * (0.20) * (0.65) = 8.45%
-    # chance is approximate, not sure how randint handles endpoints, close enough for my purposes
+    # rolls to see how much cash the officer takes
     cash_taken = random.randint(1, cash-1)
     cash -= cash_taken
-    
     # Update the cash_db and inventory_db
     for i in range(0, len(dwCashDb)):
         if dwCashDb[i].get('userID') == nodeID:
             dwCashDb[i]['cash'] = cash
+    return cash_taken
+
+def get_found_items(nodeID):
+    global dwInventoryDb, dwCashDb
+    msg = ''
+    # get the inventory for the user
     for i in range(0, len(dwInventoryDb)):
         if dwInventoryDb[i].get('userID') == nodeID:
-            dwInventoryDb[i]['inventory'] = inventory
-            amount = dwInventoryDb[i].get('amount')
+            inventory = dwInventoryDb[i].get('inventory')
+    amount = check_inv(nodeID)
 
-    return cash_taken
+    # get the cash for the user
+    for i in range(0, len(dwCashDb)):
+        if dwCashDb[i].get('userID') == nodeID:
+            cash = dwCashDb[i].get('cash')
+
+    if random.randint(0, 100) > 50: # 50% chance to find cash or drugs
+        if random.randint(0, 100) > 30: # 30% chance to find drugs
+            found = random.choice(range(len(my_drugs)))
+            # rolls to see how much of the drug the user finds
+            qty =random.randint(1, 80 - inventory)
+            amount[found] += qty
+            inventory += qty
+            for i in range(0, len(dwInventoryDb)):
+                if dwInventoryDb[i].get('userID') == nodeID:
+                    dwInventoryDb[i]['inventory'] = inventory
+                    dwInventoryDb[i]['amount'] = amount
+            msg = f"💊You found {qty} {my_drugs[found].name}"
+    else:
+        # rolls to see how much cash the user finds
+        cash_found = random.randint(1, 977)
+        cash += cash_found
+        # Update the cash_db
+        for i in range(0, len(dwCashDb)):
+            if dwCashDb[i].get('userID') == nodeID:
+                dwCashDb[i]['cash'] = cash
+        msg = "You found $" + str(cash_found) + "💸"
+        
+    return msg
 
 
 def price_change(event_number):
@@ -203,14 +232,17 @@ def buy_func(nodeID, price_list, choice=0, value='0'):
     else:
         if drug_choice in range(1, len(my_drugs) + 1):
             drug_choice = drug_choice - 1
+            cost = price_list[drug_choice]
             msg = my_drugs[drug_choice].name + ": you have🎒 " + str(amount[drug_choice]) + " "
-            msg += " The going price is: $" + "{:,}".format(price_list[drug_choice]) + " "
+            msg += " The going price is: $" + "{:,}".format(cost) + " "
 
     buy_amount = value
     if buy_amount == 'm':
         buy_amount = cash // price_list[drug_choice]
         if buy_amount > 100 - inventory:
             buy_amount = 100 - inventory
+        if buy_amount == 0:
+            return "You don\'t have any empty inventory slots.🎒"
     # set the buy amount to the max if the user enters m
     buy_amount = int(buy_amount)
     
@@ -286,15 +318,17 @@ def sell_func(nodeID, price_list, choice=0, value='0'):
     else:
         if drug_choice in range(1, len(my_drugs) + 1) and amount[drug_choice - 1] > 0:
             drug_choice = drug_choice - 1
+            cost = price_list[drug_choice]
             msg = my_drugs[drug_choice].name + ": you have " + str(amount[drug_choice]) +\
-                " The going price is: $" + str(price_list[drug_choice])
+                " The going price is: $" + str("{:,}".format(cost))
             # check if the user has enough of the drug to sell
             if sell_amount <= amount[drug_choice]:
                 amount[drug_choice] -= sell_amount
                 cash += sell_amount * price_list[drug_choice]
                 inventory -= sell_amount
-                msg += " You sold " + str(sell_amount) + " " + my_drugs[drug_choice].name + ' for $' +\
-                    str(sell_amount * price_list[drug_choice]) + '. Total cash: $' + "{:,}".format(cash)
+                profit = sell_amount * price_list[drug_choice]
+                msg += " You sold " + str(sell_amount) + " " + my_drugs[drug_choice].name +\
+                     ' for $' + "{:,}".format(profit) + '. Total cash: $' + "{:,}".format(cash)
             else:
                 msg = "You don't have that much"
                 return msg
@@ -317,7 +351,6 @@ def sell_func(nodeID, price_list, choice=0, value='0'):
     
     return msg
 
-
 def get_location_table(nodeID, choice=0):
     global dwLocationDb
     # get the location for the user
@@ -332,9 +365,9 @@ def get_location_table(nodeID, choice=0):
     loc_table_string += ' Where do you want to 🛫?#'
     return loc_table_string
 
-
 def endGameDw(nodeID):
-    global dwCashDb, dwInventoryDb, dwLocationDb, dwGameDayDb, dwHighScore
+    global dwCashDb, dwInventoryDb, dwLocationDb, dwGameDayDb, dwHighScore, dwPlayerTracker
+    cash = 0
     msg = ''
     dwHighScore = getHighScoreDw()
     # Confirm the cash for the user
@@ -343,29 +376,12 @@ def endGameDw(nodeID):
             cash = dwCashDb[i].get('cash')
     logger.debug("System: DopeWars: Game Over for user: " + str(nodeID) + " with cash: " + str(cash))
 
-    # remove the player from the game databases
-    for i in range(0, len(dwCashDb)):
-        if dwCashDb[i].get('userID') == nodeID:
-            dwCashDb.pop(i)
-    for i in range(0, len(dwInventoryDb)):
-        if dwInventoryDb[i].get('userID') == nodeID:
-            dwInventoryDb.pop(i)
-    for i in range(0, len(dwLocationDb)):
-        if dwLocationDb[i].get('userID') == nodeID:
-            dwLocationDb.pop(i)
-    for i in range(0, len(dwGameDayDb)):
-        if dwGameDayDb[i].get('userID') == nodeID:
-            dwGameDayDb.pop(i)
-    for i in range(0, len(dwPlayerTracker)):
-        if dwPlayerTracker[i].get('userID') == nodeID:
-            dwPlayerTracker.pop(i)
-
     # checks if the player's score is higher than the high score and writes a new high score if it is
     if cash > dwHighScore.get('cash'):
         dwHighScore = ({'userID': nodeID, 'cash': round(cash, 2)})
-        with open('dopewar_hs.pkl', 'wb') as file:
+        with open('data/dopewar_hs.pkl', 'wb') as file:
             pickle.dump(dwHighScore, file)
-        msg = "You finished with $" + str(cash) + " and beat the high score!🎉💰"
+            msg = "You finished with $" + "{:,}".format(cash) + " and beat the high score!🎉💰"
         return msg
     if cash > starting_cash:
         msg = 'You made money! 💵 Up ' + str((cash/starting_cash).__round__()) + 'x! Well done.'
@@ -375,8 +391,6 @@ def endGameDw(nodeID):
         return msg
     if cash < starting_cash:
         msg = "You lost money, better go get a real job.💸"
-
-    logger.debug("System: DopeWars: Game Over for user: " + str(nodeID) + " with cash: " + str(cash))
     
     return msg
 
@@ -384,31 +398,35 @@ def getHighScoreDw():
     global dwHighScore
     # Load high score table
     try:
-        with open('dopewar_hs.pkl', 'rb') as file:
+        with open('data/dopewar_hs.pkl', 'rb') as file:
             dwHighScore = pickle.load(file)
     except FileNotFoundError:
         logger.debug("System: DopeWars: No high score table found")
         # high score pickle file is a touple of the nodeID and the high score
         dwHighScore = ({"userID": 4258675309, "cash": 100})
         # write a new high score file if one is not found
-        with open('dopewar_hs.pkl', 'wb') as file:
+        with open('data/dopewar_hs.pkl', 'wb') as file:
             pickle.dump(dwHighScore, file)
     return dwHighScore
 
-def render_game_screen(userID, day_play, total_day, loc_choice, event_number, price_list, cash_stolen):
+def render_game_screen(userID, day_play, total_day, loc_choice, event_number, price_list, cash_stolen, found_items):
     global dwCashDb, dwInventoryDb, dwLocationDb
     msg = ''
     # get the location for the user
     for i in range(0, len(dwLocationDb)):
         if dwLocationDb[i].get('userID') == userID:
             loc = dwLocationDb[i].get('location')
-    
+
     if event_number != -1:
         msg += event_list[event_number].text + f"\n"
-    if event_number == -1 and cash_stolen != 0 and cash_stolen != 'conf':
-        msg += "🚔Officer Leroy stopped you and took $" + str(cash_stolen) + "💸" + f"\n"
-    if event_number == -1 and cash_stolen == 'conf':
-        msg += "🚔Officer Leroy stopped you and took all of your drugs.🚭" + f"\n"
+    elif event_number == -1 and cash_stolen != 0 and cash_stolen != 'conf':
+        msg += random.choice([f"You got high and spent ${str(cash_stolen)}💊💸\n", 
+                              f"You got mugged and lost ${str(cash_stolen)}💸🔫\n",
+                              f"You got a new tattoo and spent ${str(cash_stolen)}💉💸\n",])
+    elif event_number == -1 and cash_stolen == 'conf':
+        msg += f"🚔Officer Bob stopped you and took all of your drugs.🚭\n"
+    elif event_number == -1 and found_items != 'nothing':
+        msg += found_items + f"\n"
 
     # get the inventory for the user
     for i in range(0, len(dwInventoryDb)):
@@ -429,10 +447,10 @@ def render_game_screen(userID, day_play, total_day, loc_choice, event_number, pr
 
     return msg
 
-
 def dopeWarGameDay(nodeID, day_play, total_day):
     global dwCashDb, dwLocationDb, dwInventoryDb
     cash_stolen = 0
+    found_items = 'nothing'
 
     # roll for the event of the day
     event_number = generate_event()
@@ -443,12 +461,14 @@ def dopeWarGameDay(nodeID, day_play, total_day):
             loc = dwLocationDb[i].get('location')
             loc_choice = dwLocationDb[i].get('loc_choice')
 
-    # rolls to see if the officer event happens
-    # odds are (1 - event chance) * (officer chance)
-    # currently (1 - 0.35) * (0.20) = 13%
-    # chance is approximate, not sure how randint handles endpoints, close enough for my purposes
-    if event_number == -1 and random.randint(0, 100) > 80:
-        cash_stolen = officer(nodeID)
+    # rolls to see if event happens
+    if event_number == -1 and random.randint(0, 100) > 80: # 20% chance to have an event
+        if random.randint(0, 100) > 50: # 50% chance to have an officer encounter
+            cash_stolen = officer(nodeID)
+        else:
+            # find items
+            found_items = get_found_items(nodeID)
+
 
     price_list = price_change(event_number)
 
@@ -460,7 +480,7 @@ def dopeWarGameDay(nodeID, day_play, total_day):
     check_inv(nodeID)
 
     # main game display print
-    msg = render_game_screen(nodeID, day_play, total_day, loc_choice, event_number, price_list, cash_stolen)
+    msg = render_game_screen(nodeID, day_play, total_day, loc_choice, event_number, price_list, cash_stolen, found_items)
     
     return msg
 
@@ -570,9 +590,9 @@ def playDopeWars(nodeID, cmd):
                     sell =  sell_func(nodeID, price_list, i, 'm')
                     # ignore starts with "You don't have any"
                     if not sell.startswith("You don't have any"):
-                        msg += sell
-                        if i != len(my_drugs):
-                            msg += '\n'
+                        msg += sell + '\n'
+            # trim the last newline
+            msg = msg[:-1]
             return msg
         elif 'f' in menu_choice:
                 # set last command to location
@@ -583,9 +603,9 @@ def playDopeWars(nodeID, cmd):
 
         elif 'p' in menu_choice:
                 # render_game_screen
-                msg = render_game_screen(nodeID, game_day, total_days, loc_choice, -1, price_list, 0)
+                msg = render_game_screen(nodeID, game_day, total_days, loc_choice, -1, price_list, 0, 'nothing')
                 return msg
-        elif 'end' in menu_choice:
+        elif 'e' in menu_choice:
                 msg = endGameDw(nodeID)
                 return msg
         else:
@@ -644,6 +664,7 @@ def playDopeWars(nodeID, cmd):
         for i in range(0, len(dwPlayerTracker)):
             if dwPlayerTracker[i].get('userID') == nodeID:
                 dwPlayerTracker[i]['cmd'] = 'ask_bsf'
+                dwPlayerTracker[i]['last_played'] = time.time()
     
     # Game end
     if game_day == total_days + 1:

modules/games/golfsim.py

@@ -26,7 +26,7 @@ par4_5_range = par4_range + par5_range
 
 # Player setup
 playingHole = False
-golfTracker = [{'nodeID': 0, 'last_played': time.time(), 'cmd': '', 'hole': 0, 'distance_remaining': 0, 'hole_shots': 0, 'hole_strokes': 0, 'hole_to_par': 0, 'total_strokes': 0, 'total_to_par': 0, 'par': 0, 'hazard': ''}]
+from modules.settings import golfTracker
 
 # Club functions
 def hit_driver():
@@ -102,12 +102,12 @@ def getScorecardGolf(scorecard):
 def getHighScoreGolf(nodeID, strokes, par):
     # check if player is in high score list
     try:
-        with open('golfsim_hs.pkl', 'rb') as f:
+        with open('data/golfsim_hs.pkl', 'rb') as f:
             golfHighScore = pickle.load(f)
     except:
         logger.debug("System: GolfSim: High Score file not found.")
         golfHighScore = [{'nodeID': nodeID, 'strokes': strokes, 'par': par}]
-        with open('golfsim_hs.pkl', 'wb') as f:
+        with open('data/golfsim_hs.pkl', 'wb') as f:
             pickle.dump(golfHighScore, f)
 
     if strokes < golfHighScore[0]['strokes']:
@@ -115,16 +115,15 @@ def getHighScoreGolf(nodeID, strokes, par):
         golfHighScore[0]['nodeID'] = nodeID
         golfHighScore[0]['strokes'] = strokes
         golfHighScore[0]['par'] = par
-        with open('golfsim_hs.pkl', 'wb') as f:
+        with open('data/golfsim_hs.pkl', 'wb') as f:
             pickle.dump(golfHighScore, f)
         return golfHighScore
     
     return 0
 
 # Main game loop
-def playGolf(nodeID, message, finishedHole=False):
+def playGolf(nodeID, message, finishedHole=False, last_cmd=''):
     msg = ''
-    global golfTracker
     # Course setup
     par3_count = 0
     par4_count = 0
@@ -133,6 +132,7 @@ def playGolf(nodeID, message, finishedHole=False):
     total_strokes = 0
     total_to_par = 0
     par = 0
+    hole = 1
 
     # get player's last command from tracker if not new player
     last_cmd = ""
@@ -145,8 +145,12 @@ def playGolf(nodeID, message, finishedHole=False):
             par = golfTracker[i]['par']
             total_strokes = golfTracker[i]['total_strokes']
             total_to_par = golfTracker[i]['total_to_par']
-
-    if last_cmd == "" or last_cmd == "new":
+    #update last played time
+    for i in range(len(golfTracker)):
+        if golfTracker[i]['nodeID'] == nodeID:
+            golfTracker[i]['last_played'] = time.time()
+    
+    if last_cmd == "new":
         # Start a new hole
         if hole <= 9:
             # Set up hole count restrictions on par
@@ -193,17 +197,19 @@ def playGolf(nodeID, message, finishedHole=False):
             # Set initial parameters before starting a hole
             distance_remaining = hole_length
             hole_shots = 0
+            last_cmd = 'stroking'
 
             # save player's current game state
             for i in range(len(golfTracker)):
                 if golfTracker[i]['nodeID'] == nodeID:
+                    golfTracker[i]['cmd'] = last_cmd
+                    golfTracker[i]['hole'] = hole
                     golfTracker[i]['distance_remaining'] = distance_remaining
                     golfTracker[i]['cmd'] = 'stroking'
                     golfTracker[i]['par'] = par
                     golfTracker[i]['total_strokes'] = total_strokes
                     golfTracker[i]['total_to_par'] = total_to_par
                     golfTracker[i]['hazard'] = hazard
-                    golfTracker[i]['hole'] = hole
                     golfTracker[i]['last_played'] = time.time()
                     golfTracker[i]['hole_shots'] = hole_shots
 
@@ -275,7 +281,7 @@ def playGolf(nodeID, message, finishedHole=False):
                 # Show player the club distances
                 msg += f"Caddy Guess:\nD:{hit_driver()} L:{hit_low_iron()} M:{hit_mid_iron()} H:{hit_high_iron()} G:{hit_gap_wedge()} W:{hit_lob_wedge()}"
             else:
-                msg += "Didnt get your club 🥪♣️🪩 choice"
+                msg += f"Didnt get your club 🥪♣️🪩 choice, you have {distance_remaining}yds. to ⛳️"
                 return msg
 
             if distance_remaining - pin_distance > pin_distance or shot_distance > pin_distance:
@@ -320,8 +326,9 @@ def playGolf(nodeID, message, finishedHole=False):
                 else:
                     last_cmd = 'stroking'
             else:
-                msg += "\nYou have " + str(distance_remaining) + "yd. ⛳️"
-                msg += "\nClub?[D, L, M, H, G, W]🏌️"
+                msg += f"\nYou have " + str(distance_remaining) + "yd. ⛳️"
+                msg += f"\nClub?[D, L, M, H, G, W]🏌️"
+
 
                 # save player's current game state, keep stroking
                 for i in range(len(golfTracker)):
@@ -364,7 +371,7 @@ def playGolf(nodeID, message, finishedHole=False):
 
                 if hole not in [1, 10]:
                     # Show player total scoring info for the round, except hole 1 and 10
-                    msg += "\nYou've hit a total of " + str(total_strokes) + " strokes today, for"
+                    msg += f"\nYou've hit a total of " + str(total_strokes) + " strokes today, for"
                     msg += getScorecardGolf(total_to_par)
 
                 # Move to next hole
@@ -374,7 +381,6 @@ def playGolf(nodeID, message, finishedHole=False):
 
             # Scorecard reset
             hole_to_par = 0
-            total_to_par = 0
             hole_strokes = 0
             hole_shots = 0
         
@@ -395,7 +401,7 @@ def playGolf(nodeID, message, finishedHole=False):
             #HighScore Display
             highscore = getHighScoreGolf(nodeID, total_strokes, total_to_par)
             if highscore != 0:
-                msg += "\n🏆New Club Record🏆"
+                msg += " 🏆New Club Record🏆"
             # pop player from tracker
             for i in range(len(golfTracker)):
                 if golfTracker[i]['nodeID'] == nodeID:
@@ -403,7 +409,7 @@ def playGolf(nodeID, message, finishedHole=False):
             logger.debug("System: GolfSim: Player " + str(nodeID) + " has finished their round.")
         else:
             # Show player the next hole
-            msg += playGolf(nodeID, 'new', True)
-            msg += "\n🏌️[D, L, M, H, G, W, End]🏌️"
+            msg += playGolf(nodeID, '', True, last_cmd='new')
+            msg += f"\n🏌️[D, L, M, H, G, W, End]🏌️"
             
     return msg

modules/games/hamtest.py

@@ -0,0 +1,142 @@
+# hamradio test module for meshbot DE K7MHI 2025
+# depends on the JSON question data files from https://github.com/russolsen/ham_radio_question_pool
+
+# data files which are expected to be in ../../data/hamradio/ similar to the following:
+# https://raw.githubusercontent.com/russolsen/ham_radio_question_pool/refs/heads/master/technician-2022-2026/technician.json
+# https://raw.githubusercontent.com/russolsen/ham_radio_question_pool/refs/heads/master/general-2023-2027/general.json
+# https://raw.githubusercontent.com/russolsen/ham_radio_question_pool/refs/heads/master/extra-2024-2028/extra.json
+
+import json
+import random
+import os
+from modules.log import *
+
+class HamTest:
+    def __init__(self):
+        self.questions = {}
+        self.load_questions()
+        self.game = {}
+
+    def load_questions(self):
+        for level in ['technician', 'general', 'extra']:
+            try:
+                with open(f'{os.path.dirname(__file__)}/../../data/hamradio/{level}.json', encoding='utf-8') as f:
+                    self.questions[level] = json.load(f)
+            except FileNotFoundError:
+                logger.error(f"File not found: ../../data/hamradio/{level}.json")
+                self.questions[level] = []
+            except json.JSONDecodeError:
+                logger.error(f"Error decoding JSON from file: ../../data/hamradio/{level}.json")
+                self.questions[level] = []
+
+    def newGame(self, id, level='technician'):
+        msg = f"📻New {level} quiz started, 'end' to exit."
+        if id in self.game:
+            level = self.game[id]['level']
+        self.game[id] = {
+            'level': level,
+            'score': 0,
+            'total': 0,
+            'errors': [],
+            'qId': None,
+            'question': None,
+            'answers': None,
+            'correct': None
+        }
+        # set the pool needed for the game
+        if self.game[id]['level'] == 'extra':
+            self.game[id]['total'] = 50
+        else:
+            self.game[id]['total'] = 35
+
+        # randomize the questions
+        random.shuffle(self.questions[level])
+
+        msg += f"\n{self.nextQuestion(id)}"
+        return msg
+    
+    def nextQuestion(self, id):
+        level = self.game[id]['level']
+        # if question has the word figure in it, skip it
+        question = random.choice(self.questions[level])
+        while 'figure' in question['question'].lower():
+            question = random.choice(self.questions[level])
+
+        self.game[id]['question'] = question['question']
+        self.game[id]['answers'] = question['answers']
+        self.game[id]['correct'] = question['correct']
+        self.game[id]['qId'] = question['id']
+        self.game[id]['total'] -= 1
+
+        if self.game[id]['total'] == 0:
+            return self.endGame(id)
+
+        # ask the question and return answers in A, B, C, D format
+        msg = f"{self.game[id]['question']}\n"
+        for i, answer in enumerate(self.game[id]['answers']):
+            msg += f"{chr(65+i)}. {answer}\n"
+        return msg
+    
+    def answer(self, id, answer):
+        if id not in self.game:
+            return "No game in progress"
+        if self.game[id]['correct'] == ord(answer.upper()) - 65:
+            self.game[id]['score'] += 1
+            return f"Correct👍\n" + self.nextQuestion(id)
+        else:
+            # record the section of the question for study aid
+            section = self.game[id]['qId'][:3]
+            self.game[id]['errors'].append(section)
+            # provide the correct answer
+            answer = [self.game[id]['correct']]
+            return f"Wrong.⛔️ Correct is {chr(65+self.game[id]['correct'])}\n" + self.nextQuestion(id)
+        
+    def getScore(self, id):
+        if id not in self.game:
+            return "No game in progress"
+        score = self.game[id]['score']
+        total = self.game[id]['total']
+        level = self.game[id]['level']
+        if self.game[id]['errors']:
+            areaofstudy = max(set(self.game[id]['errors']), key = self.game[id]['errors'].count)
+        else:
+            areaofstudy = "None"
+
+        if level == 'extra':
+            pool = 50
+        else:
+            pool = 35
+        
+        return f"Score: {score}/{pool}\nQuestions left: {total}\nArea of study: {areaofstudy}"
+    
+    def endGame(self, id):
+        if id not in self.game:
+            return "No game in progress"
+        
+        score = self.game[id]['score']
+        level = self.game[id]['level']
+
+        if level == 'extra':
+            # passing score for extra is 37 out of 50
+            passing = 37
+        else:
+            # passing score for technician and general is 26 out of 35
+            passing = 26
+
+        if score >= passing:
+            msg = f"Game over. Score: {score} 73! 🎉You passed the {level} exam."
+        else:
+            # find the most common section of the questions missed
+            if self.game[id]['errors']:
+                areaofstudy = max(set(self.game[id]['errors']), key = self.game[id]['errors'].count)
+            else:
+                areaofstudy = "None"
+            msg = f"Game over. Score: {score} 73! 😿You did not pass the {level} exam. \nYou may want to study {areaofstudy}."
+        
+        # remove the game[id] from the list
+        del self.game[id]
+        return msg
+
+hamtestTracker = []
+hamtest = HamTest()
+   

modules/games/hangman.py

@@ -0,0 +1,203 @@
+# Written for Meshtastic mesh-bot by ZR1RF Johannes le Roux 2025
+import random
+
+class Hangman:
+    WORDS = [
+    "ability","able","about","above","accept","according","account","across",
+    "act","action","activity","actually","add","address","administration","admit",
+    "adult","affect","after","again","against","age","agency","agent","ago",
+    "agree","agreement","ahead","air","all","allow","almost","alone","along",
+    "already","also","although","always","American","among","amount","analysis",
+    "and","animal","another","answer","any","anyone","anything","appear","apply",
+    "approach","area","argue","arm","around","arrive","art","article","artist",
+    "as","ask","assume","at","attack","attention","attorney","audience","author",
+    "authority","available","avoid","away","baby","back","bad","bag","ball",
+    "bank","bar","base","be","beat","beautiful","because","become","bed","before",
+    "begin","behavior","behind","believe","benefit","best","better","between",
+    "beyond","big","bill","billion","bit","black","blood","blue","board","body",
+    "book","born","both","box","boy","break","bring","brother","budget","build",
+    "building","business","but","buy","by","call","camera","campaign","can",
+    "cancer","candidate","capital","car","card","care","career","carry","case",
+    "catch","cause","cell","center","central","century","certain","certainly",
+    "chair","challenge","chance","change","character","charge","check","child",
+    "choice","choose","church","citizen","city","civil","claim","class","clear",
+    "clearly","close","coach","cold","collection","college","color","come",
+    "commercial","common","community","company","compare","computer","concern",
+    "condition","conference","Congress","consider","consumer","contain","continue",
+    "control","cost","could","country","couple","course","court","cover","create",
+    "crime","cultural","culture","cup","current","customer","cut","dark","data",
+    "daughter","day","dead","deal","death","debate","decade","decide","decision",
+    "deep","defense","degree","democrat","democratic","describe","design",
+    "despite","detail","determine","develop","development","die","difference",
+    "different","difficult","dinner","direction","director","discover","discuss",
+    "discussion","disease","do","doctor","dog","door","down","draw","dream","drive",
+    "drop","drug","during","each","early","east","easy","eat","economic","economy",
+    "edge","education","effect","effort","eight","either","election","else",
+    "employee","end","energy","enjoy","enough","enter","entire","environment",
+    "environmental","especially","establish","even","evening","event","ever",
+    "every","everybody","everyone","everything","evidence","exactly","example",
+    "executive","exist","expect","experience","expert","explain","eye","face",
+    "fact","factor","fail","fall","family","far","fast","father","fear","federal",
+    "feel","feeling","few","field","fight","figure","fill","film","final","finally",
+    "financial","find","fine","finger","finish","fire","firm","first","fish","five",
+    "floor","fly","focus","follow","food","foot","for","force","foreign","forget",
+    "form","former","forward","four","free","friend","from","front","full","fund",
+    "future","game","garden","gas","general","generation","get","girl","give",
+    "glass","go","goal","good","government","great","green","ground","group","grow",
+    "growth","guess","gun","guy","hair","half","hand","hang","happen","happy",
+    "hard","have","he","head","health","hear","heart","heat","heavy","help","her",
+    "here","herself","high","him","himself","his","history","hit","hold","home",
+    "hope","hospital","hot","hotel","hour","house","how","however","huge","human",
+    "hundred","husband","I","idea","identify","if","image","imagine","impact",
+    "important","improve","in","include","including","increase","indeed","indicate",
+    "individual","industry","information","inside","instead","institution","interest",
+    "interesting","international","interview","into","investment","involve","issue",
+    "it","item","its","itself","job","join","just","keep","key","kid","kill","kind",
+    "kitchen","know","knowledge","land","language","large","last","late","later",
+    "laugh","law","lawyer","lay","lead","leader","learn","least","leave","left",
+    "leg","legal","less","let","letter","level","lie","life","light","like","likely",
+    "line","list","listen","little","live","local","long","look","lose","loss",
+    "lot","love","low","machine","magazine","main","maintain","major","majority",
+    "make","man","manage","management","manager","many","market","marriage",
+    "material","matter","may","maybe","me","mean","measure","media","medical","meet",
+    "meeting","member","memory","mention","message","method","middle","might",
+    "military","million","mind","minute","miss","mission","model","modern","moment",
+    "money","month","more","morning","most","mother","mouth","move","movement",
+    "movie","Mr","Mrs","much","music","must","my","myself","name","nation",
+    "national","natural","nature","near","nearly","necessary","need","network",
+    "never","new","news","newspaper","next","nice","night","no","none","nor",
+    "north","not","note","nothing","notice","now","number","occur","of","off",
+    "offer","office","officer","official","often","oh","oil","ok","old","on",
+    "once","one","only","onto","open","operation","opportunity","option","or",
+    "order","organization","other","others","our","out","outside","over","own",
+    "owner","page","pain","painting","paper","parent","part","participant",
+    "particular","particularly","partner","party","pass","past","patient","pattern",
+    "pay","peace","people","per","perform","performance","perhaps","period",
+    "person","personal","phone","physical","pick","picture","piece","place","plan",
+    "plant","play","player","point","police","policy","political","politics",
+    "poor","popular","population","position","positive","possible","power",
+    "practice","prepare","present","president","pressure","pretty","prevent","price",
+    "private","probably","problem","process","produce","product","production",
+    "professional","professor","program","project","property","protect","prove",
+    "provide","public","pull","purpose","push","put","quality","question","quickly",
+    "quite","race","radio","raise","range","rate","rather","reach","read","ready",
+    "real","reality","realize","really","reason","receive","recent","recently",
+    "recognize","record","red","reduce","reflect","region","relate","relationship",
+    "religious","remain","remember","remove","report","represent","republican",
+    "require","research","resource","respond","response","responsibility","rest",
+    "result","return","reveal","rich","right","rise","risk","road","rock","role",
+    "room","rule","run","safe","same","save","say","scene","school","science",
+    "scientist","score","sea","season","seat","second","section","security","see",
+    "seek","seem","sell","send","senior","sense","series","serious","serve",
+    "service","set","seven","several","shake","share","she","shoot","short","shot",
+    "should","shoulder","show","side","sign","significant","similar","simple",
+    "simply","since","sing","single","sister","sit","site","situation","six","size",
+    "skill","skin","small","smile","so","social","society","soldier","some",
+    "somebody","someone","something","sometimes","son","song","soon","sort","sound",
+    "source","south","southern","space","speak","special","specific","speech",
+    "spend","sport","spring","staff","stage","stand","standard","star","start",
+    "state","statement","station","stay","step","still","stock","stop","store",
+    "story","strategy","street","strong","structure","student","study","stuff",
+    "style","subject","success","successful","such","suddenly","suffer","suggest",
+    "summer","support","sure","surface","system","table","take","talk","task","tax",
+    "teach","teacher","team","technology","television","tell","ten","tend","term",
+    "test","than","thank","that","the","their","them","themselves","then","theory",
+    "there","these","they","thing","think","third","this","those","though","thought",
+    "thousand","threat","three","through","throughout","throw","thus","time","to",
+    "today","together","tonight","too","top","total","tough","toward","town","trade",
+    "traditional","training","travel","treat","treatment","tree","trial","trip",
+    "trouble","true","truth","try","turn","TV","two","type","under","understand",
+    "unit","until","up","upon","us","use","usually","value","various","very",
+    "victim","view","violence","visit","voice","vote","wait","walk","wall","want",
+    "war","watch","water","way","we","weapon","wear","week","weight","well","west",
+    "western","what","whatever","when","where","whether","which","while","white",
+    "who","whole","whom","whose","why","wide","wife","will","win","wind","window",
+    "wish","with","within","without","woman","wonder","word","work","worker","world",
+    "worry","would","write","writer","wrong","yard","yeah","year","yes","yet","you",
+    "young","your","yourself","meshtastic","node","lora","mesh"]
+
+    def __init__(self):
+        self.game = {}
+
+    def new_game(self, id):
+        games = won = 0
+        ret = ""
+        if id in self.game:
+            games = self.game[id]["games"]
+            won = self.game[id]["won"]
+            ret += f"Total Games: {games}, Won: {won}\n"
+
+        self.game[id] = {
+            "word": self.random_word(),
+            "guesses": [],
+            "games": games+1,
+            "won": won
+        }
+        ret += self.game_continue(id)
+        return ret
+
+    def guess(self, id, input):
+        g = self.game[id]
+        if not input:
+            return
+        letter = input[0].lower()
+        if letter.isalpha() and letter not in g["guesses"]:
+            g["guesses"].append(letter)
+
+    def wrong_guesses(self, id):
+        g = self.game[id]
+        wrong = 0
+        for letter in g["guesses"]:
+            if letter not in g["word"]:
+                wrong += 1
+        return wrong
+
+    def won(self, id):
+        g = self.game[id]
+        for letter in g["word"]:
+            if letter not in g["guesses"]:
+                return False
+        return True
+
+    def mask(self, id):
+        g = self.game[id]
+        return " ".join([a if a in g["guesses"] else "_" for a in g["word"]])
+
+    def game_board(self, id):
+        g = self.game[id]
+        emotions = "😀🙂😐😑😕😔💀"
+        wrong = self.wrong_guesses(id)
+        ret = ""
+        if self.won(id):
+            ret += "🥳" + "\n"
+            g["won"] += 1
+        else:
+            ret += emotions[wrong] + "\n"
+        ret += hangman.mask(id) + "\n"
+        if g["guesses"]:
+            ret += ",".join(g["guesses"]) + "\n"
+        return ret
+
+    def game_continue(self, id):
+        return self.game_board(id) + "Guess a letter"
+
+    def game_over(self, id):
+        return self.game_board(id) + "Game over, the word was " + self.game[id]["word"]
+
+    def play(self, id, input):
+        if id not in self.game:
+            return self.new_game(id)
+        self.guess(id, input)
+        wrong = self.wrong_guesses(id)
+        if wrong >= 6 or self.won(id):
+            return self.game_over(id) + "\n" + self.new_game(id)
+        return self.game_continue(id)
+
+    def end(self, id):
+        del self.game[id]
+
+    def random_word(self):
+        return random.choice(self.WORDS)
+
+hangmanTracker = []
+hangman = Hangman()

modules/games/joke.py

@@ -0,0 +1,181 @@
+# This module is used to tell jokes to the user
+# The emoji table of contents is used to replace words in the joke with emojis
+# As a Ham, is this obsecuring the meaning of the joke? Or is it enhancing it?
+from dadjokes import Dadjoke # pip install dadjokes
+import random
+from modules.log import *
+
+lameJokes = [
+    "Why don't scientists trust atoms? Because they make up everything!",
+    "Why did the scarecrow win an award? Because he was outstanding in his field!",
+    "Why don't skeletons fight each other? They don't have the guts.",
+    "What do you call fake spaghetti? An impasta!",
+    "Why did the bicycle fall over? Because it was two-tired!",
+    "Why did the math book look sad? Because it had too many problems.",
+    "Why did the golfer bring two pairs of pants? In case he got a hole in one.",
+    "Why did the coffee file a police report? It got mugged.",
+    "Why did the tomato turn red? Because it saw the salad dressing!",
+    "Why did the cookie go to the doctor? Because it felt crummy.",
+    "Why did the computer go to the doctor? Because it had a virus!",
+    "Why did the chicken join a band? Because it had the drumsticks!",
+    "Why did the banana go to the doctor? Because it wasn't peeling well.",
+    "Why did the cow go to space? To see the moooon!",
+    "Why did the fish blush? Because it saw the ocean's bottom!",
+    "Why did the elephant bring a suitcase to the zoo? Because it wanted to pack its trunk!",
+    "Why did the meshtastic node go to therapy? It had too many connections to handle!",
+    "Why did the meshtastic user bring a ladder to the meeting? To reach new heights in communication!",
+    "Why did the meshtastic device break up with Wi-Fi? It found a better connection!",
+    "Why did the meshtastic network throw a party? Because it wanted to mesh well with everyone!",
+    "Why did the meshtastic node get promoted? Because it was outstanding in its field!",
+    "Why did the meshtastic user bring a map? To navigate the mesh of possibilities!",
+    "Why did the meshtastic device go to school? To improve its signal strength!",
+    "How did the meshtastic node become a comedian? It uses mesh-bots to deliver punchlines!",
+    "Chuck Norris doesn't read books. He stares them down until he gets the information he wants.",
+    "When Chuck Norris enters a room, he doesn't turn the lights on. He turns the dark off.",
+    "Chuck Norris can divide by zero.",
+    "Chuck Norris counted to infinity. Twice.",
+    "Chuck Norris can slam a revolving door.",
+    "When Chuck Norris does a push-up, he isn't lifting himself up; he's pushing the Earth down.",
+    "Chuck Norris can hear sign language.",
+    "Death once had a near-Chuck Norris experience.",
+    "Chuck Norris can unscramble an egg.",
+    "Chuck Norris can win a game of Connect Four in only three moves.",
+    "Chuck Norris can make a snowman out of rain.",
+    "Chuck Norris can strangle you with a cordless phone.",
+    "Chuck Norris can do a wheelie on a unicycle.",
+    "Chuck Norris can kill two stones with one bird.",
+    "Chuck Norris can speak braille.",
+    "Chuck Norris can build a snowman out of rain.",
+    "Chuck Norris can hear sign language.",
+    "Death once had a near-Chuck Norris experience.",
+    "Chuck Norris can unscramble an egg.",
+    "Chuck Norris can win a game of Connect Four in only three moves.",
+    "Chuck Norris can make a snowman out of rain.",
+    "Chuck Norris can strangle you with a cordless phone.",
+    "Chuck Norris can do a wheelie on a unicycle.",
+    "Chuck Norris can kill two stones with one bird."]
+
+imtellingyourightnowiAmTellingYouRightNowThatMotherfErBackThereIsNotReal = ["🐦", "🦅", "🦆", "🦉", "🦜", "🐤", "🐥", "🐣", "🐔", "🐧", "🦚", "🦢", "🦩", "🦤", "🦃", "🐓"]
+
+def tableOfContents():
+    wordToEmojiMap = {
+        'love': '❤️', 'heart': '❤️', 'happy': '😊', 'smile': '😊', 'sad': '😢', 'angry': '😠', 'mad': '😠', 'cry': '😢', 'laugh': '😂', 'funny': '😂', 'cool': '😎',
+        'joy': '😂', 'kiss': '😘', 'hug': '🤗', 'wink': '😉', 'grin': '😁', 'bored': '😐', 'tired': '😴', 'sleepy': '😴', 'shocked': '😲', 'surprised': '😲',
+        'confused': '😕', 'thinking': '🤔', 'sick': '🤢', 'party': '🎉', 'celebrate': '🎉', 'clap': '👏', 'thumbs up': '👍', 'thumbs down': '👎',
+        'ok': '👌', 'wave': '👋', 'pray': '🙏', 'muscle': '💪', 'fire': '🔥', 'star': '⭐', 'sun': '☀️', 'moon': '🌙', 'rain': '🌧️', 'snow': '❄️', 'cloud': '☁️',
+        'dog': '🐶', 'cat': '🐱', 'mouse': '🐭', 'rabbit': '🐰', 'fox': '🦊', 'bear': '🐻', 'panda': '🐼', 'koala': '🐨', 'tiger': '🐯', 'lion': '🦁', 'cow': '🐮',
+        'pig': '🐷', 'frog': '🐸', 'monkey': '🐵', 'chicken': '🐔', 'penguin': '🐧', 'bird': '🐦', 'fish': '🐟', 'whale': '🐋', 'dolphin': '🐬', 'octopus': '🐙',
+        'apple': '🍎', 'orange': '🍊', 'banana': '🍌', 'watermelon': '🍉', 'grape': '🍇', 'strawberry': '🍓', 'cherry': '🍒', 'peach': '🍑', 'pineapple': '🍍', 'mango': '🥭', 'coconut': '🥥',
+        'tomato': '🍅', 'eggplant': '🍆', 'avocado': '🥑', 'broccoli': '🥦', 'cucumber': '🥒', 'corn': '🌽', 'carrot': '🥕', 'potato': '🥔', 'sweet potato': '🍠', 'chili': '🌶️', 'garlic': '🧄',
+        'pizza': '🍕', 'burger': '🍔', 'fries': '🍟', 'hotdog': '🌭', 'popcorn': '🍿', 'donut': '🍩', 'cookie': '🍪', 'cake': '🎂', 'pie': '🍰', 'cupcake': '🧁', 'chocolate': '🍫',
+        'candy': '🍬', 'lollipop': '🍭', 'pudding': '🍮', 'honey': '🍯', 'milk': '🍼', 'coffee': '☕', 'tea': '🍵', 'sake': '🍶', 'beer': '🍺', 'cheers': '🍻', 'champagne': '🥂',
+        'wine': '🍷', 'whiskey': '🥃', 'cocktail': '🍸', 'tropical drink': '🍹', 'bottle': '🍾', 'soda': '🥤', 'chopsticks': '🥢', 'fork': '🍴', 'knife': '🔪', 'spoon': '🥄', 'kitchen knife': '🔪',
+        'house': '🏠', 'home': '🏡', 'office': '🏢', 'post office': '🏣', 'hospital': '🏥', 'bank': '🏦', 'hotel': '🏨', 'love hotel': '🏩', 'convenience store': '🏪', 'school': '🏫', 'department store': '🏬',
+        'factory': '🏭', 'castle': '🏯', 'palace': '🏰', 'church': '💒', 'tower': '🗼', 'statue of liberty': '🗽', 'mosque': '🕌', 'synagogue': '🕍', 'hindu temple': '🛕', 'kaaba': '🕋', 'shinto shrine': '⛩️',
+        'railway': '🛤️', 'highway': '🛣️', 'map': '🗾', 'carousel': '🎠', 'ferris wheel': '🎡', 'roller coaster': '🎢', 'circus': '🎪', 'theater': '🎭', 'art': '🎨', 'slot machine': '🎰', 'dice': '🎲',
+        'bowling': '🎳', 'video game': '🎮', 'dart': '🎯', 'billiard': '🎱', 'medal': '🎖️', 'trophy': '🏆', 'gold medal': '🥇', 'silver medal': '🥈', 'bronze medal': '🥉', 'soccer': '⚽', 'baseball': '⚾',
+        'basketball': '🏀', 'volleyball': '🏐', 'football': '🏈', 'rugby': '🏉', 'tennis': '🎾', 'frisbee': '🥏', 'ping pong': '🏓', 'badminton': '🏸', 'boxing': '🥊', 'martial arts': '🥋',
+        'goal': '🥅', 'golf': '⛳', 'skating': '⛸️', 'fishing': '🎣', 'diving': '🤿', 'running': '🎽', 'skiing': '🎿', 'sledding': '🛷', 'curling': '🥌', 'climbing': '🧗', 'yoga': '🧘',
+        'surfing': '🏄', 'swimming': '🏊', 'water polo': '🤽', 'cycling': '🚴', 'mountain biking': '🚵', 'horse riding': '🏇', 'kneeling': '🧎', 'weightlifting': '🏋️', 'gymnastics': '🤸', 'wrestling': '🤼', 'handball': '🤾',
+        'juggling': '🤹', 'meditation': '🧘', 'sauna': '🧖', 'rock climbing': '🧗', 'stop': '🛑', 'computer': '💻', 'phone': '📱', 'email': '📧', 'camera': '📷', 'video': '📹', 'music': '🎵',
+        'guitar': '🎸', 'piano': '🎹', 'drum': '🥁', 'microphone': '🎤', 'headphone': '🎧', 'book': '📚', 'newspaper': '📰', 'magazine': '📖', 'pen': '🖊️', 'pencil': '✏️', 'paintbrush': '🖌️',
+        'scissors': '✂️', 'ruler': '📏', 'globe': '🌍', 'earth': '🌎', 'star': '🌟', 'comet': '☄️', 'rocket': '🚀', 'airplane': '✈️', 'car': '🚗', 'bus': '🚌', 'train': '🚆',
+        'bicycle': '🚲', 'motorcycle': '🏍️', 'boat': '🚤', 'ship': '🚢', 'helicopter': '🚁', 'tractor': '🚜', 'ambulance': '🚑', 'fire truck': '🚒', 'police car': '🚓', 'taxi': '🚕', 'truck': '🚚',
+        'construction': '🚧', 'traffic light': '🚦', 'stop sign': '🛑', 'fuel': '⛽', 'battery': '🔋', 'light bulb': '💡', 'flashlight': '🔦', 'candle': '🕯️', 'lamp': '🛋️',
+        'bed': '🛏️', 'sofa': '🛋️', 'chair': '🪑', 'table': '🛋️', 'toilet': '🚽', 'shower': '🚿', 'bathtub': '🛁', 'sink': '🚰', 'mirror': '🪞', 'door': '🚪', 'window': '🪟',
+        'key': '🔑', 'lock': '🔒', 'hammer': '🔨', 'wrench': '🔧', 'screwdriver': '🪛', 'saw': '🪚', 'drill': '🛠️', 'toolbox': '🧰', 'paint roller': '🖌️', 'brush': '🖌️', 'broom': '🧹',
+        'mop': '🧽', 'bucket': '🪣', 'vacuum': '🧹', 'washing machine': '🧺', 'dryer': '🧺', 'iron': '🧺', 'hanger': '🧺', 'laundry': '🧺', 'basket': '🧺', 'trash': '🗑️', 'recycle': '♻️',
+        'plant': '🌱', 'tree': '🌳', 'flower': '🌸', 'leaf': '🍃', 'cactus': '🌵', 'mushroom': '🍄', 'herb': '🌿', 'bamboo': '🎍', 'rose': '🌹', 'tulip': '🌷', 'sunflower': '🌻',
+        'hibiscus': '🌺', 'cherry blossom': '🌸', 'bouquet': '💐', 'seedling': '🌱', 'palm tree': '🌴', 'evergreen tree': '🌲', 'deciduous tree': '🌳', 'fallen leaf': '🍂', 'maple leaf': '🍁',
+        'ear of rice': '🌾', 'shamrock': '☘️', 'four leaf clover': '🍀', 'grapes': '🍇', 'melon': '🍈', 'watermelon': '🍉', 'tangerine': '🍊', 'lemon': '🍋', 'banana': '🍌', 'pineapple': '🍍',
+        'mango': '🥭', 'apple': '🍎', 'green apple': '🍏', 'pear': '🍐', 'peach': '🍑', 'cherries': '🍒', 'strawberry': '🍓', 'kiwi': '🥝', 'tomato': '🍅', 'coconut': '🥥', 'avocado': '🥑',
+        'eggplant': '🍆', 'potato': '🥔', 'carrot': '🥕', 'corn': '🌽', 'hot pepper': '🌶️', 'cucumber': '🥒', 'leafy green': '🥬', 'broccoli': '🥦', 'garlic': '🧄', 'onion': '🧅',
+        'peanuts': '🥜', 'chestnut': '🌰', 'bread': '🍞', 'croissant': '🥐', 'baguette': '🥖', 'flatbread': '🥙', 'pretzel': '🥨', 'bagel': '🥯', 'pancakes': '🥞', 'waffle': '🧇', 'cheese': '🧀',
+        'meat': '🍖', 'poultry': '🍗', 'bacon': '🥓', 'hamburger': '🍔', 'fries': '🍟', 'pizza': '🍕', 'hot dog': '🌭', 'sandwich': '🥪', 'taco': '🌮', 'burrito': '🌯', 'tamale': '🫔',
+        'stuffed flatbread': '🥙', 'falafel': '🧆', 'egg': '🥚', 'fried egg': '🍳', 'shallow pan of food': '🥘', 'pot of food': '🍲', 'fondue': '🫕', 'bowl with spoon': '🥣', 'green salad': '🥗',
+        'popcorn': '🍿', 'butter': '🧈', 'salt': '🧂', 'canned food': '🥫', 'bento box': '🍱', 'rice cracker': '🍘', 'rice ball': '🍙', 'cooked rice': '🍚', 'curry rice': '🍛', 'steaming bowl': '🍜',
+        'spaghetti': '🍝', 'roasted sweet potato': '🍠', 'oden': '🍢', 'sushi': '🍣', 'fried shrimp': '🍤', 'fish cake': '🍥', 'moon cake': '🥮', 'dango': '🍡', 'dumpling': '🥟', 'fortune cookie': '🥠',
+        'takeout box': '🥡', 'crab': '🦀', 'lobster': '🦞', 'shrimp': '🦐', 'squid': '🦑', 'oyster': '🦪', 'ice cream': '🍨', 'shaved ice': '🍧', 'ice cream cone': '🍦', 'doughnut': '🍩', 'cookie': '🍪',
+        'birthday cake': '🎂', 'shortcake': '🍰', 'cupcake': '🧁', 'pie': '🥧', 'chocolate bar': '🍫', 'candy': '🍬', 'lollipop': '🍭', 'custard': '🍮', 'honey pot': '🍯', 'baby bottle': '🍼',
+        'glass of milk': '🥛', 'hot beverage': '☕', 'teapot': '🫖', 'teacup without handle': '🍵', 'sake': '🍶', 'bottle with popping cork': '🍾', 'wine glass': '🍷', 'cocktail glass': '🍸', 'tropical drink': '🍹',
+        'beer mug': '🍺', 'clinking beer mugs': '🍻', 'clinking glasses': '🥂', 'tumbler glass': '🥃', 'cup with straw': '🥤', 'bubble tea': '🧋', 'beverage box': '🧃', 'mate': '🧉', 'ice': '🧊',
+        'chopsticks': '🥢', 'fork and knife': '🍴', 'spoon': '🥄', 'kitchen knife': '🔪', 'amphora': '🏺', 'globe showing Europe-Africa': '🌍', 'globe showing Americas': '🌎', 'globe showing Asia-Australia': '🌏',
+        'globe with meridians': '🌐', 'world map': '🗺️', 'mountain': '⛰️', 'volcano': '🌋', 'mount fuji': '🗻', 'camping': '🏕️', 'beach with umbrella': '🏖️', 'desert': '🏜️', 'desert island': '🏝️',
+        'national park': '🏞️', 'stadium': '🏟️', 'classical building': '🏛️', 'building construction': '🏗️', 'brick': '🧱', 'rock': '🪨', 'wood': '🪵', 'hut': '🛖', 'houses': '🏘️', 'derelict house': '🏚️',
+        'house with garden': '🏡', 'office building': '🏢', 'japanese post office': '🏣', 'post office': '🏤', 'hospital': '🏥', 'bank': '🏦', 'hotel': '🏨', 'love hotel': '🏩', 'convenience store': '🏪',
+        'school': '🏫', 'department store': '🏬', 'factory': '🏭', 'japanese castle': '🏯', 'castle': '🏰', 'wedding': '💒', 'tokyo tower': '🗼', 'statue of liberty': '🗽', 'church': '⛪', 'mosque': '🕌',
+        'hindu temple': '🛕', 'synagogue': '🕍', 'shinto shrine': '⛩️', 'kaaba': '🕋', 'fountain': '⛲', 'tent': '⛺', 'foggy': '🌁', 'night with stars': '🌃', 'sunrise over mountains': '🌄', 'sunrise': '🌅',
+        'cityscape at dusk': '🌆', 'sunset': '🌇', 'cityscape': '🏙️', 'bridge at night': '🌉', 'hot springs': '♨️', 'carousel horse': '🎠', 'ferris wheel': '🎡', 'roller coaster': '🎢', 'barber pole': '💈',
+        'robot': '🤖', 'alien': '👽', 'ghost': '👻', 'skull': '💀', 'pumpkin': '🎃', 'clown': '🤡', 'wizard': '🧙', 'elf': '🧝', 'fairy': '🧚', 'mermaid': '🧜', 'vampire': '🧛',
+        'zombie': '🧟', 'genie': '🧞', 'superhero': '🦸', 'supervillain': '🦹', 'mage': '🧙', 'knight': '🛡️', 'ninja': '🥷', 'pirate': '🏴‍☠️', 'angel': '👼', 'devil': '😈', 'dragon': '🐉',
+        'unicorn': '🦄', 'phoenix': '🦅', 'griffin': '🦅', 'centaur': '🐎', 'minotaur': '🐂', 'cyclops': '👁️', 'medusa': '🐍', 'sphinx': '🦁', 'kraken': '🦑', 'yeti': '❄️', 'sasquatch': '🦧',
+        'loch ness monster': '🦕', 'chupacabra': '🐐', 'banshee': '👻', 'golem': '🗿', 'djinn': '🧞', 'basilisk': '🐍', 'hydra': '🐉', 'cerberus': '🐶', 'chimera': '🐐', 'manticore': '🦁', 'wyvern': '🐉',
+        'pegasus': '🦄', 'hippogriff': '🦅', 'kelpie': '🐎', 'selkie': '🦭', 'kitsune': '🦊', 'tanuki': '🦝', 'tengu': '🦅', 'oni': '👹', 'yokai': '👻', 'kappa': '🐢', 'yurei': '👻',
+        'kami': '👼', 'shinigami': '💀', 'bakemono': '👹', 'tsukumogami': '🧸', 'noppera-bo': '👤', 'rokurokubi': '🧛', 'yuki-onna': '❄️', 'jorogumo': '🕷️', 'nue': '🐍', 'ubume': '👼',
+        'atom': '⚛️', 'dna': '🧬', 'microscope': '🔬', 'telescope': '🔭', 'rocket': '🚀', 'satellite': '🛰️', 'spaceship': '🛸', 'planet': '🪐', 'black hole': '🕳️', 'galaxy': '🌌',
+        'comet': '☄️', 'constellation': '🌠', 'lightning': '⚡', 'magnet': '🧲', 'battery': '🔋', 'computer': '💻', 'keyboard': '⌨️', 'mouse': '🖱️', 'printer': '🖨️', 'floppy disk': '💾',
+        'cd': '💿', 'dvd': '📀', 'smartphone': '📱', 'tablet': '📲', 'watch': '⌚', 'camera': '📷', 'video camera': '📹', 'projector': '📽️', 'radio': '📻', 'television': '📺',
+        'satellite dish': '📡', 'game controller': '🎮', 'joystick': '🕹️', 'vr headset': '🕶️', 'headphones': '🎧', 'speaker': '🔊', 'flashlight': '🔦', 'circuit': '🔌', 'chip': '💻',
+        'server': '🖥️', 'database': '💾', 'cloud': '☁️', 'network': '🌐', 'code': '💻', 'bug': '🐛', 'virus': '🦠', 'bacteria': '🦠', 'lab coat': '🥼', 'safety goggles': '🥽',
+        'test tube': '🧪', 'petri dish': '🧫', 'beaker': '🧪', 'bunsen burner': '🔥', 'graduated cylinder': '🧪', 'pipette': '🧪', 'scalpel': '🔪', 'syringe': '💉', 'pill': '💊',
+        'stethoscope': '🩺', 'thermometer': '🌡️', 'x-ray': '🩻', 'brain': '🧠', 'heart': '❤️', 'lung': '🫁', 'bone': '🦴', 'muscle': '💪', 'robot arm': '🦾', 'robot leg': '🦿',
+        'prosthetic arm': '🦾', 'prosthetic leg': '🦿', 'wheelchair': '🦽', 'crutch': '🦯', 'hearing aid': '🦻', 'glasses': '👓', 'magnifying glass': '🔍', 'circus tent': '🎪',
+        'duck': '🦆', 'eagle': '🦅', 'owl': '🦉', 'bat': '🦇', 'shark': '🦈', 'butterfly': '🦋', 'snail': '🐌', 'bee': '🐝', 'beetle': '🐞', 'ant': '🐜', 'cricket': '🦗', 
+        'spider': '🕷️', 'scorpion': '🦂', 'turkey': '🦃', 'peacock': '🦚', 'parrot': '🦜', 'swan': '🦢', 'flamingo': '🦩', 'dodo': '🦤', 'sloth': '🦥', 'otter': '🦦', 
+        'skunk': '🦨', 'kangaroo': '🦘', 'badger': '🦡', 'beaver': '🦫', 'bison': '🦬', 'mammoth': '🦣', 'raccoon': '🦝', 'hedgehog': '🦔', 'squirrel': '🐿️', 'chipmunk': '🐿️', 
+        'porcupine': '🦔', 'llama': '🦙', 'giraffe': '🦒', 'zebra': '🦓', 'hippopotamus': '🦛', 'rhinoceros': '🦏', 'gorilla': '🦍', 'orangutan': '🦧', 'elephant': '🐘', 'camel': '🐫', 
+        'llama': '🦙', 'alpaca': '🦙', 'buffalo': '🐃', 'ox': '🐂', 'deer': '🦌', 'moose': '🦌', 'reindeer': '🦌', 'goat': '🐐', 'sheep': '🐑', 'ram': '🐏', 'lamb': '🐑', 'horse': '🐴', 
+        'unicorn': '🦄', 'zebra': '🦓', 'cow': '🐄', 'pig': '🐖', 'boar': '🐗', 'mouse': '🐁', 'rat': '🐀', 'hamster': '🐹', 'rabbit': '🐇', 'chipmunk': '🐿️', 'beaver': '🦫', 'hedgehog': '🦔', 
+        'bat': '🦇', 'bear': '🐻', 'koala': '🐨', 'panda': '🐼', 'sloth': '🦥', 'otter': '🦦', 'skunk': '🦨', 'kangaroo': '🦘', 'badger': '🦡', 'turkey': '🦃', 'chicken': '🐔', 'rooster': '🐓', 
+        'peacock': '🦚', 'parrot': '🦜', 'swan': '🦢', 'flamingo': '🦩', 'dodo': '🦤', 'crocodile': '🐊', 'turtle': '🐢', 'lizard': '🦎', 'snake': '🐍', 'dragon': '🐉', 'sauropod': '🦕', 't-rex': '🦖', 
+        'whale': '🐋', 'dolphin': '🐬', 'fish': '🐟', 'blowfish': '🐡', 'shark': '🦈', 'octopus': '🐙', 'shell': '🐚', 'crab': '🦀', 'lobster': '🦞', 'shrimp': '🦐', 'squid': '🦑', 'snail': '🐌', 'butterfly': '🦋', 
+        'bee': '🐝', 'beetle': '🐞', 'ant': '🐜', 'cricket': '🦗', 'spider': '🕷️', 'scorpion': '🦂', 'mosquito': '🦟', 'microbe': '🦠', 'locomotive': '🚂', 'arm': '💪', 'leg': '🦵', 'sponge': '🧽',
+        'toothbrush': '🪥', 'broom': '🧹', 'basket': '🧺', 'roll of paper': '🧻', 'bucket': '🪣', 'soap': '🧼', 'toilet paper': '🧻', 'shower': '🚿', 'bathtub': '🛁', 'razor': '🪒', 'lotion': '🧴',
+        'letter': '✉️', 'envelope': '✉️', 'mail': '📬', 'post': '📮', 'golf': '⛳️', 'golfing': '⛳️', 'office': '🏢', 'meeting': '📅', 'presentation': '📊', 'report': '📄', 'document': '📄',
+        'file': '📁', 'folder': '📂', 'sports': '🏅', 'athlete': '🏃', 'competition': '🏆', 'race': '🏁', 'tournament': '🏆', 'champion': '🏆', 'medal': '🏅', 'victory': '🏆', 'win': '🏆', 'lose': '😞',
+        'draw': '🤝', 'team': '👥', 'player': '👤', 'coach': '👨‍🏫', 'referee': '🧑‍⚖️', 'stadium': '🏟️', 'arena': '🏟️', 'field': '🏟️', 'court': '🏟️', 'track': '🏟️', 'gym': '🏋️', 'fitness': '🏋️', 'exercise': '🏋️', 
+        'workout': '🏋️', 'training': '🏋️', 'practice': '🏋️', 'game': '🎮', 'match': '🎮', 'score': '🏅', 'goal': '🥅', 'point': '🏅', 'basket': '🏀', 'home run': '⚾️', 'strike': '🎳', 'spare': '🎳', 'frame': '🎳', 
+        'inning': '⚾️', 'quarter': '🏈', 'half': '🏈', 'overtime': '🏈', 'penalty': '⚽️', 'foul': '⚽️', 'timeout': '⏱️', 'substitute': '🔄', 'bench': '🪑', 'sideline': '🏟️', 'dugout': '⚾️', 'locker room': '🚪', 'shower': '🚿', 
+        'uniform': '👕', 'jersey': '👕', 'cleats': '👟', 'helmet': '⛑️', 'pads': '🛡️', 'gloves': '🧤', 'bat': '⚾️', 'ball': '⚽️', 'puck': '🏒', 'stick': '🏒', 'net': '🥅', 'hoop': '🏀', 'goalpost': '🥅', 'whistle': '🔔', 
+        'scoreboard': '📊', 'fans': '👥', 'crowd': '👥', 'cheer': '📣', 'boo': '😠', 'applause': '👏', 'celebration': '🎉', 'parade': '🎉', 'trophy': '🏆', 'medal': '🏅', 'ribbon': '🎀', 'cup': '🏆', 'championship': '🏆', 
+        'league': '🏆', 'season': '🏆', 'playoffs': '🏆', 'finals': '🏆', 'champion': '🏆', 'runner-up': '🥈', 'third place': '🥉', 'snowman': '☃️', 'snowmen': '⛄️'
+    }
+
+    return wordToEmojiMap
+
+def sendWithEmoji(message):
+    # this will take a string of text and replace any word or phrase that is in the word list with the corresponding emoji
+    wordToEmojiMap = tableOfContents()
+    # type format to clean it up
+    words = message.split()
+    i = 0
+    while i < len(words):
+        for phrase in sorted(wordToEmojiMap.keys(), key=len, reverse=True):
+            phrase_words = phrase.split()
+            # Strip punctuation from the words
+            stripped_words = [word.lower().strip('.,!?') for word in words[i:i+len(phrase_words)]]
+            if stripped_words == phrase_words:
+                logger.debug(f"System: Replaced the phrase '{phrase}' with '{wordToEmojiMap[phrase]}'")
+                words[i:i+len(phrase_words)] = [wordToEmojiMap[phrase]]
+                i += len(phrase_words) - 1
+                break
+            # Check for plural forms
+            elif stripped_words == [word + 's' for word in phrase_words]:
+                logger.debug(f"System: Replaced the plural phrase '{' '.join([word + 's' for word in phrase_words])}' with '{wordToEmojiMap[phrase]}'")
+                words[i:i+len(phrase_words)] = [wordToEmojiMap[phrase]]
+                i += len(phrase_words) - 1
+                break
+        i += 1
+    return ' '.join(words)
+
+def tell_joke(nodeID=0, vox=False):
+    dadjoke = Dadjoke()
+    try:
+        if dad_jokes_emojiJokes or vox:
+            renderedLaugh = sendWithEmoji(dadjoke.joke)
+        else:
+            renderedLaugh = dadjoke.joke
+        return renderedLaugh
+    except Exception as e:
+        return random.choice(lameJokes)
+        

modules/games/lemonade.py

@@ -18,12 +18,12 @@ locale.setlocale(locale.LC_ALL, '')
 lemon_starting_cash = 30.00
 lemon_total_weeks = 7
 
-lemonadeTracker = [{'nodeID': 0, 'cups': 0, 'lemons': 0, 'sugar': 0, 'cash': lemon_starting_cash, 'start': lemon_starting_cash, 'cmd': 'new', 'time': time.time()}]
 lemonadeCups = [{'nodeID': 0, 'cost': 2.50, 'count': 25, 'min': 0.99, 'unit': 0.00}]
 lemonadeLemons = [{'nodeID': 0, 'cost': 4.00, 'count': 8, 'min': 2.00, 'unit': 0.00}]
 lemonadeSugar = [{'nodeID': 0, 'cost': 3.00, 'count': 15, 'min': 1.50, 'unit': 0.00}]
-lemonadeWeeks = [{'nodeID': 0, 'current': 1, 'total': lemon_total_weeks, 'sales': 99, 'potential': 0, 'unit': 0.00, 'price': 0.00}]
+lemonadeWeeks = [{'nodeID': 0, 'current': 1, 'total': lemon_total_weeks, 'sales': 99, 'potential': 0, 'unit': 0.00, 'price': 0.00, 'total_sales': 0}]
 lemonadeScore = [{'nodeID': 0, 'value': 0.00, 'total': 0.00}]
+from modules.settings import lemonadeTracker
 
 def get_sales_amount(potential, unit, price):
     """Gets the sales amount.
@@ -41,24 +41,27 @@ def getHighScoreLemon():
     high_score = {"userID": 0, "cash": 0, "success": 0}
     # Load high score table
     try:
-        with open('lemonade_hs.pkl', 'rb') as file:
+        with open('data/lemonstand.pkl', 'rb') as file:
             high_score = pickle.load(file)
     except FileNotFoundError:
         logger.debug("System: Lemonade: No high score table found")
         # write a new high score file if one is not found
-        with open('lemonade_hs.pkl', 'wb') as file:
+        with open('data/lemonstand.pkl', 'wb') as file:
             pickle.dump(high_score, file)
     return high_score
 
-def start_lemonade(nodeID, message, celsius=False):
+def playLemonstand(nodeID, message, celsius=False, newgame=False):
     global lemonadeTracker, lemonadeCups, lemonadeLemons, lemonadeSugar, lemonadeWeeks, lemonadeScore
+    msg = ""
     potential = 0
     unit = 0.0
     price = 0.0
+    total_sales = 0
+    lemonsLastCmd = ''
 
     high_score = getHighScoreLemon()
 
-    def saveValues():
+    def saveValues(nodeID, inventory, cups, lemons, sugar, weeks, score):
         # save playerDB values
         for i in range(len(lemonadeTracker)):
             if lemonadeTracker[i]['nodeID'] == nodeID:
@@ -87,38 +90,12 @@ def start_lemonade(nodeID, message, celsius=False):
                 lemonadeWeeks[i]['potential'] = potential
                 lemonadeWeeks[i]['unit'] = unit
                 lemonadeWeeks[i]['price'] = price
+                lemonadeWeeks[i]['total_sales'] = weeks.total_sales
         for i in range(len(lemonadeScore)):
             if lemonadeScore[i]['nodeID'] == nodeID:
                 lemonadeScore[i]['value'] = score.value
                 lemonadeScore[i]['total'] = score.total
 
-    def endGame(nodeID):
-        # remove the player from the tracker
-        for i in range(len(lemonadeTracker)):
-            if lemonadeTracker[i]['nodeID'] == nodeID:
-                lemonadeTracker.pop(i)
-        for i in range(len(lemonadeCups)):
-            if lemonadeCups[i]['nodeID'] == nodeID:
-                lemonadeCups.pop(i)
-        for i in range(len(lemonadeLemons)):
-            if lemonadeLemons[i]['nodeID'] == nodeID:
-                lemonadeLemons.pop(i)
-        for i in range(len(lemonadeSugar)):
-            if lemonadeSugar[i]['nodeID'] == nodeID:
-                lemonadeSugar.pop(i)
-        for i in range(len(lemonadeWeeks)):
-            if lemonadeWeeks[i]['nodeID'] == nodeID:
-                lemonadeWeeks.pop(i)
-        for i in range(len(lemonadeScore)):
-            if lemonadeScore[i]['nodeID'] == nodeID:
-                lemonadeScore.pop(i)
-        logger.debug("System: Lemonade: Game Over for " + str(nodeID))
-
-    # Check for end of game
-    if "end" in message.lower():
-        endGame(nodeID)
-        return "Goodbye!👋"
-
     title="LemonStand🍋"
     # Define the temperature unit symbols
     fahrenheit_unit = "ºF"
@@ -169,6 +146,7 @@ def start_lemonade(nodeID, message, celsius=False):
         'current' : 1,   # start with the 1st week
         'total'   : 12,  # span the 12 weeks of Summer
         'sales'   : 99,  # 99 maximum sales per week
+        'total_sales' : 0, # total sales
         'summary' : []   # empty array
     }
     weeks = SimpleNamespace(**weeksd)
@@ -210,7 +188,7 @@ def start_lemonade(nodeID, message, celsius=False):
             inventory.sugar = lemonadeTracker[i]['sugar']
             inventory.cash = lemonadeTracker[i]['cash']
             inventory.start = lemonadeTracker[i]['start']
-            last_cmd = lemonadeTracker[i]['cmd']
+            lemonsLastCmd = lemonadeTracker[i]['cmd']
     for i in range(len(lemonadeCups)):
         if lemonadeCups[i]['nodeID'] == nodeID:
             cups.cost = lemonadeCups[i]['cost']
@@ -231,21 +209,40 @@ def start_lemonade(nodeID, message, celsius=False):
             potential = lemonadeWeeks[i]['potential']
             unit = lemonadeWeeks[i]['unit']
             price = lemonadeWeeks[i]['price']
+            weeks.total_sales = lemonadeWeeks[i]['total_sales']
     for i in range(len(lemonadeScore)):
         if lemonadeScore[i]['nodeID'] == nodeID:
             score.value = lemonadeScore[i]['value']
             score.total = lemonadeScore[i]['total']
-
-    logger.debug("System: Lemonade: Last Command: " + last_cmd)
-
+    if (newgame):
+        # reset the game values
+        inventory.cups = 0
+        inventory.lemons = 0
+        inventory.sugar = 0
+        inventory.cash = lemon_starting_cash
+        inventory.start = lemon_starting_cash
+        cups.cost = 2.50
+        cups.unit = round(cups.cost / cups.count, 2)
+        lemons.cost = 4.00
+        lemons.unit = round(lemons.cost / lemons.count, 2)
+        sugar.cost = 3.00
+        sugar.unit = round(sugar.cost / sugar.count, 2)
+        weeks.current = 1
+        weeks.total_sales = 0
+        weeks.summary = []
+        score.value = 0.00
+        score.total = 0.00
+        lemonsLastCmd = "cups"
+        # set the last command to new in the inventory db
+        for i in range(len(lemonadeTracker)):
+            if lemonadeTracker[i]['nodeID'] == nodeID:
+                lemonadeTracker[i]['cmd'] = "cups"
+                lemonadeTracker[i]['last_played'] = time.time()
+        saveValues(nodeID, inventory, cups, lemons, sugar, weeks, score)
     # Start the main loop
     if (weeks.current <= weeks.total):
-
-        if "new" in last_cmd:
-            # set the last command to cups in the inventory db
-            for i in range(len(lemonadeTracker)):
-                if lemonadeTracker[i]['nodeID'] == nodeID:
-                    lemonadeTracker[i]['cmd'] = "cups"
+        if newgame or "new" in lemonsLastCmd:
+            logger.debug("System: Lemonade: New Game: " + str(nodeID))
             # Create a new display buffer for the text messages
             buffer= ""
     
@@ -262,7 +259,7 @@ def start_lemonade(nodeID, message, celsius=False):
             buffer += ". " + \
                         formatted + temperature.units + " " + \
                         forecastd[list(forecastd)[temperature.forecast]][2] + \
-                        " " + glyph
+                        " " + glyph + f"\n"
 
             # Calculate the potential sales as a percentage of the maximum value
             # (lower temperature = fewer sales, severe weather = fewer sales)
@@ -290,44 +287,39 @@ def start_lemonade(nodeID, message, celsius=False):
             sugar.unit = round(sugar.cost / sugar.count, 2)
 
             # Calculate the unit cost and display the estimated sales from the forecast potential
-            unit = cups.unit + lemons.unit + sugar.unit
-            buffer += " SupplyCost" + locale.currency(unit, grouping=True) + " a cup."
-            buffer += " Sales Potential:" + str(potential) + " cups."
+            unit = max(0.01, min(cups.unit + lemons.unit + sugar.unit, 4.0))  # limit the unit cost between $0.01 and $4.00
+            buffer += f"\nSupplyCost" + locale.currency(round(unit, 2), grouping=True) + " a cup."
+            buffer += f"\nSales Potential:" + str(potential) + " cups."
 
             # Display the current inventory
-            buffer += " Inventory:"
+            buffer += f"\nInventory:"
             buffer += "🥤:" + str(inventory.cups)
             buffer += "🍋:" + str(inventory.lemons)
             buffer += "🍚:" + str(inventory.sugar)
 
             # Display the updated item prices
-            buffer += f"\nPrices: "
-            buffer += "🥤:" + \
-                        locale.currency(cups.cost, grouping=True) + " 📦 of " + str(cups.count) + "."
-            buffer += " 🍋:" + \
-                        locale.currency(lemons.cost, grouping=True) + " 🧺 of " + str(lemons.count) + "."
-            buffer += " 🍚:" + \
-                        locale.currency(sugar.cost, grouping=True) + " bag for " + str(sugar.count) + "🥤."
-
+            buffer += f"\nPrices:\n"
+            buffer += f"\n🥤:" + locale.currency(round(cups.cost, 2), grouping=True) + " 📦 of " + str(cups.count) + "."
+            buffer += f"\n🍋:" + locale.currency(round(lemons.cost, 2), grouping=True) + " 🧺 of " + str(lemons.count) + "."
+            buffer += f"\n🍚:" + locale.currency(round(sugar.cost, 2), grouping=True) + " bag for " + str(sugar.count) + "🥤."
             # Display the current cash
             gainloss   = inventory.cash - inventory.start
-            buffer += " 💵:" + \
-                        locale.currency(inventory.cash, grouping=True)
+            buffer += f"\n💵:" + locale.currency(round(inventory.cash, 2), grouping=True)
             
             
             # if the player is in the red
-            pnl = locale.currency(gainloss, grouping=True)
+            pnl = locale.currency(round(gainloss, 2), grouping=True)
             if "0.00" not in pnl:
                 if pnl.startswith("-"):
                     buffer += "📊P&L📉" + pnl
                 else:
                     buffer += "📊P&L📈" + pnl
 
-            buffer += f"\n🥤 to buy? Have {inventory.cups} Cost {locale.currency(cups.cost, grouping=True)} a 📦 of {str(cups.count)}"
-            saveValues()
+            buffer += f"\n🥤 to buy?\nHave {inventory.cups} Cost {locale.currency(cups.cost, grouping=True)} a 📦 of {str(cups.count)}"
+            saveValues(nodeID, inventory, cups, lemons, sugar, weeks, score)
             return buffer
         
-        if "cups" in last_cmd:
+        if "cups" in lemonsLastCmd and not newgame:
             # Read the number of cup boxes to purchase
             newcups = -1
             if "n" in message.lower():
@@ -341,22 +333,22 @@ def start_lemonade(nodeID, message, celsius=False):
                     inventory.cups += (newcups * cups.count)
                     inventory.cash -= cost
                     msg = "Purchased " + str(newcups) + " 📦 "
-                    msg += str(inventory.cups) + " 🥤  in inventory. "  + locale.currency(inventory.cash, grouping=True) + f" remaining"
+                    msg += str(inventory.cups) + " 🥤  in inventory. "  + locale.currency(round(inventory.cash, 2), grouping=True) + f" remaining"
                 else:
                     msg =  "No 🥤 were purchased"
             except Exception as e:
                 return "invalid input, enter the number of 🥤 to purchase or (N)one"
                 
+            msg += f"\n 🍋 to buy?\nHave {inventory.lemons}🥤 of 🍋 Cost {locale.currency(lemons.cost, grouping=True)} a 🧺 for {str(lemons.count)}🥤"
             # set the last command to lemons in the inventory db
             for i in range(len(lemonadeTracker)):
                 if lemonadeTracker[i]['nodeID'] == nodeID:
                     lemonadeTracker[i]['cmd'] = "lemons"
-            saveValues()
-            msg += f"\n 🍋 to buy? Have {inventory.lemons}🥤 of 🍋 Cost {locale.currency(lemons.cost, grouping=True)} a 🧺 for {str(lemons.count)}🥤"
+            saveValues(nodeID, inventory, cups, lemons, sugar, weeks, score)
             return msg
                 
 
-        if "lemons" in last_cmd:
+        if "lemons" in lemonsLastCmd and not newgame:
             # Read the number of lemon bags to purchase
             newlemons = -1
             if "n" in message.lower():
@@ -377,15 +369,15 @@ def start_lemonade(nodeID, message, celsius=False):
                 newlemons = -1
                 return "⛔️invalid input, enter the number of 🍋 to purchase"
                 
+            msg += f"\n 🍚 to buy?\nYou have {inventory.sugar}🥤 of 🍚, Cost {locale.currency(sugar.cost, grouping=True)} a bag for {str(sugar.count)}🥤"
             # set the last command to sugar in the inventory db
             for i in range(len(lemonadeTracker)):
                 if lemonadeTracker[i]['nodeID'] == nodeID:
                     lemonadeTracker[i]['cmd'] = "sugar"
-            saveValues()
-            msg += f"\n 🍚 to buy? You have {inventory.sugar}🥤 of 🍚, Cost {locale.currency(sugar.cost, grouping=True)} a bag for {str(sugar.count)}🥤"
+            saveValues(nodeID, inventory, cups, lemons, sugar, weeks, score)
             return msg
 
-        if "sugar" in last_cmd:
+        if "sugar" in lemonsLastCmd and not newgame:
             # Read the number of sugar bags to purchase
             newsugar = -1
             if "n" in message.lower():
@@ -405,28 +397,28 @@ def start_lemonade(nodeID, message, celsius=False):
             except Exception as e:
                 return "⛔️invalid input, enter the number of 🍚 bags to purchase"
 
-            msg += f"Cost of goods is {locale.currency(unit, grouping=True)}"
-            msg += f"per 🥤 {locale.currency(inventory.cash, grouping=True)} 💵 remaining."
+            msg += f"Cost of goods is {locale.currency(round(unit, 2), grouping=True)}"
+            msg += f"per 🥤 {locale.currency(round(inventory.cash, 2), grouping=True)} 💵 remaining."
             msg += f"\nPrice to Sell? or (G)rocery to buy more 🥤🍋🍚"
 
             # set the last command to price in the inventory db
             for i in range(len(lemonadeTracker)):
                 if lemonadeTracker[i]['nodeID'] == nodeID:
                     lemonadeTracker[i]['cmd'] = "price"
-            saveValues()
+            saveValues(nodeID, inventory, cups, lemons, sugar, weeks, score)
             return msg
     
-        if "price" in last_cmd:
+        if "price" in lemonsLastCmd and not newgame:
             # set the last command to sales in the inventory db
             for i in range(len(lemonadeTracker)):
                 if lemonadeTracker[i]['nodeID'] == nodeID:
                     lemonadeTracker[i]['cmd'] = "sales"
                     if "g" in message.lower():
                         lemonadeTracker[i]['cmd'] = "cups"
-                        msg = f"#of🥤 to buy? Have {inventory.cups} Cost {locale.currency(cups.cost, grouping=True)} a 📦 of {str(cups.count)}"
+                        msg = f"#of🥤\nto buy? Have {inventory.cups} Cost {locale.currency(cups.cost, grouping=True)} a 📦 of {str(cups.count)}"
                         return msg
                     else:
-                        last_cmd = "sales"
+                        lemonsLastCmd = "sales"
             
             # Read the actual price
             price = 0.00
@@ -438,14 +430,15 @@ def start_lemonade(nodeID, message, celsius=False):
                         return "The price must be greater than zero."
                 except Exception as e:
                     price = 0.00
+                    lemonsLastCmd = "price"
                     return "⛔️Invalid input, enter the price of the lemonade per 🥤"
             
             # this isnt sent to the user, not needed
             #msg = "  Setting the price at " + locale.currency(price, grouping=True)
-            saveValues()
+            saveValues(nodeID, inventory, cups, lemons, sugar, weeks, score)
         
 
-        if "sales" in last_cmd:
+        if "sales" in lemonsLastCmd and not newgame:
             # Calculate the weekly sales based on price and lowest inventory level
             # (higher markup price = fewer sales, limited by the inventory on-hand)
             sales  = get_sales_amount(potential, unit, price)
@@ -475,7 +468,7 @@ def start_lemonade(nodeID, message, celsius=False):
             msg += " N.Profit:" + locale.currency(net, grouping=True)
 
             # Display the updated inventory levels
-            msg += "\nRemaining"
+            msg += f"\nRemaining"
             msg += " 🥤:" + str(inventory.cups)
             msg += " 🍋:" + str(inventory.lemons)
             msg += " 🍚:" + str(inventory.sugar)
@@ -491,13 +484,16 @@ def start_lemonade(nodeID, message, celsius=False):
             # Display the weekly sales summary
             pad_week = len(str(weeks.total))
             pad_sale = len(str(weeks.sales))
-            total    = 0
-            msg += "\nWeekly📊"
+            total = 0
+            msg += f"\nWeekly📊"
             for i in range(len(weeks.summary)):
                 msg += "#" + str(weeks.current).rjust(pad_week) + ".  " + str(weeks.summary[i]['sales']).rjust(pad_sale) + \
                     " sold x " + locale.currency(weeks.summary[i]['price'], grouping=True) + "ea. "
                 total = total + weeks.summary[i]['sales']
 
+            # Update the total sales for the game
+            weeks.total_sales += total
+            
             # Loop through a range of prices to find the highest net profit
             maxsales = 0
             maxprice = 0.00
@@ -529,41 +525,43 @@ def start_lemonade(nodeID, message, celsius=False):
                 if (inventory.sugar <= 0):
                     msg += " You ran out of sugar.🍚"
             else:
-                msg += "\nCongratulations 🍋🍋 your sales were perfect!🎉"
+                msg += f"\nCongratulations 🍋🍋 your sales were perfect!🎉"
             
             # Increment the score counters
             score.value = score.value + minnet
             score.total = score.total + maxnet
 
+
             # Increment the week number
             if (weeks.current == weeks.total):
                 # end of the game
                 success = round((score.value / score.total) * 100)
-                msg += "\nYou've made " + locale.currency(score.value, grouping=True) + " out of a possible " + \
+                msg += f"\nYou've made " + locale.currency(score.value, grouping=True) + " out of a possible " + \
                     locale.currency(score.total, grouping=True) + " for a score of " + str(success) + "% "
-                msg += "You've sold " + str(total) + " total 🥤🍋"
+                msg += f"\nYou've sold " + str(weeks.total_sales) + " total 🥤🍋"
 
                 # check for high score
                 high_score = getHighScoreLemon()
                 if (inventory.cash > int(high_score['cash'])):
-                    msg += "\nCongratulations! You've set a new high score!🎉💰🍋"
+                    msg += f"\nCongratulations! You've set a new high score!🎉💰🍋"
                     high_score['cash'] = inventory.cash
                     high_score['success'] = success
                     high_score['userID'] = nodeID
-                    with open('lemonade_hs.pkl', 'wb') as file:
+                    with open('data/lemonstand.pkl', 'wb') as file:
                         pickle.dump(high_score, file)
-                endGame(nodeID)
 
             else:
                 # keep playing
+                
+                weeks.current = weeks.current + 1
+
+                msg += f"\nPlay another week🥤? or (E)nd Game"
                 # set the last command to new in the inventory db
                 for i in range(len(lemonadeTracker)):
                     if lemonadeTracker[i]['nodeID'] == nodeID:
                         lemonadeTracker[i]['cmd'] = "new"
-            
-                weeks.current = weeks.current + 1
-
-                msg += f"Play another week🥤? 'end' to end game"
-                
-                saveValues()
+                        lemonadeTracker[i]['last_played'] = time.time()
+                saveValues(nodeID, inventory, cups, lemons, sugar, weeks, score)
             return msg
+    else:
+        return "Game Over! Start a (N)ew Game or (E)xit"

modules/games/meshtrekker.py

@@ -0,0 +1,255 @@
+"""
+Mesh Trekker Game
+Game Rules:
+1. Players compete to cover the most distance over time using their Meshtastic devices.
+2. The game tracks players' movements via GPS coordinates sent by their devices.
+3. Total distance traveled is calculated and summed over time for each player.
+4. Leaderboards show top distances for daily, weekly, and all-time periods.
+5. Players can form teams, with team distances being the sum of all team members' distances.
+6. Special achievements are awarded for milestones (e.g., 10km, 50km, 100km total distance).
+7. The game runs continuously, allowing players to participate at their own pace.
+8. Players can use the 'whereami' command to check their current location and update their position in the game.
+"""
+
+import pickle
+from modules.log import *
+from datetime import datetime, timedelta
+from geopy.distance import geodesic
+
+class MeshTrekkerError(Exception):
+    """Base class for exceptions in this module."""
+    pass
+
+class DataLoadError(MeshTrekkerError):
+    """Raised when there's an error loading data."""
+    pass
+
+class DataSaveError(MeshTrekkerError):
+    """Raised when there's an error saving data."""
+    pass
+
+class InvalidGPSDataError(MeshTrekkerError):
+    """Raised when invalid GPS data is provided."""
+    pass
+
+class MeshTrekker:
+    def __init__(self, data_file='mesh_trekker_data.pkl'):
+        self.data_file = data_file
+        try:
+            self.data = self.load_data()
+        except DataLoadError as e:
+            logger.error(f"Failed to load data: {e}")
+            self.data = self.initialize_data()
+
+    def initialize_data(self):
+        return {
+            'gps_data': {},
+            'user_distances': {},
+            'teams': {},
+            'achievements': {},
+        }
+
+    def load_data(self):
+        try:
+            with open(self.data_file, 'rb') as f:
+                return pickle.load(f)
+        except (pickle.PickleError, EOFError, FileNotFoundError) as e:
+            logger.info(f"Data file {self.data_file} not found. Initializing new data.")
+            return self.initialize_data()
+
+    def save_data(self):
+        try:
+            with open(self.data_file, 'wb') as f:
+                pickle.dump(self.data, f)
+        except (pickle.PickleError, IOError) as e:
+            raise DataSaveError(f"Error saving data: {e}")
+
+    def validate_gps_data(self, latitude, longitude, timestamp):
+        try:
+            lat = float(latitude)
+            lon = float(longitude)
+            if not -90 <= lat <= 90:
+                raise InvalidGPSDataError(f"Invalid latitude: {latitude}")
+            if not -180 <= lon <= 180:
+                raise InvalidGPSDataError(f"Invalid longitude: {longitude}")
+            if not isinstance(timestamp, datetime):
+                raise InvalidGPSDataError(f"Invalid timestamp: {timestamp}")
+        except ValueError:
+            raise InvalidGPSDataError(f"Invalid GPS data: latitude={latitude}, longitude={longitude}")
+
+    def process_gps_data(self, user_id, latitude, longitude, timestamp):
+        try:
+            self.validate_gps_data(latitude, longitude, timestamp)
+
+            if user_id not in self.data['gps_data']:
+                self.data['gps_data'][user_id] = []
+
+            self.data['gps_data'][user_id].append((float(latitude), float(longitude), timestamp))
+
+            if len(self.data['gps_data'][user_id]) > 1:
+                last_lat, last_lon, last_time = self.data['gps_data'][user_id][-2]
+                last_point = (last_lat, last_lon)
+                new_point = (float(latitude), float(longitude))
+
+                distance = geodesic(last_point, new_point).kilometers
+
+                if user_id not in self.data['user_distances']:
+                    self.data['user_distances'][user_id] = (0, timestamp)
+
+                total_distance, _ = self.data['user_distances'][user_id]
+                new_total_distance = total_distance + distance
+                self.data['user_distances'][user_id] = (new_total_distance, timestamp)
+
+                self.check_achievements(user_id, new_total_distance)
+
+            self.save_data()
+            return new_total_distance
+        except InvalidGPSDataError as e:
+            logger.error(f"Invalid GPS data for user {user_id}: {e}")
+        except DataSaveError as e:
+            logger.error(f"Failed to save data after processing GPS for user {user_id}: {e}")
+        except Exception as e:
+            logger.error(f"Unexpected error processing GPS data for user {user_id}: {e}")
+        return None
+
+    def get_leaderboard(self, timeframe='all'):
+        try:
+            now = datetime.now()
+            if timeframe == 'daily':
+                start_time = now - timedelta(days=1)
+            elif timeframe == 'weekly':
+                start_time = now - timedelta(weeks=1)
+            else:
+                start_time = datetime.min
+
+            leaderboard = []
+            for user_id, (distance, last_updated) in self.data['user_distances'].items():
+                if last_updated > start_time:
+                    leaderboard.append((user_id, distance))
+
+            return sorted(leaderboard, key=lambda x: x[1], reverse=True)[:10]
+        except Exception as e:
+            logger.error(f"Error generating leaderboard: {e}")
+            return []
+
+    def get_team_leaderboard(self):
+        try:
+            team_distances = {}
+            for team_name, members in self.data['teams'].items():
+                team_distance = sum(self.data['user_distances'].get(member, (0, None))[0] for member in members)
+                team_distances[team_name] = team_distance
+
+            return sorted(team_distances.items(), key=lambda x: x[1], reverse=True)[:10]
+        except Exception as e:
+            logger.error(f"Error generating team leaderboard: {e}")
+            return []
+
+    def get_user_stats(self, user_id):
+        try:
+            distance, last_updated = self.data['user_distances'].get(user_id, (0, None))
+            achievements = self.data['achievements'].get(user_id, [])
+            return {
+                'distance': distance,
+                'last_updated': last_updated,
+                'achievements': achievements
+            }
+        except Exception as e:
+            logger.error(f"Error retrieving stats for user {user_id}: {e}")
+            return None
+
+    def create_team(self, team_name, user_id):
+        try:
+            if team_name not in self.data['teams']:
+                self.data['teams'][team_name] = [user_id]
+                self.save_data()
+                return True
+            return False
+        except DataSaveError as e:
+            logger.error(f"Failed to save data after creating team {team_name}: {e}")
+            return False
+        except Exception as e:
+            logger.error(f"Error creating team {team_name}: {e}")
+            return False
+
+    def join_team(self, team_name, user_id):
+        try:
+            if team_name in self.data['teams'] and user_id not in self.data['teams'][team_name]:
+                self.data['teams'][team_name].append(user_id)
+                self.save_data()
+                return True
+            return False
+        except DataSaveError as e:
+            logger.error(f"Failed to save data after user {user_id} joined team {team_name}: {e}")
+            return False
+        except Exception as e:
+            logger.error(f"Error joining team {team_name} for user {user_id}: {e}")
+            return False
+
+    def check_achievements(self, user_id, total_distance):
+        try:
+            if user_id not in self.data['achievements']:
+                self.data['achievements'][user_id] = []
+
+            milestones = [10, 50, 100, 500, 1000]  # in km
+            new_achievements = []
+            for milestone in milestones:
+                if total_distance >= milestone and milestone not in self.data['achievements'][user_id]:
+                    self.data['achievements'][user_id].append(milestone)
+                    new_achievements.append(milestone)
+                    logger.info(f"User {user_id} achieved {milestone}km milestone!")
+            return new_achievements
+        except Exception as e:
+            logger.error(f"Error checking achievements for user {user_id}: {e}")
+            return []
+
+    def get_achievements(self, user_id):
+        try:
+            return self.data['achievements'].get(user_id, [])
+        except Exception as e:
+            logger.error(f"Error retrieving achievements for user {user_id}: {e}")
+            return []
+        
+# Initialize the game
+game = MeshTrekker()
+
+def handle_meshtrekker(user_id, deviceID, channel_number, location_info=(0,0)):
+    # Process GPS data from Meshtastic devices
+    latitude, longitude = location_info.split(": ")[1].split(", ")
+    
+    current_time = datetime.now()
+    new_distance = game.process_gps_data(user_id, latitude, longitude, current_time)
+
+
+    # # Create and join teams
+    # game.create_team("Team A", "user1")
+    # game.join_team("Team A", "user2")
+
+    # # Get individual leaderboard
+    # print("\nAll-time individual leaderboard:")
+    # for user, distance in game.get_leaderboard():
+    #     print(f"{user}: {distance:.2f} km")
+
+    # # Get team leaderboard
+    # print("\nTeam leaderboard:")
+    # for team, distance in game.get_team_leaderboard():
+    #     print(f"{team}: {distance:.2f} km")
+
+    # # Get user stats
+    # user_stats = game.get_user_stats("user1")
+    # print(f"\nUser1 stats: {user_stats}")
+
+    # # Get achievements
+    # achievements = game.get_achievements("user1")
+    # print(f"User1 achievements: {achievements}")
+
+    
+    if new_distance is not None:
+        new_achievements = game.check_achievements(user_id, new_distance)
+        response = f"{location_info}\nTotal distance: {new_distance:.2f} km"
+        if new_achievements:
+            response += f"\nNew achievements: {', '.join([f'{a}km' for a in new_achievements])}"
+    else:
+        response = f"{location_info}\nFailed to update distance. Please try again."
+    
+    return response
+

modules/games/mmind.py

@@ -5,9 +5,7 @@ import random
 import time
 import pickle
 from modules.log import *
-
-mindTracker = [{'nodeID': 0, 'last_played': time.time(), 'cmd': '', 'secret_code': '', 'diff': 'n', 'turns': 1}]
-
+from modules.settings import mindTracker
 def chooseDifficultyMMind(message):
     usrInput = message.lower()
     msg = ''
@@ -62,98 +60,63 @@ def makeCodeMMind(diff):
     return secret_code
 
 #get guess from user
-def getGuessMMind(diff, guess):
-    msg = ''
-    if diff == "n":
-        valid_colorsMMind = "RYGB"
-    elif diff == "h":
-        valid_colorsMMind = "RYGBOP"
-    elif diff == "x":
-        valid_colorsMMind = "RYGBOPWK"
-        
-    user_guess = guess.upper()
-    valid_guess = True
-    if len(user_guess) != 4:
-        valid_guess = False
-    for i in range(len(user_guess)):
-        if user_guess[i] not in valid_colorsMMind:
-            valid_guess = False
-    if valid_guess == False:
-        user_guess = "XXXX"
+def getGuessMMind(diff, guess, nodeID):
+    valid_colors = {
+        "n": "RYGB",
+        "h": "RYGBOP",
+        "x": "RYGBOPWK"
+    }
+    user_guess = guess.strip().upper()
+    if len(user_guess) != 4 or any(c not in valid_colors.get(diff, "RYGB") for c in user_guess):
+        return "XXXX"
+    
+    #increase the turn count and store in tracker
+    for i in range(len(mindTracker)):
+        if mindTracker[i]['nodeID'] == nodeID:
+            mindTracker[i]['turns'] += 1
+            mindTracker[i]['last_played'] = time.time()
+            mindTracker[i]['diff'] = diff
     return user_guess
 
 def getHighScoreMMind(nodeID, turns, diff):
-    # check if player is in high score list and pick the lowest score
-    try:
-        with open('mmind_hs.pkl', 'rb') as f:
-            mindHighScore = pickle.load(f)
-    except:
-        logger.debug("System: MasterMind: High Score file not found.")
-        mindHighScore = [{'nodeID': nodeID, 'turns': turns, 'diff': diff}]
-        with open('mmind_hs.pkl', 'wb') as f:
-            pickle.dump(mindHighScore, f)
+    import os
+    hs_file = 'data/mmind_hs.pkl'
+    # Try to load existing high scores
+    if os.path.exists(hs_file):
+        try:
+            with open(hs_file, 'rb') as f:
+                mindHighScore = pickle.load(f)
+        except Exception as e:
+            logger.debug(f"System: MasterMind: Error loading high score file: {e}")
+            mindHighScore = []
+    else:
+        mindHighScore = []
 
+    # If nodeID==0, just return 0
     if nodeID == 0:
-        # just return the high score
+        mindHighScore = [{'nodeID': 0, 'turns': 0, 'diff': 'n'}]
         return mindHighScore
 
-    # calculate lowest score
-    lowest_score = mindHighScore[0]['turns']
+    # If no high score, add this one
+    if not mindHighScore:
+        mindHighScore = [{'nodeID': nodeID, 'turns': turns, 'diff': diff}]
+        with open(hs_file, 'wb') as f:
+            pickle.dump(mindHighScore, f)
+        return mindHighScore
 
-    if mindHighScore[0]['diff'] == "n" and diff == "n":
-        if lowest_score > turns:
-            # update the high score for normal if new score is lower
-            mindHighScore[0]['nodeID'] = nodeID
-            mindHighScore[0]['turns'] = turns
-            mindHighScore[0]['diff'] = diff
-            
-            # write new high score to file
-            with open('mmind_hs.pkl', 'wb') as f:
+    # If the diff matches, compare and update if better
+    if mindHighScore[0]['diff'] == diff:
+        if turns < mindHighScore[0]['turns']:
+            mindHighScore[0] = {'nodeID': nodeID, 'turns': turns, 'diff': diff}
+            with open(hs_file, 'wb') as f:
                 pickle.dump(mindHighScore, f)
-            return mindHighScore
-    elif mindHighScore[0]['diff'] == "n" and diff == "h":
-        # update the high score for hard if normal is the only high score
-        mindHighScore[0]['nodeID'] = nodeID
-        mindHighScore[0]['turns'] = turns
-        mindHighScore[0]['diff'] = diff
-        
-        # write new high score to file
-        with open('mmind_hs.pkl', 'wb') as f:
-            pickle.dump(mindHighScore, f)
         return mindHighScore
-    elif mindHighScore[0]['diff'] == "h" and diff == "h":
-        if lowest_score > turns:
-            # update the high score for hard if new score is lower
-            mindHighScore[0]['nodeID'] = nodeID
-            mindHighScore[0]['turns'] = turns
-            mindHighScore[0]['diff'] = diff
-            
-            # write new high score to file
-            with open('mmind_hs.pkl', 'wb') as f:
-                pickle.dump(mindHighScore, f)
-            return mindHighScore
-    elif mindHighScore[0]['diff'] == "n" or mindHighScore[0]['diff'] == "h" and diff == "x":
-        # update the high score for expert if normal or high is the only high score
-        mindHighScore[0]['nodeID'] = nodeID
-        mindHighScore[0]['turns'] = turns
-        mindHighScore[0]['diff'] = diff
-        
-        # write new high score to file
-        with open('mmind_hs.pkl', 'wb') as f:
-            pickle.dump(mindHighScore, f)
-        return mindHighScore
-    elif mindHighScore[0]['diff'] == "x" and diff == "x":
-        if lowest_score > turns:
-            # update the high score for expert if new score is lower
-            mindHighScore[0]['nodeID'] = nodeID
-            mindHighScore[0]['turns'] = turns
-            mindHighScore[0]['diff'] = diff
-            
-            # write new high score to file
-            with open('mmind_hs.pkl', 'wb') as f:
-                pickle.dump(mindHighScore, f)
-            return mindHighScore
-    return 0
+
+    # If the diff is different, replace with new high score for new diff
+    mindHighScore[0] = {'nodeID': nodeID, 'turns': turns, 'diff': diff}
+    with open(hs_file, 'wb') as f:
+        pickle.dump(mindHighScore, f)
+    return mindHighScore
 
 
 def getEmojiMMind(secret_code):
@@ -182,7 +145,7 @@ def getEmojiMMind(secret_code):
     return secret_code_emoji
 
 #compare userGuess with secret code and provide feedback
-def compareCodeMMind(secret_code, user_guess):
+def compareCodeMMind(secret_code, user_guess, nodeID):
     game_won = False
     perfect_pins = 0
     wrong_position = 0
@@ -195,23 +158,41 @@ def compareCodeMMind(secret_code, user_guess):
         # check for perfect pins and right color wrong position
         temp_code = []
         temp_guess = []
-        for i in range(len(user_guess)): #check for perfect pins
+        # Check for perfect pins
+        for i in range(len(user_guess)):
             if user_guess[i] == secret_code[i]:
                 perfect_pins += 1
             else:
                 temp_code.append(secret_code[i])
                 temp_guess.append(user_guess[i])
-        for i in range(len(temp_guess)): #check for right color wrong position
-            for j in range(len(temp_code)):
-                if temp_guess[i] == temp_code[j]:
-                    wrong_position += 1
-                    temp_code[j] = "0"
-                    break
+
+        # Check for right color wrong position
+        for guess in temp_guess:
+            if guess in temp_code:
+                wrong_position += 1
+                temp_code.remove(guess)  # Remove the first occurrence of the matched color
     # display feedback
     if game_won:
-        msg += f"Correct{getEmojiMMind(user_guess)}\n"
+        msg += f"\n🏆Correct{getEmojiMMind(user_guess)}\nYou are the master mind!🤯"
+        # get turn count from tracker
+        for i in range(len(mindTracker)):
+            if mindTracker[i]['nodeID'] == nodeID:
+                turns = mindTracker[i]['turns'] - 2  # subtract 2 to account for increment after last guess and starting at 1
+                diff = mindTracker[i]['diff']
+        # get high score
+        high_score = getHighScoreMMind(nodeID, turns, diff)
+        if high_score[0]['turns'] != 0:
+            msg += f"\n🏆 High Score:{turns} turns, Difficulty:{diff}"
+        # reset turn count in tracker
+        msg += f"\nWould you like to play again? (N)ormal, (H)ard, or e(X)pert?"
+        # reset turn count in tracker
+        for i in range(len(mindTracker)):
+            if mindTracker[i]['nodeID'] == nodeID:
+                mindTracker[i]['turns'] = 0
+                mindTracker[i]['secret_code'] = ''
+                mindTracker[i]['cmd'] = 'new'
     else:
-        msg += f"Guess{getEmojiMMind(user_guess)}\n"
+        msg += f"\nGuess{getEmojiMMind(user_guess)}\n"
 
     if perfect_pins > 0 and game_won == False:
         msg += "✅ color ✅ position: {}".format(perfect_pins)
@@ -230,11 +211,11 @@ def playGameMMind(diff, secret_code, turn_count, nodeID, message):
     msg = ''
     won = False
     if turn_count <= 10:
-        user_guess = getGuessMMind(diff, message)
+        user_guess = getGuessMMind(diff, message, nodeID)
         if user_guess == "XXXX":
-            msg += "Invalid guess. Please enter 4 valid colors."
+            msg += f"⛔️Invalid guess. Please enter 4 valid colors letters.\n🔴🟢🔵🔴 is RGBR"
             return msg
-        check_guess = compareCodeMMind(secret_code, user_guess)
+        check_guess = compareCodeMMind(secret_code, user_guess, nodeID)
 
         # display turn count and feedback
         msg += "Turn {}:".format(turn_count)
@@ -244,18 +225,6 @@ def playGameMMind(diff, secret_code, turn_count, nodeID, message):
     
         if won == True:
             msg += f"\n🎉🧠 you win 🥷🤯"
-            # get high score
-            high_score = getHighScoreMMind(nodeID, turn_count, diff)
-            if high_score != 0:
-                msg += f"\n🏆 High Score:{high_score[0]['turns']} turns, Difficulty:{high_score[0]['diff'].upper()}"
-            
-            msg += "\nWould you like to play again?\n(N)ormal, (H)ard, e(X)pert?"
-            # reset turn count in tracker
-            for i in range(len(mindTracker)):
-                if mindTracker[i]['nodeID'] == nodeID:
-                    mindTracker[i]['turns'] = 1
-                    mindTracker[i]['secret_code'] = ''
-                    mindTracker[i]['cmd'] = 'new'
         else:
             # increment turn count and keep playing
             turn_count += 1
@@ -265,12 +234,12 @@ def playGameMMind(diff, secret_code, turn_count, nodeID, message):
                     mindTracker[i]['turns'] = turn_count
     elif won == False:
         msg += f"🙉Game Over🙈\nThe code was: {getEmojiMMind(secret_code)}"
-        msg += "\nYou have run out of turns.😿"
-        msg += "\nWould you like to play again? (N)ormal, (H)ard, or e(X)pert?"
+        msg += f"\nYou have run out of turns.😿"
+        msg += f"\nWould you like to play again? (N)ormal, (H)ard, or e(X)pert?"
         # reset turn count in tracker
         for i in range(len(mindTracker)):
             if mindTracker[i]['nodeID'] == nodeID:
-                mindTracker[i]['turns'] = 1
+                mindTracker[i]['turns'] = 0
                 mindTracker[i]['secret_code'] = ''
                 mindTracker[i]['cmd'] = 'new'
 
@@ -296,8 +265,6 @@ def start_mMind(nodeID, message):
         if mindTracker[i]['nodeID'] == nodeID:
             last_cmd = mindTracker[i]['cmd']
 
-    logger.debug("System: MasterMind: last_cmd: " + str(last_cmd))
-
     if last_cmd == "new":
         if message.lower().startswith("n") or message.lower().startswith("h") or message.lower().startswith("x"):
             diff = message.lower()[0]

modules/games/quiz.py

@@ -0,0 +1,165 @@
+# Quiz Module for meshbot 2025
+# Provides a quiz game function with multiple choice and free-text questions
+# Quizmaster can start/stop the quiz, players can join/leave, answer questions
+# Scores are tracked, first correct answer is noted, top 3 players announced at end
+# Questions are loaded from a JSON file in data/quiz_questions.json
+# Questions can be multiple choice (with answers array) or free-text (with answer string)
+# Players answer with "Q: <answer>" format, "Q: ?" for next question, locked to DM
+# unlike a normal game, players can join/leave anytime during the quiz but the QuizMaster needs to start or open game
+# Quizmaster can broadcast messages to all players
+
+import json
+import os
+import random
+from modules.log import *
+
+QUIZ_JSON = os.path.join(os.path.dirname(__file__), '../', '../', 'data', 'quiz_questions.json')
+QUIZMASTER_ID = bbs_admin_list
+
+trap_list_quiz = ("quiz", "q:")
+help_text_quiz = "quiz",
+
+class QuizGame:
+    def __init__(self):
+        self.quizmaster = QUIZMASTER_ID
+        self.active = False
+        self.players = {}  # user_id: {'score': int, 'current_q': int, 'answered': set()}
+        self.questions = []  # Loaded from JSON
+        self.first_correct = {}  # q_idx: user_id
+        self.load_questions()
+
+    def start_game(self, quizmaster_id):
+        if str(quizmaster_id) not in self.quizmaster:
+            return "Only the quizmaster can start the quiz."
+        if self.active:
+            return "Quiz already running."
+        self.active = True
+        logger.debug(f"QuizMaster: {quizmaster_id} started a new quiz round.")
+        self.players = {}
+        self.first_correct = {}  # Reset on new game
+        self.load_questions()
+        return "Quiz started! Players can now join."
+    
+    def load_questions(self):
+        try:
+            with open(QUIZ_JSON, 'r') as f:
+                self.questions = json.load(f)
+            # Shuffle questions to ensure randomness each game
+            #random.shuffle(self.questions)
+        except Exception as e:
+            logger.error(f"Failed to load quiz questions: {e}")
+            self.questions = []
+
+    def stop_game(self, quizmaster_id):
+        if not self.active or str(quizmaster_id) not in self.quizmaster:
+            return "Only the quizmaster can stop the quiz."
+        return_msg = "Quiz stopped! Final scores:\n" + self.top_three()
+        logger.debug(f"QuizMaster: {quizmaster_id} stopped the quiz.")
+        self.active = False
+        self.players = {}
+        return return_msg
+
+    def join(self, user_id):
+        if not self.active:
+            return "No quiz running. Wait for the quizmaster to start."
+        if user_id in self.players:
+            return "You are already in the quiz."
+        self.players[user_id] = {'score': 0, 'current_q': 0, 'answered': set()}
+        reminder = f"Joined!\n'Q: <Answer>' 'Q: ?' for more.\n"
+        logger.debug(f"QuizMaster: Player {user_id} joined the round.")
+        return reminder + self.next_question(user_id)
+
+    def leave(self, user_id):
+        if user_id in self.players:
+            del self.players[user_id]
+            logger.debug(f"QuizMaster: Player {user_id} left the round.")
+            return "You left the quiz."
+        return "You are not in the quiz."
+
+    def next_question(self, user_id):
+        if user_id not in self.players:
+            return "Join the quiz first."
+        player = self.players[user_id]
+        while player['current_q'] < len(self.questions) and player['current_q'] in player['answered']:
+            player['current_q'] += 1
+        if player['current_q'] >= len(self.questions):
+            return f"No more questions. Your final score: {player['score']}."
+        q = self.questions[player['current_q']]
+        msg = f"Q{player['current_q']+1}: {q['question']}\n"
+        if "answers" in q:
+            for i, opt in enumerate(q['answers']):
+                msg += f"{chr(65+i)}. {opt}\n"
+            msg = msg.strip()
+        return msg
+
+    def answer(self, user_id, answer):
+        if user_id not in self.players:
+            return "Join the quiz first."
+        player = self.players[user_id]
+        q_idx = player['current_q']
+        if q_idx >= len(self.questions):
+            return "No more questions."
+        if q_idx in player['answered']:
+            return "Already answered. Type 'next' for another question."
+        q = self.questions[q_idx]
+        # Check if it's multiple choice or free-text
+        if "answers" in q and "correct" in q:
+            try:
+                ans_idx = ord(answer.upper()) - 65
+                if ans_idx == q['correct']:
+                    player['score'] += 1
+                    # Track first correct answer
+                    if q_idx not in self.first_correct:
+                        self.first_correct[q_idx] = user_id
+                        logger.info(f"QuizMaster: Question {q_idx+1} first user with correct answer by {user_id}")
+                    result = "Correct! 🎉"
+                else:
+                    result = f"Wrong. Correct answer: {chr(65+q['correct'])}"
+                player['answered'].add(q_idx)
+                player['current_q'] += 1
+                return f"{result}\n" + self.next_question(user_id)
+            except Exception:
+                return "Invalid answer. Use A, B, C, etc."
+        elif "answer" in q:
+            user_ans = answer.strip().lower()
+            correct_ans = str(q['answer']).strip().lower()
+            if user_ans == correct_ans:
+                player['score'] += 1
+                if q_idx not in self.first_correct:
+                    self.first_correct[q_idx] = user_id
+                    logger.info(f"QuizMaster: Question {q_idx+1} first user with correct answer by {user_id}")
+                result = "Correct! 🎉"
+            else:
+                result = f"Wrong. Correct answer: {q['answer']}"
+            player['answered'].add(q_idx)
+            player['current_q'] += 1
+            return f"{result}\n" + self.next_question(user_id)
+        else:
+            return "Invalid question format."
+
+    def top_three(self):
+        if not self.players:
+            return "No players in the quiz."
+        ranking = sorted(self.players.items(), key=lambda x: x[1]['score'], reverse=True)
+        count = min(3, len(ranking))
+        msg = f"🏆 Top {count} Player{'s' if count > 1 else ''}:\n"
+        for idx, (uid, pdata) in enumerate(iterable=ranking[:count], start=1):
+            msg += f"{idx}. {uid}: @{pdata['score']}\n"
+        return msg
+
+    def broadcast(self, quizmaster_id, message):
+        msgToAll = {}
+        if quizmaster_id and str(quizmaster_id) not in self.quizmaster:
+            return "Only the quizmaster can broadcast."
+        if not self.players:
+            return "No players to broadcast to."
+        # set up message
+        message_to_send = f"📢 From Quizmaster: {message}"
+        msgToAll['message'] = message_to_send
+        # setup players
+        for uid in self.players.keys():
+            msgToAll.setdefault('players', []).append(uid)
+        return msgToAll
+                
+# Initialize the quiz game
+quizGamePlayer = QuizGame()

modules/games/tictactoe.py

@@ -0,0 +1,277 @@
+# Tic-Tac-Toe game for Meshtastic mesh-bot
+# Board positions chosen by numbers 1-9
+# 2025
+from modules.log import *
+import random
+import time
+
+# to molly and jake, I miss you both so much.
+
+if disable_emojis_in_games:
+    X = "X"
+    O = "O"
+else:
+    X = "❌"
+    O = "⭕️"
+
+class TicTacToe:
+    def __init__(self):
+        self.game = {}
+
+    def new_game(self, id):
+        positiveThoughts = ["🚀I need to call NATO",
+                            "🏅Going for the gold!",
+                            "Mastering ❌TTT⭕️",]
+        sorryNotGoinWell = ["😭Not your day, huh?",
+                        "📉Results here dont define you.",
+                        "🤖WOPR would be proud."]
+        """Start a new game"""
+        games = won = 0
+        ret = ""
+        if id in self.game:
+            games = self.game[id]["games"]
+            won = self.game[id]["won"]
+            if games > 3:
+                if won / games >= 3.14159265358979323846: # win rate > pi
+                    ret += random.choice(positiveThoughts) + "\n"
+                else:
+                    ret += random.choice(sorryNotGoinWell) + "\n"
+            # Retain stats
+            ret += f"Games:{games} 🥇❌:{won}\n"
+
+        self.game[id] = {
+            "board": [" "] * 9,  # 3x3 board as flat list
+            "player": X,       # Human is X, bot is O
+            "games": games + 1,
+            "won": won,
+            "turn": "human"      # whose turn it is
+        }
+        ret += self.show_board(id)
+        ret += "Pick 1-9:"
+        return ret
+    
+    def rndTeaPrice(self, tea=42):
+        """Return a random tea between 0 and tea."""
+        return random.uniform(0, tea)
+
+    def show_board(self, id):
+        """Display compact board with move numbers"""
+        g = self.game[id]
+        b = g["board"]
+        
+        # Show board with positions
+        board_str = ""
+        for i in range(3):
+            row = ""
+            for j in range(3):
+                pos = i * 3 + j
+                if disable_emojis_in_games:
+                    cell = b[pos] if b[pos] != " " else str(pos + 1)
+                else:
+                    cell = b[pos] if b[pos] != " " else f" {str(pos + 1)} "
+                row += cell
+                if j < 2:
+                    row += " | "
+            board_str += row
+            if i < 2:
+                #board_str += "\n-+-+-\n"
+                board_str += "\n"
+        
+        return board_str + "\n"
+
+    def make_move(self, id, position):
+        """Make a move for the current player"""
+        g = self.game[id]
+        
+        # Validate position
+        if position < 1 or position > 9:
+            return False
+        
+        pos = position - 1
+        if g["board"][pos] != " ":
+            return False
+        
+        # Make human move
+        g["board"][pos] = X
+        return True
+
+    def bot_move(self, id):
+        """AI makes a move: tries to win, block, or pick random"""
+        g = self.game[id]
+        board = g["board"]
+    
+        # Try to win
+        move = self.find_winning_move(id, O)
+        if move != -1:
+            board[move] = O
+            return move
+    
+        # Try to block player
+        move = self.find_winning_move(id, X)
+        if move != -1:
+            board[move] = O
+            return move
+    
+        # Pick random move
+        move = self.find_random_move(id)
+        if move != -1:
+            board[move] = O
+            return move
+    
+        # No moves possible
+        return -1
+
+    def find_winning_move(self, id, player):
+        """Find a winning move for the given player"""
+        g = self.game[id]
+        board = g["board"][:]
+        
+        # Check all empty positions
+        for i in range(9):
+            if board[i] == " ":
+                board[i] = player
+                if self.check_winner_on_board(board) == player:
+                    return i
+                board[i] = " "
+        return -1
+    
+    def find_random_move(self, id: str, tea_price: float = 42.0) -> int:
+        """Find a random empty position, using time and tea_price for extra randomness."""
+        board = self.game[id]["board"]
+        empty = [i for i, cell in enumerate(board) if cell == " "]
+        current_time = time.time()
+        from_china = self.rndTeaPrice(time.time() % 7)  # Correct usage
+        tea_price = from_china
+        tea_price = (42 * 7) - (13 / 2) + (tea_price % 5)
+        if not empty:
+            return -1
+        # Combine time and tea_price for a seed
+        seed = int(current_time * 1000) ^ int(tea_price * 1000)
+        local_random = random.Random(seed)
+        local_random.shuffle(empty)
+        return empty[0]
+
+    def check_winner_on_board(self, board):
+        """Check winner on given board state"""
+        # Winning combinations
+        wins = [
+            [0,1,2], [3,4,5], [6,7,8],  # Rows
+            [0,3,6], [1,4,7], [2,5,8],  # Columns  
+            [0,4,8], [2,4,6]            # Diagonals
+        ]
+        
+        for combo in wins:
+            if board[combo[0]] == board[combo[1]] == board[combo[2]] != " ":
+                return board[combo[0]]
+        return None
+
+    def check_winner(self, id):
+        """Check if there's a winner"""
+        g = self.game[id]
+        return self.check_winner_on_board(g["board"])
+
+    def is_board_full(self, id):
+        """Check if board is full"""
+        g = self.game[id]
+        return " " not in g["board"]
+
+    def game_over_msg(self, id):
+        """Generate game over message"""
+        g = self.game[id]
+        winner = self.check_winner(id)
+        
+        if winner == X:
+            g["won"] += 1
+            return "🎉You won! (n)ew (e)nd"
+        elif winner == O:
+            return "🤖Bot wins! (n)ew (e)nd"
+        else:
+            return "🤝Tie, The only winning move! (n)ew (e)nd"
+
+    def play(self, id, input_msg):
+        """Main game play function"""
+        if id not in self.game:
+            return self.new_game(id)
+        
+        # If input is just "tictactoe", show current board
+        if input_msg.lower().strip() == ("tictactoe" or "tic-tac-toe"):
+            return self.show_board(id) + "Your turn! Pick 1-9:"
+        
+        g = self.game[id]
+        
+        # Parse player move
+        try:
+            # Extract just the number from the input
+            numbers = [char for char in input_msg if char.isdigit()]
+            if not numbers:
+                if input_msg.lower().startswith('q'):
+                    self.end_game(id)
+                    return "Game ended. To start a new game, type 'tictactoe'."
+                elif input_msg.lower().startswith('n'):
+                    return self.new_game(id)
+                elif input_msg.lower().startswith('b'):
+                    return self.show_board(id) + "Your turn! Pick 1-9:"
+            position = int(numbers[0])
+        except (ValueError, IndexError):
+            return "Enter 1-9, or (e)nd (n)ew game, send (b)oard to see board🧩"
+        
+        # Make player move
+        if not self.make_move(id, position):
+            return "Invalid move! Pick 1-9:"
+        
+        # Check if player won
+        if self.check_winner(id):
+            result = self.game_over_msg(id) + "\n" + self.show_board(id)
+            self.end_game(id)
+            return result
+        
+        # Check for tie
+        if self.is_board_full(id):
+            result = self.game_over_msg(id) + "\n" + self.show_board(id)
+            self.end_game(id)
+            return result
+        
+        # Bot's turn
+        bot_pos = self.bot_move(id)
+        
+        # Check if bot won
+        if self.check_winner(id):
+            result = self.game_over_msg(id) + "\n" + self.show_board(id)
+            self.end_game(id)
+            return result
+        
+        # Check for tie after bot move
+        if self.is_board_full(id):
+            result = self.game_over_msg(id) + "\n" + self.show_board(id)
+            self.end_game(id)
+            return result
+        
+        # Continue game
+        return self.show_board(id) + "Your turn! Pick 1-9:"
+
+    def end_game(self, id):
+        """Clean up finished game but keep stats"""
+        if id in self.game:
+            games = self.game[id]["games"]
+            won = self.game[id]["won"]
+            # Remove game but we'll create new one on next play
+            del self.game[id]
+            # Preserve stats for next game
+            self.game[id] = {
+                "board": [" "] * 9,
+                "player": X,
+                "games": games,
+                "won": won,
+                "turn": "human"
+            }
+
+
+    def end(self, id):
+        """End game completely (called by 'end' command)"""
+        if id in self.game:
+            del self.game[id]
+
+
+# Global instances for the bot system
+tictactoeTracker = []
+tictactoe = TicTacToe()

modules/games/videopoker.py

@@ -6,8 +6,7 @@ import pickle
 from modules.log import *
 
 vpStartingCash = 20
-vpTracker= [{'nodeID': 0, 'cmd': 'new', 'time': time.time(), 'cash': vpStartingCash, 'player': None, 'deck': None, 'highScore': 0, 'drawCount': 0}]
-
+from modules.settings import vpTracker
 # Define the Card class
 class CardVP:
 
@@ -164,8 +163,8 @@ class PlayerVP:
                 return self.show_hand()    
             except Exception as e:
                 pass
-    
-        return "Re-Draw/Deal ex:1,3,4 to hold cards 1,3 and 4, or (N)o to keep current (H)and"
+
+        return "ex:1,3,4 deals them new, and keeps 2,5 or (N)o to keep current (H)and"
 
     # Method for scoring hand, calculating winnings, and outputting message
     def score_hand(self, resetHand = True):
@@ -276,23 +275,23 @@ def saveHSVp(nodeID, highScore):
     # Save the game high_score to pickle
     highScore = {'nodeID': nodeID, 'highScore': highScore}
     try:
-        with open('videopoker_hs.pkl', 'wb') as file:
+        with open('data/videopoker_hs.pkl', 'wb') as file:
             pickle.dump(highScore, file)
     except FileNotFoundError:
-        logger.debug("System: BlackJack: Creating new videopoker_hs.pkl file")
-        with open('videopoker_hs.pkl', 'wb') as file:
+        logger.debug("System: BlackJack: Creating new data/videopoker_hs.pkl file")
+        with open('data/videopoker_hs.pkl', 'wb') as file:
             pickle.dump(highScore, file)
 
 def loadHSVp():
     # Load the game high_score from pickle
     try:
-        with open('videopoker_hs.pkl', 'rb') as file:
+        with open('data/videopoker_hs.pkl', 'rb') as file:
             highScore = pickle.load(file)
             return highScore
     except FileNotFoundError:
-        logger.debug("System: VideoPoker: Creating new videopoker_hs.pkl file")
+        logger.debug("System: VideoPoker: Creating new data/videopoker_hs.pkl file")
         highScore = {'nodeID': 0, 'highScore': 0}
-        with open('videopoker_hs.pkl', 'wb') as file:
+        with open('data/videopoker_hs.pkl', 'wb') as file:
             pickle.dump(highScore, file)
         return 0
 
@@ -304,7 +303,7 @@ def playVideoPoker(nodeID, message):
         # create new player if not in tracker
         logger.debug(f"System: VideoPoker: New Player {nodeID}")
         vpTracker.append({'nodeID': nodeID, 'cmd': 'new', 'time': time.time(), 'cash': vpStartingCash, 'player': None, 'deck': None, 'highScore': 0, 'drawCount': 0})
-        return f"Welcome to 🎰VideoPoker♥️ you have {vpStartingCash} coins, Whats your bet?"
+        return f"You have {vpStartingCash} coins, \nWhats your bet?"
     
     # Gather the player's bet
     if getLastCmdVp(nodeID) == "new" or getLastCmdVp(nodeID) == "gameOver":
@@ -326,15 +325,15 @@ def playVideoPoker(nodeID, message):
         try:
             bet = int(message)
         except ValueError:
-            msg += "Please enter a valid bet amount. 1 to 5 coins."
+            msg += f"Please enter a valid bet, 1 to 5 coins. you have {player.bankroll} coins."
 
         # Check if bet is valid
         if bet > player.bankroll:
-            msg += "You can only bet the money you have. No strip poker here..."
+            msg += f"You can only bet the money you have. {player.bankroll} coins, No strip poker here..."
         elif bet < 1:
-            msg += "You must bet at least 1 coin."
+            msg += "You must bet at least 1 coin.🪙"
         elif bet > 5:
-            msg += "You can only bet up to 5 coins."
+            msg += "The 🎰 coin slot only fits 5 coins max."
 
         # if msg contains an error, return it
         if msg is not None and msg != '':
@@ -390,7 +389,7 @@ def playVideoPoker(nodeID, message):
         else:
             if drawCount <= 1:
                 msg = player.redraw(deck, message)
-                if msg.startswith("Send Card"):
+                if msg.startswith("ex:"):
                     # if returned error message, return it
                     return msg
                 drawCount += 1
@@ -403,7 +402,7 @@ def playVideoPoker(nodeID, message):
                 if drawCount == 2:
                     # this is the last draw will carry on to endGame for scoring
                     msg = player.redraw(deck, message) + f"\n"
-                    if msg.startswith("Send Card"):
+                    if msg.startswith("ex:"):
                         # if returned error message, return it
                         return msg
                     # redraw done
@@ -426,14 +425,14 @@ def playVideoPoker(nodeID, message):
 
         if player.bankroll < 1:
             player.bankroll = vpStartingCash
-            msg += "\nLooks 💸 like you're out of money. 💳 resetting ballance 🏧"
+            msg += f"\nLooks 💸 like you're out of money. 💳 resetting ballance 🏧"
         elif player.bankroll > vpTracker[i]['highScore']:
             vpTracker[i]['highScore'] = player.bankroll
             msg += " 🎉HighScore!"
             # save high score
             saveHSVp(nodeID, vpTracker[i]['highScore'])
 
-        msg += f"\nPlace your Bet, 'L' to leave the game."
+        msg += f"\nPlace your Bet, or (L)eave Table."
 
         setLastCmdVp(nodeID, "gameOver")
         # reset player and deck in tracker

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(lat, lon):
+    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

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"
+    
+
+    

modules/llm.py

@@ -1,78 +1,239 @@
 #!/usr/bin/env python3
 # LLM Module for meshing-around
-# This module is used to interact with Ollama to generate responses to user input
+# This module is used to interact with LLM API to generate responses to user input
 # K7MHI Kelly Keeton 2024
 from modules.log import *
 
-from langchain_ollama import OllamaLLM # pip install ollama langchain-ollama
-from langchain_core.prompts import ChatPromptTemplate # pip install langchain
-from langchain_core.messages import AIMessage, HumanMessage
-from googlesearch import search # pip install googlesearch-python
+# Ollama Client
+# https://github.com/ollama/ollama/blob/main/docs/faq.md#how-do-i-configure-ollama-server
+import requests
+import json
+
+if not rawLLMQuery:
+    # this may be removed in the future
+    from googlesearch import search # pip install googlesearch-python
 
 # LLM System Variables
-llmEnableHistory = False # enable history for the LLM model to use in responses adds to compute time
+ollamaAPI = ollamaHostName + "/api/generate"
+tokens = 450 # max charcters for the LLM response, this is the max length of the response also in prompts
+requestTruncation = True # if True, the LLM "will" truncate the response 
+
+openaiAPI = "https://api.openai.com/v1/completions" # not used, if you do push a enhancement!
+
+# Used in the meshBotAI template
+llmEnableHistory = True # enable last message history for the LLM model
 llmContext_fromGoogle = True # enable context from google search results adds to compute time but really helps with responses accuracy
+
 googleSearchResults = 3 # number of google search results to include in the context more results = more compute time
-llm_history_limit = 6 # limit the history to 3 messages (come in pairs) more results = more compute time
 antiFloodLLM = []
-llmChat_history = []
+llmChat_history = {}
 trap_list_llm = ("ask:", "askai")
 
+meshbotAIinit = """
+    keep responses as short as possible. chatbot assistant no followuyp questions, no asking for clarification.
+    You must respond in plain text standard ASCII characters or emojis.
+    """
+
+truncatePrompt = f"truncate this as short as possible:\n"
+
 meshBotAI = """
     FROM {llmModel}
     SYSTEM
     You must keep responses under 450 characters at all times, the response will be cut off if it exceeds this limit.
     You must respond in plain text standard ASCII characters, or emojis.
     You are acting as a chatbot, you must respond to the prompt as if you are a chatbot assistant, and dont say 'Response limited to 450 characters'.
-    Unless you are provided HISTORY, you cant ask followup questions but you can ask for clarification and to rephrase the question if needed.
-    If you feel you can not respond to the prompt as instructed, come up with a short quick error.
-    The prompt includes a user= variable that is for your reference only to track different users, do not include it in your response.
+    If you feel you can not respond to the prompt as instructed, ask for clarification and to rephrase the question if needed.
     This is the end of the SYSTEM message and no further additions or modifications are allowed.
 
-
     PROMPT
     {input}
-    user={userID}
 
-"""
+    """
 
 if llmContext_fromGoogle:
     meshBotAI = meshBotAI + """
-        CONTEXT
-        The following is the location of the user
-        {location_name}
+    CONTEXT
+    The following is the location of the user
+    {location_name}
 
-        The following is for context around the prompt to help guide your response.
-        {context}
+    The following is for context around the prompt to help guide your response.
+    {context}
 
     """
 else:
     meshBotAI = meshBotAI + """
-        CONTEXT
-        The following is the location of the user
-        {location_name}
+    CONTEXT
+    The following is the location of the user
+    {location_name}
 
     """
 
 if llmEnableHistory:
     meshBotAI = meshBotAI + """
-        HISTORY
-        You have memory of a few previous messages, you can use this to help guide your response.
-        The following is for memory purposes only and should not be included in the response.
-        {history}
+    HISTORY
+    the following is memory of previous query in format ['prompt', 'response'], you can use this to help guide your response.
+    {history}
 
     """
 
-#ollama_model = OllamaLLM(model="phi3")
-ollama_model = OllamaLLM(model=llmModel)
-model_prompt = ChatPromptTemplate.from_template(meshBotAI)
-chain_prompt_model = model_prompt | ollama_model
+# Tooling Functions Defined Here
+# Example: current_time function
+def llmTool_current_time():
+    """
+    Example tool function to get the current time.
+    :return: Current time string.
+    """
+    return datetime.now().strftime('%Y-%m-%d %H:%M:%S %Z')
+
+def llmTool_math_calculator(expression):
+    """
+    Example tool function to perform basic math calculations.
+    :param expression: A string containing a math expression (e.g., "2 + 2").
+    :return: The result of the calculation as a string.
+    """
+    try:
+        # WARNING: Using eval can be dangerous if not controlled properly.
+        # This is a simple example; in production, consider using a safe math parser.
+        result = eval(expression, {"__builtins__": None}, {})
+        return str(result)
+    except Exception as e:
+        return f"Error in calculation: {e}"
+
+def llmTool_get_google(query, num_results=3):
+    """
+    Example tool function to perform a Google search and return results.
+    :param query: The search query string.
+    :param num_results: Number of search results to return.
+    :return: A list of search result titles and descriptions.
+    """
+    results = []
+    try:
+        googleSearch = search(query, advanced=True, num_results=num_results)
+        for result in googleSearch:
+            results.append(f"{result.title}: {result.description}")
+        return results
+    except Exception as e:
+        return [f"Error in Google search: {e}"]
+
+llmFunctions = [
+
+    {
+        "name": "llmTool_current_time",
+        "description": "Get the current time.",
+        "parameters": {
+            "type": "object",
+            "properties": {}
+    }
+    },
+    {
+        "name": "llmTool_math_calculator",
+        "description": "Perform basic math calculations.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "expression": {
+                    "type": "string",
+                    "description": "A math expression to evaluate, e.g., '2 + 2'."
+                }
+            },
+            "required": ["expression"]
+        }
+    },
+    {
+        "name": "llmTool_get_google",
+        "description": "Perform a Google search and return results.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "query": {
+                    "type": "string",
+                    "description": "The search query string."
+                },
+                "num_results": {
+                    "type": "integer",
+                    "description": "Number of search results to return.",
+                    "default": 3
+                }
+            },
+            "required": ["query"]
+        }
+    }  
+]
+
+def get_google_context(input, num_results):
+    # Get context from Google search results
+    googleResults = []
+    try:
+        googleSearch = search(input, advanced=True, num_results=num_results)
+        if googleSearch:
+            for result in googleSearch:
+                googleResults.append(f"{result.title} {result.description}")
+        else:
+            googleResults = ['no other context provided']
+    except Exception as e:
+        logger.debug(f"System: LLM Query: context gathering failed, likely due to network issues")
+        googleResults = ['no other context provided']
+    return googleResults
+
+def send_ollama_query(llmQuery):
+    # Send the query to the Ollama API and return the response
+    result = requests.post(ollamaAPI, data=json.dumps(llmQuery))
+    if result.status_code == 200:
+        result_json = result.json()
+        result = result_json.get("response", "")
+        # deepseek has added <think> </think> tags to the response
+        if "<think>" in result:
+            result = result.split("</think>")[1]
+    else:
+        raise Exception(f"HTTP Error: {result.status_code}")
+    return result
+
+def send_ollama_tooling_query(prompt, functions, model=None, max_tokens=450):
+    """
+    Send a prompt and function/tool definitions to Ollama API for function calling.
+    :param prompt: The user prompt string.
+    :param functions: List of function/tool definitions (see Ollama API docs).
+    :param model: Model name (optional, defaults to llmModel).
+    :param max_tokens: Max tokens for response.
+    :return: Ollama API response JSON.
+    """
+    if model is None:
+        model = llmModel
+    payload = {
+        "model": model,
+        "prompt": prompt,
+        "functions": functions,
+        "stream": False,
+        "max_tokens": max_tokens
+    }
+    result = requests.post(ollamaAPI, data=json.dumps(payload))
+    if result.status_code == 200:
+        return result.json()
+    else:
+        raise Exception(f"HTTP Error: {result.status_code} - {result.text}")
 
 def llm_query(input, nodeID=0, location_name=None):
     global antiFloodLLM, llmChat_history
     googleResults = []
+
+    # if this is the first initialization of the LLM the query of " " should bring meshbotAIinit OTA shouldnt reach this?
+    # This is for LLM like gemma and others now?
+    if input == " " and rawLLMQuery:
+        logger.warning("System: These LLM models lack a traditional system prompt, they can be verbose and not very helpful be advised.")
+        input = meshbotAIinit
+    else:
+        input = input.strip()
+        # classic model for gemma2, deepseek-r1, etc
+        logger.debug(f"System: Using classic LLM model framework, ideally for gemma2, deepseek-r1, etc")
+
     if not location_name:
         location_name = "no location provided "
+    
+    # remove askai: and ask: from the input
+    for trap in trap_list_llm:
+        if input.lower().startswith(trap):
+            input = input[len(trap):].strip()
+            break
 
     # add the naughty list here to stop the function before we continue
     # add a list of allowed nodes only to use the function
@@ -83,29 +244,13 @@ def llm_query(input, nodeID=0, location_name=None):
     else:
         antiFloodLLM.append(nodeID)
 
-    if llmContext_fromGoogle:
-        # grab some context from the internet using google search hits (if available)
-        # localization details at https://pypi.org/project/googlesearch-python/
-
-        # remove common words from the search query
-        # commonWordsList = ["is", "for", "the", "of", "and", "in", "on", "at", "to", "with", "by", "from", "as", "a", "an", "that", "this", "these", "those", "there", "here", "where", "when", "why", "how", "what", "which", "who", "whom", "whose", "whom"]
-        # sanitizedSearch = ' '.join([word for word in input.split() if word.lower() not in commonWordsList])
-
-        try:
-            googleSearch = search(input, advanced=True, num_results=googleSearchResults)
-            if googleSearch:
-                for result in googleSearch:
-                    # SearchResult object has url= title= description= just grab title and description
-                    googleResults.append(f"{result.title} {result.description}")
-            else:
-                googleResults = ['no other context provided']
-        except Exception as e:
-            logger.debug(f"System: LLM Query: context gathering failed, likely due to network issues")
-            googleResults = ['no other context provided']
+    if llmContext_fromGoogle and not rawLLMQuery:
+        googleResults = get_google_context(input, googleSearchResults)
 
+    history = llmChat_history.get(nodeID, ["", ""])
 
     if googleResults:
-        logger.debug(f"System: LLM Query: {input} From:{nodeID} with context from google")
+        logger.debug(f"System: Google-Enhanced LLM Query: {input} From:{nodeID}")
     else:
         logger.debug(f"System: LLM Query: {input} From:{nodeID}")
     
@@ -114,38 +259,42 @@ def llm_query(input, nodeID=0, location_name=None):
     location_name += f" at the current time of {datetime.now().strftime('%Y-%m-%d %H:%M:%S %Z')}"
 
     try:
-        result = chain_prompt_model.invoke({"input": input, "llmModel": llmModel, "userID": nodeID, \
-                                            "history": llmChat_history, "context": googleResults, "location_name": location_name})
+        if rawLLMQuery:
+            # sanitize the input to remove tool call syntax
+            if '```' in input:
+                logger.warning("System: LLM Query: Code markdown detected, removing for raw query")
+            input = input.replace('```bash', '').replace('```python', '').replace('```', '')
+            modelPrompt = input
+        else:
+            # Build the query from the template
+            modelPrompt = meshBotAI.format(input=input, context='\n'.join(googleResults), location_name=location_name, llmModel=llmModel, history=history)
+            
+        llmQuery = {"model": llmModel, "prompt": modelPrompt, "stream": False, "max_tokens": tokens}
+        # Query the model via Ollama web API
+        result = send_ollama_query(llmQuery)
+
         #logger.debug(f"System: LLM Response: " + result.strip().replace('\n', ' '))
     except Exception as e:
+        antiFloodLLM.remove(nodeID)  # Ensure removal on error
         logger.warning(f"System: LLM failure: {e}")
-        return "I am having trouble processing your request, please try again later."
+        return "⛔️I am having trouble processing your request, please try again later."
     
-
+    # cleanup for message output
     response = result.strip().replace('\n', ' ')
+    
+    if rawLLMQuery and requestTruncation and len(response) > 450:
+        #retryy loop to truncate the response
+        logger.warning(f"System: LLM Query: Response exceeded {tokens} characters, requesting truncation")
+        truncateQuery = {"model": llmModel, "prompt": truncatePrompt + response, "stream": False, "max_tokens": tokens}
+        truncateResult = send_ollama_query(truncateQuery)
 
-    # Store history of the conversation, with limit to prevent template growing too large causing speed issues
-    if len(llmChat_history) > llm_history_limit:
-        # remove the oldest two messages
-        llmChat_history.pop(0)
-        llmChat_history.pop(1)
-    inputWithUserID = input + f"   user={nodeID}"
-    llmChat_history.append(HumanMessage(content=inputWithUserID))
-    llmChat_history.append(AIMessage(content=response))
+        # cleanup for message output
+        response = result.strip().replace('\n', ' ')
 
     # done with the query, remove the user from the anti flood list
     antiFloodLLM.remove(nodeID)
 
-    return response
+    if llmEnableHistory:
+        llmChat_history[nodeID] = [input, response]
 
-# import subprocess
-# def get_ollama_cpu():
-#     try:
-#         psOutput = subprocess.run(['ollama', 'ps'], capture_output=True, text=True)
-#         if "GPU" in psOutput.stdout:
-#             logger.debug(f"System: Ollama process with GPU")
-#         else:
-#             logger.debug(f"System: Ollama process with CPU, query time will be slower")
-#     except Exception as e:
-#         logger.debug(f"System: Ollama process not found, {e}")
-#         return False
+    return response

modules/log.py

@@ -1,10 +1,13 @@
-# Custom logger for MeshBot and PongBot
-# you can change the sdtout_handler level to logging.INFO to only show INFO level logs
-# stdout_handler.setLevel(logging.INFO)vs stdout_handler.setLevel(logging.DEBUG)
-# 2024 Kelly Keeton K7MHI
 import logging
-from datetime import datetime
+from logging.handlers import TimedRotatingFileHandler
+import re
+from datetime import datetime, timedelta
 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'
@@ -33,10 +36,17 @@ class CustomFormatter(logging.Formatter):
         log_fmt = self.FORMATS.get(record.levelno)
         formatter = logging.Formatter(log_fmt)
         return formatter.format(record)
+    
+class plainFormatter(logging.Formatter):
+    ansi_escape = re.compile(r'\x1b\[([0-9]+)(;[0-9]+)*m')
+
+    def format(self, record):
+        message = super().format(record)
+        return self.ansi_escape.sub('', message)
 
 # 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")
@@ -51,22 +61,36 @@ 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
 logger.addHandler(stdout_handler)
+
 if syslog_to_file:
     # Create file handler for logging to a file
-    file_handler = logging.FileHandler('logs/system{}.log'.format(today.strftime('%Y_%m_%d')))
-    file_handler.setLevel(logging.DEBUG) # DEBUG used by default for system logs to disk
-    file_handler.setFormatter(logging.Formatter(logFormat))
-    logger.addHandler(file_handler)
+    file_handler_sys = TimedRotatingFileHandler('logs/meshbot.log', when='midnight', backupCount=log_backup_count, encoding='utf-8')
+    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)
 
 if log_messages_to_file:
     # Create file handler for logging to a file
-    file_handler = logging.FileHandler('logs/messages{}.log'.format(today.strftime('%Y_%m_%d')))
+    file_handler = TimedRotatingFileHandler('logs/messages.log', when='midnight', backupCount=log_backup_count, encoding='utf-8')
     file_handler.setLevel(logging.INFO) # INFO used for messages to disk
     file_handler.setFormatter(logging.Formatter(msgLogFormat))
     msgLogger.addHandler(file_handler)
+
+# Pretty Timestamp
+def getPrettyTime(seconds):
+    # convert unix time to minutes, hours, days, or years for simple display
+    if seconds < 60:
+        return f"{int(seconds)}s"
+    elif seconds < 3600:
+        return f"{int(round(seconds / 60))}m"
+    elif seconds < 86400:
+        return f"{int(round(seconds / 3600))}h"
+    elif seconds < 31536000:
+        return f"{int(round(seconds / 86400))}d"
+    else:
+        return f"{int(round(seconds / 31536000))}y"

modules/qrz.py

@@ -0,0 +1,57 @@
+# 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:
+            # we have not seen this node before
+            return True
+        else:
+            # we have seen this node before
+            return False
+    except sqlite3.OperationalError as e:
+        if "no such table" in str(e):
+            initalize_qrz_database()
+            logger.warning("QRZ database table not found, created new table")
+            # we have not seen this node before
+            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, str(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, str(name)))
+        else:
+            raise
+    conn.commit()
+    conn.close()
+    return True
+
+
+    

modules/radio.py

@@ -1,13 +1,105 @@
 # meshing around with hamlib as a source for info to send to mesh network
 # detect signal strength and frequency of active channel if appears to be in use send to mesh network
 # depends on rigctld running externally as a network service
+# also can use VOX detection with a microphone and vosk speech to text to send voice messages to mesh network
+# requires vosk and sounddevice python modules. will auto download needed. more from https://alphacephei.com/vosk/models and unpack
 # 2024 Kelly Keeton K7MHI
 
-import socket
-import asyncio
 from modules.log import *
+import asyncio
+
+# verbose debug logging for trap words function
+debugVoxTmsg = False
+
+
+if radio_detection_enabled:
+    # used by hamlib detection
+    import socket
+
+if voxDetectionEnabled:
+    # methods available for trap word processing, these can be called by VOX detection when trap words are detected
+    from mesh_bot import tell_joke, handle_wxc, handle_moon, handle_sun, handle_riverFlow, handle_tide, handle_satpass
+    botMethods = {
+        "joke": tell_joke,
+        "weather": handle_wxc,
+        "moon": handle_moon,
+        "daylight": handle_sun,
+        "river": handle_riverFlow,
+        "tide": handle_tide,
+        "satellite": handle_satpass}
+    # module global variables
+    previousVoxState = False
+    voxHoldTime = signalHoldTime
+
+    try:
+        import sounddevice as sd # pip install sounddevice    sudo apt install portaudio19-dev
+        from vosk import Model, KaldiRecognizer # pip install vosk
+        import json
+        q = asyncio.Queue(maxsize=32)  # queue for audio data
+        
+        if useLocalVoxModel:
+            voxModel = Model(lang=localVoxModelPath) # use built in model for specified language
+        else:
+            voxModel = Model(lang=voxLanguage) # use built in model for specified language
+
+    except Exception as e:
+        print(f"RadioMon: Error importing VOX dependencies: {e}")
+        print(f"To use VOX detection please install the vosk and sounddevice python modules")
+        print(f"pip install vosk sounddevice")
+        print(f"sounddevice needs pulseaudio,  apt-get install portaudio19-dev")
+        voxDetectionEnabled = False
+        logger.error(f"RadioMon: VOX detection disabled due to import error")
+
+FREQ_NAME_MAP = {
+    462562500: "GRMS CH1",
+    462587500: "GRMS CH2",
+    462612500: "GRMS CH3",
+    462637500: "GRMS CH4",
+    462662500: "GRMS CH5",
+    462687500: "GRMS CH6",
+    462712500: "GRMS CH7",
+    467562500: "GRMS CH8",
+    467587500: "GRMS CH9",
+    467612500: "GRMS CH10",
+    467637500: "GRMS CH11",
+    467662500: "GRMS CH12",
+    467687500: "GRMS CH13",
+    467712500: "GRMS CH14",
+    467737500: "GRMS CH15",
+    462550000: "GRMS CH16",
+    462575000: "GMRS CH17",
+    462600000: "GMRS CH18",
+    462625000: "GMRS CH19",
+    462675000: "GMRS CH20",
+    462670000: "GMRS CH21",
+    462725000: "GMRS CH22",
+    462725500: "GMRS CH23",
+    467575000: "GMRS CH24",
+    467600000: "GMRS CH25",
+    467625000: "GMRS CH26",
+    467650000: "GMRS CH27",
+    467675000: "GMRS CH28",
+    467700000: "FRS CH1",
+    462650000: "FRS CH5",
+    462700000: "FRS CH7",
+    462737500: "FRS CH16",
+    146520000: "2M Simplex Calling",
+    446000000: "70cm Simplex Calling",
+    156800000: "Marine CH16",
+    # Add more as needed
+}
+
+def get_freq_common_name(freq):
+    freq = int(freq)
+    name = FREQ_NAME_MAP.get(freq)
+    if name:
+        return name
+    else:
+        # Return MHz if not found
+        return f"{freq/1000000} Mhz"
 
 def get_hamlib(msg="f"):
+    # get data from rigctld server
     try:
         rigControlSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         rigControlSocket.settimeout(2)
@@ -29,110 +121,47 @@ def get_hamlib(msg="f"):
     except Exception as e:
         logger.error(f"RadioMon: Error fetching data from rigctld: {e}")
         return ERROR_FETCHING_DATA
-
-def get_freq_common_name(freq):
-    freq = int(freq)
-    if freq == 462562500:
-        return "GRMS CH1"
-    elif freq == 462587500:
-        return "GRMS CH2"
-    elif freq == 462612500:
-        return "GRMS CH3"
-    elif freq == 462637500:
-        return "GRMS CH4"
-    elif freq == 462662500:
-        return "GRMS CH5"
-    elif freq == 462687500:
-        return "GRMS CH6"
-    elif freq == 462712500:
-        return "GRMS CH7"
-    elif freq == 467562500:
-        return "GRMS CH8"
-    elif freq == 467587500:
-        return "GRMS CH9"
-    elif freq == 467612500:
-        return "GRMS CH10"
-    elif freq == 467637500:
-        return "GRMS CH11"
-    elif freq == 467662500:
-        return "GRMS CH12"
-    elif freq == 467687500:
-        return "GRMS CH13"
-    elif freq == 467712500:
-        return "GRMS CH14"
-    elif freq == 467737500:
-        return "GRMS CH15"
-    elif freq == 462550000:
-        return "GRMS CH16"
-    elif freq == 462575000:
-        return "GMRS CH17"
-    elif freq == 462600000:
-        return "GMRS CH18"
-    elif freq == 462625000:
-        return "GMRS CH19"
-    elif freq == 462675000:
-        return "GMRS CH20"
-    elif freq == 462670000:
-        return "GMRS CH21"
-    elif freq == 462725000:
-        return "GMRS CH22"
-    elif freq == 462725500:
-        return "GMRS CH23"
-    elif freq == 467575000:
-        return "GMRS CH24"
-    elif freq == 467600000:
-        return "GMRS CH25"
-    elif freq == 467625000:
-        return "GMRS CH26"
-    elif freq == 467650000:
-        return "GMRS CH27"
-    elif freq == 467675000:
-        return "GMRS CH28"
-    elif freq == 467700000:
-        return "FRS CH1"
-    elif freq == 462575000:
-        return "FRS CH2"
-    elif freq == 462600000:
-        return "FRS CH3"
-    elif freq == 462650000:
-        return "FRS CH5"
-    elif freq == 462675000:
-        return "FRS CH6"
-    elif freq == 462700000:
-        return "FRS CH7"
-    elif freq == 462725000:
-        return "FRS CH8"
-    elif freq == 462562500:
-        return "FRS CH9"
-    elif freq == 462587500:
-        return "FRS CH10"
-    elif freq == 462612500:
-        return "FRS CH11"
-    elif freq == 462637500:
-        return "FRS CH12"
-    elif freq == 462662500:
-        return "FRS CH13"
-    elif freq == 462687500:
-        return "FRS CH14"
-    elif freq == 462712500:
-        return "FRS CH15"
-    elif freq == 462737500:
-        return "FRS CH16"
-    elif freq == 146520000:
-        return "2M Simplex Calling"
-    elif freq == 446000000:
-        return "70cm Simplex Calling"
-    elif freq == 156800000:
-        return "Marine CH16"
-    else:
-        #return Mhz
-        freq = freq/1000000
-        return f"{freq} Mhz"
     
 def get_sig_strength():
     strength = get_hamlib('l STRENGTH')
     return strength
 
+def checkVoxTrapWords(text):
+    try:
+        if not voxOnTrapList:
+            logger.debug(f"RadioMon: VOX detected: {text}")
+            return text
+        if text:
+            traps = [voxTrapList] if isinstance(voxTrapList, str) else voxTrapList
+            text_lower = text.lower()
+            for trap in traps:
+                trap_clean = trap.strip()
+                trap_lower = trap_clean.lower()
+                idx = text_lower.find(trap_lower)
+                if debugVoxTmsg:
+                    logger.debug(f"RadioMon: VOX checking for trap word '{trap_lower}' in: '{text}' (index: {idx})")
+                if idx != -1:
+                    new_text = text[idx + len(trap_clean):].strip()
+                    if debugVoxTmsg:
+                        logger.debug(f"RadioMon: VOX detected trap word '{trap_lower}' in: '{text}' (remaining: '{new_text}')")
+                    new_words = new_text.split()
+                    if voxEnableCmd:
+                        for word in new_words:
+                            if word in botMethods:
+                                logger.info(f"RadioMon: VOX action '{word}' with '{new_text}'")
+                                if word == "joke":
+                                    return botMethods[word](vox=True)
+                                else:
+                                    return botMethods[word](None, None, None, vox=True)
+                    logger.debug(f"RadioMon: VOX returning text after trap word '{trap_lower}': '{new_text}'")
+                    return new_text
+            if debugVoxTmsg:
+                logger.debug(f"RadioMon: VOX no trap word found in: '{text}'")
+        return None
+    except Exception as e:
+        logger.debug(f"RadioMon: Error in checkVoxTrapWords: {e}")
+        return None
+
 async def signalWatcher():
     global previousStrength
     global signalCycle
@@ -157,4 +186,61 @@ async def signalWatcher():
         signalCycle = 0
         previousStrength = -40
 
-# end of file
+async def make_vox_callback(loop, q):
+    def vox_callback(indata, frames, time, status):
+        if status:
+            logger.warning(f"RadioMon: VOX input status: {status}")
+        try:
+            loop.call_soon_threadsafe(q.put_nowait, bytes(indata))
+        except asyncio.QueueFull:
+            # Drop the oldest item and add the new one
+            try:
+                q.get_nowait()  # Remove oldest
+            except asyncio.QueueEmpty:
+                pass
+            try:
+                loop.call_soon_threadsafe(q.put_nowait, bytes(indata))
+            except asyncio.QueueFull:
+                # If still full, just drop this frame
+                logger.debug("RadioMon: VOX queue full, dropping audio frame")
+        except RuntimeError:
+            # Loop may be closed
+            pass
+    return vox_callback
+ 
+async def voxMonitor():
+    global previousVoxState, voxMsgQueue
+    try:
+        model = voxModel
+        device_info = sd.query_devices(voxInputDevice, 'input')
+        samplerate = 16000
+        logger.debug(f"RadioMon: VOX monitor started on device {device_info['name']} with samplerate {samplerate} using trap words: {voxTrapList if voxOnTrapList else 'none'}")
+        rec = KaldiRecognizer(model, samplerate)
+        loop = asyncio.get_running_loop()
+        callback = await make_vox_callback(loop, q)
+        with sd.RawInputStream(
+            device=voxInputDevice,
+            samplerate=samplerate,
+            blocksize=4000,
+            dtype='int16',
+            channels=1,
+            callback=callback
+        ):
+            while True:
+                data = await q.get()
+                if rec.AcceptWaveform(data):
+                    result = rec.Result()
+                    text = json.loads(result).get("text", "")
+                    # process text
+                    if text and text != 'huh':
+                        result = checkVoxTrapWords(text)
+                        if result:
+                            # If result is a function return, handle it (send to mesh, log, etc.)
+                            # If it's just text, handle as a normal message
+                            voxMsgQueue.append(result)
+
+                await asyncio.sleep(0.1)
+    except Exception as e:
+        logger.error(f"RadioMon: Error in VOX monitor: {e}")
+
+# end of file

modules/rss.py

@@ -0,0 +1,95 @@
+# rss feed module for meshing-around 2025
+from modules.log import *
+import urllib.request
+import xml.etree.ElementTree as ET
+import html
+from html.parser import HTMLParser
+
+class MLStripper(HTMLParser):
+    def __init__(self):
+        super().__init__()
+        self.reset()
+        self.fed = []
+    def handle_data(self, d):
+        self.fed.append(d)
+    def get_data(self):
+        return ''.join(self.fed)
+
+def strip_tags(html_text):
+    s = MLStripper()
+    s.feed(html_text)
+    return s.get_data()
+
+RSS_FEED_URLS = rssFeedURL
+RSS_FEED_NAMES = rssFeedNames
+RSS_RETURN_COUNT = rssMaxItems
+RSS_TRIM_LENGTH = rssTruncate
+
+def get_rss_feed(msg):
+    # Determine which feed to use
+    feed_name = ""
+    msg_lower = msg.lower() if msg else ""
+    if msg_lower and any(name.lower() in msg_lower for name in RSS_FEED_NAMES):
+        for name in RSS_FEED_NAMES:
+            if name.lower() in msg_lower:
+                feed_name = name
+                break
+    else:
+        logger.debug(f"RSS: No feed name found in message '{msg}'. Using default feed.")
+        feed_name = RSS_FEED_NAMES[0] if RSS_FEED_NAMES else "default"
+
+    try:
+        idx = RSS_FEED_NAMES.index(feed_name)
+        feed_url = RSS_FEED_URLS[idx]
+    except (ValueError, IndexError):
+        logger.warning(f"RSS: Feed '{feed_name}' not found in RSS_FEED_URLS ({RSS_FEED_URLS}).")
+        return f"Feed '{feed_name}' not found."
+
+    if "?" in msg_lower:
+        return f"Fetches the latest {RSS_RETURN_COUNT} entries RSS feeds. Available feeds are: {', '.join(RSS_FEED_NAMES)}. To fetch a specific feed, include its name in your request."
+
+    try:
+        logger.debug(f"Fetching RSS feed from {feed_url} from message '{msg}'")
+        agent = {'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3'}
+        request = urllib.request.Request(feed_url, headers=agent)
+        with urllib.request.urlopen(request, timeout=urlTimeoutSeconds) as response:
+            xml_data = response.read()
+        root = ET.fromstring(xml_data)
+        # Try both namespaced and non-namespaced item tags
+        items = root.findall('.//item')
+        ns = None
+        if not items:
+            # Try to find the namespace dynamically
+            for elem in root.iter():
+                if elem.tag.endswith('item'):
+                    ns_uri = elem.tag.split('}')[0].strip('{')
+                    items = root.findall(f'.//{{{ns_uri}}}item')
+                    ns = ns_uri
+                    break
+        items = items[:RSS_RETURN_COUNT]
+        if not items:
+            return "No RSS feed entries found."
+        formatted_entries = []
+        for item in items:
+            if ns:
+                title = item.findtext(f'{{{ns}}}title', default='No title')
+                link = item.findtext(f'{{{ns}}}link', default=None)
+                description = item.findtext(f'{{{ns}}}description', default='No description')
+                pub_date = item.findtext(f'{{{ns}}}pubDate', default='No date')
+            else:
+                title = item.findtext('title', default='No title')
+                link = item.findtext('link', default=None)
+                description = item.findtext('description', default='No description')
+                pub_date = item.findtext('pubDate', default='No date')
+
+            # Unescape HTML entities and strip tags
+            description = html.unescape(description)
+            description = strip_tags(description)
+            if len(description) > RSS_TRIM_LENGTH:
+                description = description[:RSS_TRIM_LENGTH - 3] + "..."
+
+            formatted_entries.append(f"{title}\n{description}\n")
+        return "\n".join(formatted_entries)
+    except Exception as e:
+        logger.error(f"Error fetching RSS feed from {feed_url}: {e}")
+        return ERROR_FETCHING_DATA

modules/scheduler.py

@@ -0,0 +1,104 @@
+# modules/scheduler.py 2025 meshing-around
+import schedule
+from modules.log import logger
+from modules.system import send_message, BroadcastScheduler
+from modules.system import send_message
+# methods available for custom scheduler messages
+from mesh_bot import tell_joke, welcome_message, MOTD, handle_wxc, handle_moon, handle_sun, handle_riverFlow, handle_tide, handle_satpass
+
+async def setup_scheduler(
+    schedulerMotd, MOTD, schedulerMessage, schedulerChannel, schedulerInterface,
+    schedulerValue, schedulerTime, schedulerInterval, logger, BroadcastScheduler
+):
+    schedulerValue = schedulerValue.lower().strip()
+    schedulerTime = schedulerTime.strip()
+    schedulerInterval = schedulerInterval.strip()
+    schedulerChannel = int(schedulerChannel)
+    schedulerInterface = int(schedulerInterface)
+    # Setup the scheduler based on configuration
+    try:
+        if schedulerMotd:
+            scheduler_message = MOTD
+        else:
+            scheduler_message = schedulerMessage
+
+        # Basic Scheduler Options
+        if 'custom' not in schedulerValue:
+            # Basic scheduler job to run the schedule see examples below for custom schedules
+            if schedulerValue.lower() == 'day':
+                if schedulerTime != '':
+                    schedule.every().day.at(schedulerTime).do(lambda: send_message(scheduler_message, schedulerChannel, 0, schedulerInterface))
+                else:
+                    schedule.every(int(schedulerInterval)).days.do(lambda: send_message(scheduler_message, schedulerChannel, 0, schedulerInterface))
+            elif 'mon' in schedulerValue.lower() and schedulerTime != '':
+                schedule.every().monday.at(schedulerTime).do(lambda: send_message(scheduler_message, schedulerChannel, 0, schedulerInterface))
+            elif 'tue' in schedulerValue.lower() and schedulerTime != '':
+                schedule.every().tuesday.at(schedulerTime).do(lambda: send_message(scheduler_message, schedulerChannel, 0, schedulerInterface))
+            elif 'wed' in schedulerValue.lower() and schedulerTime != '':
+                schedule.every().wednesday.at(schedulerTime).do(lambda: send_message(scheduler_message, schedulerChannel, 0, schedulerInterface))
+            elif 'thu' in schedulerValue.lower() and schedulerTime != '':
+                schedule.every().thursday.at(schedulerTime).do(lambda: send_message(scheduler_message, schedulerChannel, 0, schedulerInterface))
+            elif 'fri' in schedulerValue.lower() and schedulerTime != '':
+                schedule.every().friday.at(schedulerTime).do(lambda: send_message(scheduler_message, schedulerChannel, 0, schedulerInterface))
+            elif 'sat' in schedulerValue.lower() and schedulerTime != '':
+                schedule.every().saturday.at(schedulerTime).do(lambda: send_message(scheduler_message, schedulerChannel, 0, schedulerInterface))
+            elif 'sun' in schedulerValue.lower() and schedulerTime != '':
+                schedule.every().sunday.at(schedulerTime).do(lambda: send_message(scheduler_message, schedulerChannel, 0, schedulerInterface))
+            elif 'hour' in schedulerValue.lower():
+                schedule.every(int(schedulerInterval)).hours.do(lambda: send_message(scheduler_message, schedulerChannel, 0, schedulerInterface))
+            elif 'min' in schedulerValue.lower():
+                schedule.every(int(schedulerInterval)).minutes.do(lambda: send_message(scheduler_message, schedulerChannel, 0, schedulerInterface))
+            logger.debug(f"System: Starting the basic scheduler to send '{scheduler_message}' on schedule '{schedulerValue}' every {schedulerInterval} interval at time '{schedulerTime}' on Device:{schedulerInterface} Channel:{schedulerChannel}")
+        else:
+            # Default schedule if no valid configuration is provided
+
+            # custom scheduler job to run the schedule see examples below
+            logger.debug(f"System: Starting the scheduler to send reminder every Monday at noon on Device:{schedulerInterface} Channel:{schedulerChannel}")
+            schedule.every().monday.at("12:00").do(lambda: logger.info("System: Scheduled Broadcast Enabled Reminder"))
+            
+            # send a joke every 15 minutes
+            #schedule.every(15).minutes.do(lambda: send_message(tell_joke(), schedulerChannel, 0, schedulerInterface))
+
+        # Start the Broadcast Scheduler
+        await BroadcastScheduler()
+    except Exception as e:
+        logger.error(f"System: Scheduler Error {e}")
+
+# Enhanced Examples of using the scheduler, Times here are in 24hr format
+# https://schedule.readthedocs.io/en/stable/
+
+# Good Morning Every day at 09:00 using send_message function to channel 2 on device 1
+#schedule.every().day.at("09:00").do(lambda: send_message("Good Morning", 2, 0, 1))
+
+# Send WX every Morning at 08:00 using handle_wxc function to channel 2 on device 1
+#schedule.every().day.at("08:00").do(lambda: send_message(handle_wxc(0, 1, 'wx'), 2, 0, 1))
+
+# Send Weather Channel Notice Wed. Noon on channel 2, device 1
+#schedule.every().wednesday.at("12:00").do(lambda: send_message("Weather alerts available on 'Alerts' channel with default 'AQ==' key.", 2, 0, 1))
+
+# Send config URL for Medium Fast Network Use every other day at 10:00 to default channel 2 on device 1
+#schedule.every(2).days.at("10:00").do(lambda: send_message("Join us on Medium Fast https://meshtastic.org/e/#CgcSAQE6AggNEg4IARAEOAFAA0gBUB5oAQ", 2, 0, 1))
+
+# Send a Net Starting Now Message Every Wednesday at 19:00 using send_message function to channel 2 on device 1
+#schedule.every().wednesday.at("19:00").do(lambda: send_message("Net Starting Now", 2, 0, 1))
+
+# Send a Welcome Notice for group on the 15th and 25th of the month at 12:00 using send_message function to channel 2 on device 1
+#schedule.every().day.at("12:00").do(lambda: send_message("Welcome to the group", 2, 0, 1)).day(15, 25)
+
+# Send a Welcome Notice for group on the 15th and 25th of the month at 12:00
+#schedule.every().day.at("12:00").do(lambda: send_message("Welcome to the group", schedulerChannel, 0, schedulerInterface)).day(15, 25)
+
+# Send a joke every 6 hours
+#schedule.every(6).hours.do(lambda: send_message(tell_joke(), schedulerChannel, 0, schedulerInterface))
+
+# Send a joke every 2 minutes
+#schedule.every(2).minutes.do(lambda: send_message(tell_joke(), schedulerChannel, 0, schedulerInterface))
+
+# Send the Welcome Message every other day at 08:00
+#schedule.every(2).days.at("08:00").do(lambda: send_message(welcome_message, schedulerChannel, 0, schedulerInterface))
+
+# Send the MOTD every day at 13:00
+#schedule.every().day.at("13:00").do(lambda: send_message(MOTD, schedulerChannel, 0, schedulerInterface))
+
+# Send bbslink looking for peers every other day at 10:00
+#schedule.every(2).days.at("10:00").do(lambda: send_message("bbslink MeshBot looking for peers", schedulerChannel, 0, schedulerInterface))

modules/settings.py

@@ -5,9 +5,10 @@ import configparser
 # messages
 NO_DATA_NOGPS = "No location data: does your device have GPS?"
 ERROR_FETCHING_DATA = "error fetching data"
-WELCOME_MSG = 'MeshBot, here for you like a friend who is not. Try sending: ping @foo  or, cmd? for more'
+WELCOME_MSG = 'MeshBot, here for you like a friend who is not. Try sending: ping @foo  or, CMD? for more'
+EMERGENCY_RESPONSE = "MeshBot detected a possible request for Emergency Assistance and alerted a wider audience."
 MOTD = 'Thanks for using MeshBOT! Have a good day!'
-NO_ALERTS = "No weather alerts found."
+NO_ALERTS = "No alerts found."
 
 # setup the global variables
 SITREP_NODE_COUNT = 3 # number of nodes to report in the sitrep
@@ -19,65 +20,110 @@ antiSpam = True # anti-spam feature to prevent flooding public channel
 ping_enabled = True # ping feature to respond to pings, ack's etc.
 sitrep_enabled = True # sitrep feature to respond to sitreps
 lastHamLibAlert = 0 # last alert from hamlib
-max_retry_count1 = 4 # max retry count for interface 1
-max_retry_count2 = 4 # max retry count for interface 2
+lastFileAlert = 0 # last alert from file monitor
+max_retry_count1 = max_retry_count2 = max_retry_count3 = max_retry_count4 = max_retry_count5 = max_retry_count6 = max_retry_count7 = max_retry_count8 = max_retry_count9 = 4 # default retry count for interfaces
 retry_int1 = False
 retry_int2 = False
-scheduler_enabled = False # enable the scheduler currently config via code only
 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
+cmdHistory = [] # list to hold the command history for lheard and history commands
+msg_history = [] # list to hold the message history for the messages command
+max_bytes = 200 # Meshtastic has ~237 byte limit, use conservative 200 bytes for message content
+voxMsgQueue = [] # queue for VOX detected messages
+# Game trackers
+surveyTracker = []           # Survey game tracker
+tictactoeTracker = []        # TicTacToe game tracker
+hamtestTracker = []          # Ham radio test tracker
+hangmanTracker = []          # Hangman game tracker
+golfTracker = []             # GolfSim game tracker
+mastermindTracker = []       # Mastermind game tracker
+vpTracker = []               # Video Poker game tracker
+jackTracker = []             # Blackjack game tracker
+lemonadeTracker = []         # Lemonade Stand game tracker
+dwPlayerTracker = []         # DopeWars player tracker
+jackTracker = []             # Jack game tracker
+mindTracker = []             # Mastermind (mmind) game tracker
 
 # Read the config file, if it does not exist, create basic config file
 config = configparser.ConfigParser() 
 config_file = "config.ini"
 
 try:
-    config.read(config_file)
+    config.read(config_file, encoding='utf-8')
 except Exception as e:
     print(f"System: Error reading config file: {e}")
+    # exit if we can't read the config file
+    print(f"System: Check the config.ini against config.template file for missing sections or values.")
+    print(f"System: Exiting...")
+    exit(1)
 
 if config.sections() == []:
     print(f"System: Error reading config file: {config_file} is empty or does not exist.")
     config['interface'] = {'type': 'serial', 'port': "/dev/ttyACM0", 'hostname': '', 'mac': ''}
-    config['general'] = {'respond_by_dm_only': 'True', 'defaultChannel': '0', 'motd': MOTD,
-                         'welcome_message': WELCOME_MSG, 'zuluTime': 'False'}
+    config['general'] = {'respond_by_dm_only': 'True', 'defaultChannel': '0', 'motd': MOTD, 'welcome_message': WELCOME_MSG, 'zuluTime': 'False'}
     config.write(open(config_file, 'w'))
     print (f"System: Config file created, check {config_file} or review the config.template")
 
 if 'sentry' not in config:
-        config['Sentry'] = {'SentryEnabled': 'False', 'SentryChannel': '2', 'SentryHoldoff': '9', 'sentryIgnoreList': '', 'SentryRadius': '100'}
-        config.write(open(config_file, 'w'))
+    config['sentry'] = {'SentryEnabled': 'False', 'SentryChannel': '2', 'SentryHoldoff': '9', 'sentryIgnoreList': '', 'SentryRadius': '100'}
+    config.write(open(config_file, 'w'))
 
 if 'location' not in config:
-        config['location'] = {'enabled': 'True', 'lat': '48.50', 'lon': '-123.0', 'UseMeteoWxAPI': 'False', 'useMetric': 'False', 'NOAAforecastDuration': '4', 'NOAAalertCount': '2', 'NOAAalertsEnabled': 'True'}
-        config.write(open(config_file, 'w'))
+    config['location'] = {'enabled': 'True', 'lat': '48.50', 'lon': '-123.0', 'UseMeteoWxAPI': 'False', 'useMetric': 'False', 'NOAAforecastDuration': '4', 'NOAAalertCount': '2', 'NOAAalertsEnabled': 'True', 'wxAlertBroadcastEnabled': 'False', 'wxAlertBroadcastChannel': '2', 'repeaterLookup': 'rbook'}
+    config.write(open(config_file, 'w'))
 
 if 'bbs' not in config:
-        config['bbs'] = {'enabled': 'False', 'bbsdb': 'bbsdb.pkl', 'bbs_ban_list': '', 'bbs_admin_list': ''}
-        config.write(open(config_file, 'w'))
+    config['bbs'] = {'enabled': 'False', 'bbsdb': 'data/bbsdb.pkl', 'bbs_ban_list': '', 'bbs_admin_list': ''}
+    config.write(open(config_file, 'w'))
 
 if 'repeater' not in config:
-        config['repeater'] = {'enabled': 'False', 'repeater_channels': ''}
-        config.write(open(config_file, 'w'))
+    config['repeater'] = {'enabled': 'False', 'repeater_channels': ''}
+    config.write(open(config_file, 'w'))
 
 if 'radioMon' not in config:
-        config['radioMon'] = {'enabled': 'False', 'rigControlServerAddress': 'localhost:4532', 'sigWatchBrodcastCh': '2', 'signalDetectionThreshold': '-10', 'signalHoldTime': '10', 'signalCooldown': '5', 'signalCycleLimit': '5'}
-        config.write(open(config_file, 'w'))
+    config['radioMon'] = {'enabled': 'False', 'rigControlServerAddress': 'localhost:4532', 'sigWatchBrodcastCh': '2', 'signalDetectionThreshold': '-10', 'signalHoldTime': '10', 'signalCooldown': '5', 'signalCycleLimit': '5'}
+    config.write(open(config_file, 'w'))
 
 if 'games' not in config:
-        config['games'] = {'dopeWars': 'True', 'lemonade': 'True', 'blackjack': 'True', 'videoPoker': 'True'}
-        config.write(open(config_file, 'w'))
+    config['games'] = {'dopeWars': 'True', 'lemonade': 'True', 'blackjack': 'True', 'videoPoker': 'True'}
+    config.write(open(config_file, 'w'))
 
 if 'messagingSettings' not in config:
-        config['messagingSettings'] = {'responseDelay': '0.7', 'splitDelay': '0', 'MESSAGE_CHUNK_SIZE': '160'}
-        config.write(open(config_file, 'w'))
+    config['messagingSettings'] = {'responseDelay': '0.7', 'splitDelay': '0', 'MESSAGE_CHUNK_SIZE': '160'}
+    config.write(open(config_file, 'w'))
+
+if 'fileMon' not in config:
+    config['fileMon'] = {'enabled': 'False', 'file_path': 'alert.txt', 'broadcastCh': '2'}
+    config.write(open(config_file, 'w'))
+
+if 'scheduler' not in config:
+    config['scheduler'] = {'enabled': 'False'}
+    config.write(open(config_file, 'w'))
+
+if 'emergencyHandler' not in config:
+    config['emergencyHandler'] = {'enabled': 'False', 'alert_channel': '2', 'alert_interface': '1', 'email': ''}
+    config.write(open(config_file, 'w'))
+
+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:
@@ -89,81 +135,306 @@ if 'interface2' in config:
 else:
     interface2_enabled = False
 
-# variables
+# 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
     useDMForResponse = config['general'].getboolean('respond_by_dm_only', True)
     publicChannel = config['general'].getint('defaultChannel', 0) # the meshtastic public channel
+    ignoreChannels = config['general'].get('ignoreChannels', '').split(',') # ignore these channels
     ignoreDefaultChannel = config['general'].getboolean('ignoreDefaultChannel', False)
+    cmdBang = config['general'].getboolean('cmdBang', False) # default off
+    explicitCmd = config['general'].getboolean('explicitCmd', True) # default on
     zuluTime = config['general'].getboolean('zuluTime', False) # aka 24 hour time
-    log_messages_to_file = config['general'].getboolean('LogMessagesToFile', True) # default True
-    syslog_to_file = config['general'].getboolean('SyslogToFile', False)
-    urlTimeoutSeconds = config['general'].getint('urlTimeout', 10) # default 10 seconds
+    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', 15) # default 15 seconds for URL fetch timeout
     store_forward_enabled = config['general'].getboolean('StoreForward', True)
     storeFlimit = config['general'].getint('StoreLimit', 3) # default 3 messages for S&F
+    reverseSF = config['general'].getboolean('reverseSF', False) # default False, send oldest first
     welcome_message = config['general'].get('welcome_message', WELCOME_MSG)
     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)
+    use_kiwix_server = config['general'].getboolean('useKiwixServer', False)
+    kiwix_url = config['general'].get('kiwixURL', 'http://127.0.0.1:8080')
+    kiwix_library_name = config['general'].get('kiwixLibraryName', 'wikipedia_en_100_nopic_2024-06')
     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
+    llmModel = config['general'].get('ollamaModel', 'gemma3:270m') # default gemma3:270m
+    rawLLMQuery = config['general'].getboolean('rawLLMQuery', True) #default True
+    llmReplyToNonCommands = config['general'].getboolean('llmReplyToNonCommands', True) # default True
+    dont_retry_disconnect = config['general'].getboolean('dont_retry_disconnect', False) # default False, retry on disconnect
+    favoriteNodeList = config['general'].get('favoriteNodeList', '').split(',')
+    enableEcho = config['general'].getboolean('enableEcho', False) # default False
+    echoChannel = config['general'].getint('echoChannel', '9') # default 9, empty string to ignore
+    rssEnable = config['general'].getboolean('rssEnable', True) # default True
+    rssFeedURL = config['general'].get('rssFeedURL', 'http://www.hackaday.com/rss.xml,https://www.arrl.org/rss/arrl.rss').split(',')
+    rssMaxItems = config['general'].getint('rssMaxItems', 3) # default 3 items
+    rssTruncate = config['general'].getint('rssTruncate', 100) # default 100 characters
+    rssFeedNames = config['general'].get('rssFeedNames', 'default,arrl').split(',')
+
+    # emergency response
+    emergency_responder_enabled = config['emergencyHandler'].getboolean('enabled', False)
+    emergency_responder_alert_channel = config['emergencyHandler'].getint('alert_channel', 2) # default 2
+    emergency_responder_alert_interface = config['emergencyHandler'].getint('alert_interface', 1) # default 1
+    emergency_responder_email = config['emergencyHandler'].get('email', '').split(',')
 
     # sentry
     sentry_enabled = config['sentry'].getboolean('SentryEnabled', False) # default False
     secure_channel = config['sentry'].getint('SentryChannel', 2) # default 2
+    secure_interface = config['sentry'].getint('SentryInterface', 1) # default 1
     sentry_holdoff = config['sentry'].getint('SentryHoldoff', 9) # default 9
     sentryIgnoreList = config['sentry'].get('sentryIgnoreList', '').split(',')
     sentry_radius = config['sentry'].getint('SentryRadius', 100) # default 100 meters
+    email_sentry_alerts = config['sentry'].getboolean('emailSentryAlerts', False) # default False
+    highfly_enabled = config['sentry'].getboolean('highFlyingAlert', True) # default True
+    highfly_altitude = config['sentry'].getint('highFlyingAlertAltitude', 2000) # default 2000 meters
+    highfly_channel = config['sentry'].getint('highFlyingAlertChannel', 2) # default 2
+    highfly_interface = config['sentry'].getint('highFlyingAlertInterface', 1) # default 1
+    highfly_ignoreList = config['sentry'].get('highFlyingIgnoreList', '').split(',') # default empty
+    highfly_check_openskynetwork = config['sentry'].getboolean('highflyOpenskynetwork', True) # default True check with OpenSkyNetwork if highfly detected
+    detctionSensorAlert = config['sentry'].getboolean('detectionSensorAlert', False) # default False
+    reqLocationEnabled = config['sentry'].getboolean('reqLocationEnabled', False) # default False
 
     # location
     location_enabled = config['location'].getboolean('enabled', True)
     latitudeValue = config['location'].getfloat('lat', 48.50)
     longitudeValue = config['location'].getfloat('lon', -123.0)
+    fuzz_config_location = config['location'].getboolean('fuzzConfigLocation', True) # default True
+    fuzzItAll = config['location'].getboolean('fuzzAllLocations', False) # default False, only fuzz config location
     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 None
+    coastalEnabled = config['location'].getboolean('coastalEnabled', False) # default False
+    myCoastalZone = config['location'].get('myCoastalZone', None) # default None
+    coastalForecastDays = config['location'].getint('coastalForecastDays', 3) # default 3 days
+
+    # 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
+    ignoreEASenable = config['location'].getboolean('ignoreEASenable', False) # default False
+    ignoreEASwords = config['location'].get('ignoreEASwords', 'test,advisory').split(',') # default test,advisory
+    myRegionalKeysDE = config['location'].get('myRegionalKeysDE', '110000000000').split(',') # default city Berlin
     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
-   
+    enableExtraLocationWx = config['location'].getboolean('enableExtraLocationWx', False) # default False
+    myStateFIPSList = config['location'].get('myFIPSList', '').split(',') # default empty
+    mySAMEList = config['location'].get('mySAMEList', '').split(',') # default empty
+    ignoreFEMAenable = config['location'].getboolean('ignoreFEMAenable', True) # default True
+    ignoreFEMAwords = config['location'].get('ignoreFEMAwords', 'test,exercise').split(',') # default test,exercise
+    wxAlertBroadcastChannel = config['location'].get('wxAlertBroadcastCh', '2').split(',') # default Channel 2
+    emergencyAlertBroadcastCh = config['location'].get('eAlertBroadcastCh', '2').split(',') # default Channel 2
+    volcanoAlertBroadcastEnabled = config['location'].getboolean('volcanoAlertBroadcastEnabled', False) # default False
+    volcanoAlertBroadcastChannel = config['location'].get('volcanoAlertBroadcastCh', '2').split(',') # default Channel 2
+    ignoreUSGSEnable = config['location'].getboolean('ignoreVolcanoEnable', False) # default False
+    ignoreUSGSWords = config['location'].get('ignoreVolcanoWords', 'test,advisory').split(',') # default test,advisory
+    
     # bbs
     bbs_enabled = config['bbs'].getboolean('enabled', False)
-    bbsdb = config['bbs'].get('bbsdb', 'bbsdb.pkl')
+    bbsdb = config['bbs'].get('bbsdb', 'data/bbsdb.pkl')
     bbs_ban_list = config['bbs'].get('bbs_ban_list', '').split(',')
     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(',')
+    bbsAPI_enabled = config['bbs'].getboolean('bbsAPI_enabled', False)
+    
+    # checklist
+    checklist_enabled = config['checklist'].getboolean('enabled', False)
+    checklist_db = config['checklist'].get('checklist_db', 'data/checklist.db')
+    reverse_in_out = config['checklist'].getboolean('reverse_in_out', False)
+
+    # 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', 'MeshBot says Hello! DM for more info.')
+    train_qrz = config['qrz'].getboolean('training', True)
+    
+    # E-Mail Settings
+    sysopEmails = config['smtp'].get('sysopEmails', '').split(',')
+    enableSMTP = config['smtp'].getboolean('enableSMTP', False)
+    enableImap = config['smtp'].getboolean('enableImap', False)
+    SMTP_SERVER = config['smtp'].get('SMTP_SERVER', 'smtp.gmail.com')
+    SMTP_PORT = config['smtp'].getint('SMTP_PORT', 587)
+    FROM_EMAIL = config['smtp'].get('FROM_EMAIL', 'none@gmail.com')
+    SMTP_AUTH = config['smtp'].getboolean('SMTP_AUTH', True)
+    SMTP_USERNAME = config['smtp'].get('SMTP_USERNAME', FROM_EMAIL)
+    SMTP_PASSWORD = config['smtp'].get('SMTP_PASSWORD', 'password')
+    EMAIL_SUBJECT = config['smtp'].get('EMAIL_SUBJECT', 'Meshtastic✉️')
+    IMAP_SERVER = config['smtp'].get('IMAP_SERVER', 'imap.gmail.com')
+    IMAP_PORT = config['smtp'].getint('IMAP_PORT', 993)
+    IMAP_USERNAME = config['smtp'].get('IMAP_USERNAME', SMTP_USERNAME)
+    IMAP_PASSWORD = config['smtp'].get('IMAP_PASSWORD', SMTP_PASSWORD)
+    IMAP_FOLDER = config['smtp'].get('IMAP_FOLDER', 'inbox')
 
     # repeater
     repeater_enabled = config['repeater'].getboolean('enabled', False)
     repeater_channels = config['repeater'].get('repeater_channels', '').split(',')
 
+    # scheduler
+    scheduler_enabled = config['scheduler'].getboolean('enabled', False)
+    schedulerInterface = config['scheduler'].getint('interface', 1) # default interface 1
+    schedulerChannel = config['scheduler'].getint('channel', 2) # default channel 2
+    schedulerMessage = config['scheduler'].get('message', 'Scheduled message') # default message
+    schedulerInterval = config['scheduler'].get('interval', '') # default empty
+    schedulerTime = config['scheduler'].get('time', '') # default empty
+    schedulerValue = config['scheduler'].get('value', '') # default empty
+    schedulerMotd = config['scheduler'].getboolean('schedulerMotd', False) # default False
+
     # radio monitoring
     radio_detection_enabled = config['radioMon'].getboolean('enabled', False)
     rigControlServerAddress = config['radioMon'].get('rigControlServerAddress', 'localhost:4532') # default localhost:4532
     sigWatchBroadcastCh = config['radioMon'].get('sigWatchBroadcastCh', '2').split(',') # default Channel 2
+    sigWatchBroadcastInterface = config['radioMon'].getint('sigWatchBroadcastInterface', 1) # default interface 1
     signalDetectionThreshold = config['radioMon'].getint('signalDetectionThreshold', -10) # default -10 dBm
     signalHoldTime = config['radioMon'].getint('signalHoldTime', 10) # default 10 seconds
     signalCooldown = config['radioMon'].getint('signalCooldown', 5) # default 1 second
     signalCycleLimit = config['radioMon'].getint('signalCycleLimit', 5) # default 5 cycles, used with SIGNAL_COOLDOWN
-    
+    voxDetectionEnabled = config['radioMon'].getboolean('voxDetectionEnabled', False) # default VOX detection disabled
+    voxDescription = config['radioMon'].get('voxDescription', 'VOX') # default VOX detected audio message
+    useLocalVoxModel = config['radioMon'].getboolean('useLocalVoxModel', False) # default False
+    localVoxModelPath = config['radioMon'].get('localVoxModelPath', 'no') # default models/vox.tflite
+    voxLanguage = config['radioMon'].get('voxLanguage', 'en-US') # default en-US
+    voxInputDevice = config['radioMon'].get('voxInputDevice', 'default') # default default
+    voxOnTrapList = config['radioMon'].getboolean('voxOnTrapList', False) # default False
+    voxTrapList = config['radioMon'].get('voxTrapList', 'chirpy').split(',') # default chirpy
+    voxEnableCmd = config['radioMon'].getboolean('voxEnableCmd', True) # default True
+
+    # file monitor
+    file_monitor_enabled = config['fileMon'].getboolean('filemon_enabled', False)
+    file_monitor_file_path = config['fileMon'].get('file_path', 'alert.txt') # default alert.txt
+    file_monitor_broadcastCh = config['fileMon'].get('broadcastCh', '2').split(',') # default Channel 2
+    read_news_enabled = config['fileMon'].getboolean('enable_read_news', False) # default disabled
+    news_file_path = config['fileMon'].get('news_file_path', '../data/news.txt') # default ../data/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
+    allowXcmd = config['fileMon'].getboolean('allowXcmd', False) # default False
+    xCmd2factorEnabled = config['fileMon'].getboolean('2factor_enabled', True) # default True
+    xCmd2factor_timeout = config['fileMon'].getint('2factor_timeout', 100) # default 100 seconds
+
     # games
+    game_hop_limit = config['games'].getint('game_hop_limit', 5) # default 5 hops
+    disable_emojis_in_games = config['games'].getboolean('disable_emojis', False) # default False
     dopewars_enabled = config['games'].getboolean('dopeWars', True)
     lemonade_enabled = config['games'].getboolean('lemonade', True)
     blackjack_enabled = config['games'].getboolean('blackjack', True)
     videoPoker_enabled = config['games'].getboolean('videoPoker', True)
     mastermind_enabled = config['games'].getboolean('mastermind', True)
     golfSim_enabled = config['games'].getboolean('golfSim', True)
+    hangman_enabled = config['games'].getboolean('hangman', True)
+    hamtest_enabled = config['games'].getboolean('hamtest', True)
+    tictactoe_enabled = config['games'].getboolean('tictactoe', True)
+    quiz_enabled = config['games'].getboolean('quiz', False)
+    survey_enabled = config['games'].getboolean('survey', False)
+    default_survey = config['games'].get('defaultSurvey', 'example') # default example
+    surveyRecordID = config['games'].getboolean('surveyRecordID', True)
+    surveyRecordLocation = config['games'].getboolean('surveyRecordLocation', True)
 
     # messaging settings
     responseDelay = config['messagingSettings'].getfloat('responseDelay', 0.7) # default 0.7
     splitDelay = config['messagingSettings'].getfloat('splitDelay', 0) # default 0
-    MESSAGE_CHUNK_SIZE = config['messagingSettings'].getint('MESSAGE_CHUNK_SIZE', 160) # default 160
-
-except KeyError as e:
+    MESSAGE_CHUNK_SIZE = config['messagingSettings'].getint('MESSAGE_CHUNK_SIZE', 160) # default 160 chars
+    wantAck = config['messagingSettings'].getboolean('wantAck', False) # default False
+    maxBuffer = config['messagingSettings'].getint('maxBuffer', 200) # default 200 bytes
+    enableHopLogs = config['messagingSettings'].getboolean('enableHopLogs', False) # default False
+    debugMetadata = config['messagingSettings'].getboolean('debugMetadata', False) # default False
+    metadataFilter = config['messagingSettings'].get('metadataFilter', '').split(',') # default empty
+    DEBUGpacket = config['messagingSettings'].getboolean('DEBUGpacket', False) # default False
+    noisyNodeLogging = config['messagingSettings'].getboolean('noisyNodeLogging', False) # default False
+    logMetaStats = config['messagingSettings'].getboolean('logMetaStats', True) # default True
+    noisyTelemetryLimit = config['messagingSettings'].getint('noisyTelemetryLimit', 5) # default 5 packets
+except Exception as e:
     print(f"System: Error reading config file: {e}")
     print(f"System: Check the config.ini against config.template file for missing sections or values.")
     print(f"System: Exiting...")

modules/smtp.py

@@ -0,0 +1,272 @@
+# SMTP module for the meshing-around bot
+# 2024 Idea and code bits from https://github.com/tremmert81
+# https://avtech.com/articles/138/list-of-email-to-sms-addresses/
+# 2024 Kelly Keeton K7MHI
+
+from modules.log import *
+import pickle
+import time
+import smtplib
+from email.mime.text import MIMEText
+from email.mime.multipart import MIMEMultipart
+
+# System variables
+trap_list_smtp = ("email:", "setemail", "sms:", "setsms", "clearsms")
+smtpThrottle = {}
+SMTP_TIMEOUT = 10
+
+if enableImap:
+    # Import IMAP library
+    import imaplib
+    import email
+
+# Send email
+def send_email(to_email, message, nodeID=0):
+    global smtpThrottle
+    
+    # Clean up email address
+    to_email = to_email.strip()
+    
+    # Basic email validation
+    if "@" not in to_email or "." not in to_email:
+        logger.warning(f"System: Invalid email address format: {to_email}")
+        return False
+        
+    # throttle email to prevent abuse
+    if to_email in smtpThrottle:
+        if smtpThrottle[to_email] > time.time() - 120:
+            logger.warning("System: Email throttled for " + to_email[:-6])
+            return "⛔️Email throttled, try again later"
+    smtpThrottle[to_email] = time.time()
+
+    # check if email is in the ban list
+    if nodeID in bbs_ban_list:
+        logger.warning("System: Email blocked for " + str(nodeID))
+        return "⛔️Email throttled, try again later"
+    # Send email
+    try:
+        # Create message
+        msg = MIMEMultipart()
+        msg['From'] = FROM_EMAIL
+        msg['To'] = to_email
+        msg['Subject'] = EMAIL_SUBJECT
+        msg.attach(MIMEText(message, 'plain'))
+
+        # Connect to SMTP server
+        server = smtplib.SMTP(SMTP_SERVER, SMTP_PORT, timeout=SMTP_TIMEOUT)
+        try:
+            # login /auth
+            if SMTP_PORT == 587:
+                server.starttls()
+            if SMTP_AUTH:
+                server.login(SMTP_USERNAME, SMTP_PASSWORD)
+        except Exception as e:
+            logger.warning(f"System: Failed to login to SMTP server: {str(e)}")
+            return
+
+        # Send email; this command will hold the program until the email is sent
+        server.send_message(msg)
+        server.quit()
+
+        logger.info("System: Email sent to: " + to_email[:-6])
+        return True
+    except Exception as e:
+        logger.warning(f"System: Failed to send email: {str(e)}")
+        return False
+
+def check_email(nodeID, sysop=False):
+    if not enableImap:
+        return
+
+    try:
+        # Connect to IMAP server
+        mail = imaplib.IMAP4_SSL(IMAP_SERVER, IMAP_PORT, timeout=SMTP_TIMEOUT)
+        mail.login(IMAP_USERNAME, IMAP_PASSWORD)
+        mail.select(IMAP_FOLDER)
+
+        # Search for new emails
+        status, data = mail.search(None, 'UNSEEN')
+        if status == 'OK':
+            for num in data[0].split():
+                status, data = mail.fetch(num, '(RFC822)')
+                if status == 'OK':
+                    email_message = email.message_from_bytes(data[0][1])
+                    email_from = email_message['from']
+                    email_subject = email_message['subject']
+                    email_body = ""
+
+                    if not sysop:
+                        # Check if email is whitelisted by particpant in the mesh
+                        for address in sms_db[nodeID]:
+                            if address in email_from:
+                                email_body = email_message.get_payload()
+                                logger.info("System: Email received from: " + email_from[:-6] + " for " + str(nodeID))
+                                return email_body.strip()
+                    else:
+                        # Check if email is from sysop
+                        for address in sysopEmails:
+                            if address in email_from:
+                                email_body = email_message.get_payload()
+                                logger.info("System: SysOp Email received from: " + email_from[:-6] + " for sysop")
+                                return email_body.strip()
+                        
+    except Exception as e:
+        logger.warning("System: Failed to check email: " + str(e))
+        return False
+
+# initalize email db
+email_db = {}
+try:
+    with open('data/email_db.pickle', 'rb') as f:
+        email_db = pickle.load(f)
+except:
+    logger.warning("System: Email db not found, creating a new one")
+    with open('data/email_db.pickle', 'wb') as f:
+        pickle.dump(email_db, f)
+
+def store_email(nodeID, email):
+    global email_db
+
+    # if not in db, add it
+    logger.debug("System: Setting E-Mail for " + str(nodeID))
+    email_db[nodeID] = email
+
+    # save to a pickle for persistence, this is a simple db, be mindful of risk
+    with open('data/email_db.pickle', 'wb') as f:
+        pickle.dump(email_db, f)
+    f.close()
+    return True
+
+
+# initalize SMS db
+sms_db = [{'nodeID': 0, 'sms':[]}]
+try:
+    with open('data/sms_db.pickle', 'rb') as f:
+        sms_db = pickle.load(f)
+except:
+    logger.warning("System: SMS db not found, creating a new one")
+    with open('data/sms_db.pickle', 'wb') as f:
+        pickle.dump(sms_db, f)
+
+def store_sms(nodeID, sms):
+    global sms_db
+    try:
+        logger.debug("System: Setting SMS for " + str(nodeID))
+        # if the nodeID has over 5 sms addresses warn and return
+        for item in sms_db:
+            if item['nodeID'] == nodeID:
+                if len(item['sms']) >= 5:
+                    logger.warning("System: 📵SMS limit reached for " + str(nodeID))
+                    return False
+        # if not in db, add it
+        if nodeID not in sms_db:
+            sms_db.append({'nodeID': nodeID, 'sms': sms})
+        else:
+            # if in db, update it
+            for item in sms_db:
+                if item['nodeID'] == nodeID:
+                    item['sms'].append(sms)
+
+        # save to a pickle for persistence, this is a simple db, be mindful of risk
+        with open('data/sms_db.pickle', 'wb') as f:
+            pickle.dump(sms_db, f)
+        f.close()
+        return True
+    except Exception as e:
+        logger.warning("System: Failed to store SMS: " + str(e))
+        return False
+
+def handle_sms(nodeID, message):
+    global sms_db
+    # if clearsms, remove all sms for node
+    if message.lower().startswith("clearsms"):
+        if any(item['nodeID'] == nodeID for item in sms_db):
+            # remove record from db for nodeID
+            sms_db = [item for item in sms_db if item['nodeID'] != nodeID]
+            # update the pickle
+            with open('data/sms_db.pickle', 'wb') as f:
+                pickle.dump(sms_db, f)
+            f.close()
+            return "📲 address cleared"
+        return "📲No address to clear"
+    
+    # send SMS to SMS in db. if none ask for one
+    if message.lower().startswith("setsms"):
+        message = message.split(" ", 1)
+        if len(message[1]) < 5:
+            return "?📲setsms: example@phone.co"
+        if "@" not in message[1] and "." not in message[1]:
+            return "📲Please provide a valid email address"
+        if store_sms(nodeID, message[1]):
+            return "📲SMS address set 📪"
+        else:
+            return "⛔️Failed to set address"
+        
+    if message.lower().startswith("sms:"):
+        message = message.split(" ", 1)
+        if any(item['nodeID'] == nodeID for item in sms_db):
+            count = 0
+            # for all dict items maching nodeID in sms_db send sms
+            for item in sms_db:
+                if item['nodeID'] == nodeID:
+                    smsEmail = item['sms']
+                    logger.info("System: Sending SMS for " + str(nodeID) + " to " + smsEmail[:-6])
+                    if send_email(smsEmail, message[1], nodeID):
+                        count += 1
+                    else: 
+                        return "⛔️Failed to send SMS"
+            return "📲SMS sent " + str(count) + " addresses 📤"
+        else:
+            return "📲No address set, use 📲setsms"
+    
+    return "Error: ⛔️ not understood. use:setsms example@phone.co"
+
+def handle_email(nodeID, message):
+    global email_db
+    try:
+        # send email to email in db. if none ask for one
+        if message.lower().startswith("setemail"):
+            message = message.split(" ", 1)
+            if len(message) < 2:
+                return "📧Please provide an email address"
+            email_addr = message[1].strip()
+            if "@" not in email_addr or "." not in email_addr:
+                return "📧Please provide a valid email address"
+            if store_email(nodeID, email_addr):
+                return "📧Email address set 📪"
+            return "Error: ⛔️ Failed to set email address"
+            
+        if message.lower().startswith("email:"):
+            parts = message.split(" ", 1)
+            if len(parts) < 2:
+                return "Error: ⛔️ format should be: email: message  or, email: address@example.com #message"
+                
+            content = parts[1].strip()
+            
+            # Check if this is a direct email with address
+            if "@" in content and "#" in content:
+                # Split into email and message
+                addr_msg = content.split("#", 1)
+                if len(addr_msg) != 2:
+                    return "Error: ⛔️ Message format should be: email: address@example.com #message"
+                    
+                to_email = addr_msg[0].strip()
+                message_body = addr_msg[1].strip()
+                
+                logger.info(f"System: Sending email for {nodeID} to {to_email}")
+                if send_email(to_email, message_body, nodeID): 
+                    return "📧Email-sent 📤"
+                return "⛔️Failed to send email"
+                
+            # Using stored email address
+            elif nodeID in email_db:
+                logger.info(f"System: Sending email for {nodeID} to stored address")
+                if send_email(email_db[nodeID], content, nodeID):
+                    return "📧Email-sent 📤"
+                return "⛔️Failed to send email"
+        
+        return "Error: ⛔️ no email on file. use: setemail"
+            
+    except Exception as e:
+        logger.error(f"System: Email handling error: {str(e)}")
+        return "⛔️Failed to process email command"

modules/solarconditions.py

@@ -1,142 +0,0 @@
-# helper functions to get HF band conditions, DRAP X-ray flux, and sunrise/sunset times
-# HF code from https://github.com/Murturtle/MeshLink
-# K7MHI Kelly Keeton 2024
-
-import requests # pip install requests
-import xml.dom.minidom
-from datetime import datetime
-import ephem # pip install pyephem
-from datetime import timedelta
-from modules.log import *
-
-trap_list_solarconditions = ("sun", "solar", "hfcond")
-
-def hf_band_conditions():
-    # ham radio HF band conditions
-    hf_cond = ""
-    band_cond = requests.get("https://www.hamqsl.com/solarxml.php", timeout=urlTimeoutSeconds)
-    if(band_cond.ok):
-        solarxml = xml.dom.minidom.parseString(band_cond.text)
-        for i in solarxml.getElementsByTagName("band"):
-            hf_cond += i.getAttribute("time")[0]+i.getAttribute("name") +"="+str(i.childNodes[0].data)+"\n"
-        hf_cond = hf_cond[:-1] # remove the last newline
-    else:
-        logger.error("Solar: Error fetching HF band conditions")
-        hf_cond = ERROR_FETCHING_DATA
-    
-    return hf_cond
-
-def solar_conditions():
-    # radio related solar conditions from hamsql.com
-    solar_cond = ""
-    solar_cond = requests.get("https://www.hamqsl.com/solarxml.php", timeout=urlTimeoutSeconds)
-    if(solar_cond.ok):
-        solar_xml = xml.dom.minidom.parseString(solar_cond.text)
-        for i in solar_xml.getElementsByTagName("solardata"):
-            solar_a_index = i.getElementsByTagName("aindex")[0].childNodes[0].data
-            solar_k_index = i.getElementsByTagName("kindex")[0].childNodes[0].data
-            solar_xray = i.getElementsByTagName("xray")[0].childNodes[0].data
-            solar_flux = i.getElementsByTagName("solarflux")[0].childNodes[0].data
-            sunspots = i.getElementsByTagName("sunspots")[0].childNodes[0].data
-            signalnoise = i.getElementsByTagName("signalnoise")[0].childNodes[0].data
-        solar_cond = "A-Index: " + solar_a_index + "\nK-Index: " + solar_k_index + "\nSunspots: " + sunspots + "\nX-Ray Flux: " + solar_xray + "\nSolar Flux: " + solar_flux + "\nSignal Noise: " + signalnoise
-    else:
-        logger.error("Solar: Error fetching solar conditions")
-        solar_cond = ERROR_FETCHING_DATA
-    return solar_cond
-
-def drap_xray_conditions():
-    # DRAP X-ray flux conditions, from NOAA direct
-    drap_cond = ""
-    drap_cond = requests.get("https://services.swpc.noaa.gov/text/drap_global_frequencies.txt", timeout=urlTimeoutSeconds)
-    if(drap_cond.ok):
-        drap_list = drap_cond.text.split('\n')
-        x_filter = '#  X-RAY Message :'
-        for line in drap_list:
-            if x_filter in line:
-                xray_flux = line.split(": ")[1]
-    else:
-        logger.error("Error fetching DRAP X-ray flux")
-        xray_flux = ERROR_FETCHING_DATA
-    return xray_flux
-
-def get_sun(lat=0, lon=0):
-    # get sunrise and sunset times using callers location or default
-    obs = ephem.Observer()
-    obs.date = datetime.now()
-    sun = ephem.Sun()
-    if lat != 0 and lon != 0:
-        obs.lat = str(lat)
-        obs.lon = str(lon)
-    else:
-        obs.lat = str(latitudeValue)
-        obs.lon = str(longitudeValue)
-
-    sun.compute(obs)
-    sun_table = {}
-    sun_table['azimuth'] = sun.az
-    sun_table['altitude'] = sun.alt
-
-    # get the next rise and set times
-    local_sunrise = ephem.localtime(obs.next_rising(sun))
-    local_sunset = ephem.localtime(obs.next_setting(sun))
-    if zuluTime:
-        sun_table['rise_time'] = local_sunrise.strftime('%a %d %H:%M')
-        sun_table['set_time'] = local_sunset.strftime('%a %d %H:%M')
-    else:
-        sun_table['rise_time'] = local_sunrise.strftime('%a %d %I:%M%p')
-        sun_table['set_time'] = local_sunset.strftime('%a %d %I:%M%p')
-    # if sunset is before sunrise, then it's tomorrow
-    if local_sunset < local_sunrise:
-        local_sunset = ephem.localtime(obs.next_setting(sun)) + timedelta(1)
-        if zuluTime:
-            sun_table['set_time'] = local_sunset.strftime('%a %d %H:%M')
-        else:
-            sun_table['set_time'] = local_sunset.strftime('%a %d %I:%M%p')
-    sun_data = "SunRise: " + sun_table['rise_time'] + "\nSet: " + sun_table['set_time']
-    return sun_data
-
-def get_moon(lat=0, lon=0):
-    # get moon phase and rise/set times using callers location or default
-    # the phase calculation mght not be accurate (followup later)
-    obs = ephem.Observer()
-    moon = ephem.Moon()
-    if lat != 0 and lon != 0:
-        obs.lat = str(lat)
-        obs.lon = str(lon)
-    else:
-        obs.lat = str(latitudeValue)
-        obs.lon = str(longitudeValue)
-    
-    obs.date = datetime.now()
-    moon.compute(obs)
-    moon_table = {}
-    moon_phase = ['NewMoon', 'Waxing Crescent', 'First Quarter', 'Waxing Gibbous', 'FullMoon', 'Waning Gibbous', 'Last Quarter', 'Waning Crescent'][round(moon.phase / (2 * ephem.pi) * 8) % 8]
-    moon_table['phase'] = moon_phase
-    moon_table['illumination'] = moon.phase
-    moon_table['azimuth'] = moon.az
-    moon_table['altitude'] = moon.alt
-
-    local_moonrise = ephem.localtime(obs.next_rising(moon))
-    local_moonset = ephem.localtime(obs.next_setting(moon))
-    if zuluTime:
-        moon_table['rise_time'] = local_moonrise.strftime('%a %d %H:%M')
-        moon_table['set_time'] = local_moonset.strftime('%a %d %H:%M')
-    else:
-        moon_table['rise_time'] = local_moonrise.strftime('%a %d %I:%M%p')
-        moon_table['set_time'] = local_moonset.strftime('%a %d %I:%M%p')
-
-    local_next_full_moon = ephem.localtime(ephem.next_full_moon((obs.date)))
-    local_next_new_moon = ephem.localtime(ephem.next_new_moon((obs.date)))
-    if zuluTime:
-        moon_table['next_full_moon'] = local_next_full_moon.strftime('%a %b %d %H:%M')
-        moon_table['next_new_moon'] = local_next_new_moon.strftime('%a %b %d %H:%M')
-    else:
-        moon_table['next_full_moon'] = local_next_full_moon.strftime('%a %b %d %I:%M%p')
-        moon_table['next_new_moon'] = local_next_new_moon.strftime('%a %b %d %I:%M%p')
-
-    moon_data = "MoonRise:" + moon_table['rise_time'] + "\nSet:" + moon_table['set_time'] + \
-        "\nPhase:" + moon_table['phase'] + " @:" + str('{0:.2f}'.format(moon_table['illumination'])) + "%" \
-        + "\nFullMoon:" + moon_table['next_full_moon'] + "\nNewMoon:" + moon_table['next_new_moon']
-    
-    return moon_data

modules/space.py

@@ -0,0 +1,252 @@
+# helper functions to get HF band conditions, DRAP X-ray flux, and sunrise/sunset times
+# HF code from https://github.com/Murturtle/MeshLink
+# K7MHI Kelly Keeton 2024
+
+import requests # pip install requests
+import xml.dom.minidom
+from datetime import datetime
+import ephem # pip install pyephem
+from datetime import timezone
+from modules.log import *
+import math
+
+trap_list_solarconditions = ("sun", "moon", "solar", "hfcond", "satpass", "howtall")
+
+def hf_band_conditions():
+    # ham radio HF band conditions
+    hf_cond = ""
+    signalnoise = ""
+    band_cond = requests.get("https://www.hamqsl.com/solarxml.php", timeout=urlTimeoutSeconds)
+    if(band_cond.ok):
+        solarxml = xml.dom.minidom.parseString(band_cond.text)
+        for i in solarxml.getElementsByTagName("band"):
+            hf_cond += i.getAttribute("time")[0]+i.getAttribute("name") +"="+str(i.childNodes[0].data)+"\n"
+        hf_cond = hf_cond[:-1] # remove the last newline
+        for i in solarxml.getElementsByTagName("solardata"):
+            signalnoise = i.getElementsByTagName("signalnoise")[0].childNodes[0].data
+        hf_cond += "\nQRN:" + signalnoise
+    else:
+        logger.error("Solar: Error fetching HF band conditions")
+        hf_cond = ERROR_FETCHING_DATA
+    
+    return hf_cond
+
+def solar_conditions():
+    # radio related solar conditions from hamsql.com
+    solar_cond = ""
+    solar_cond = requests.get("https://www.hamqsl.com/solarxml.php", timeout=urlTimeoutSeconds)
+    if(solar_cond.ok):
+        solar_xml = xml.dom.minidom.parseString(solar_cond.text)
+        for i in solar_xml.getElementsByTagName("solardata"):
+            solar_a_index = i.getElementsByTagName("aindex")[0].childNodes[0].data
+            solar_k_index = i.getElementsByTagName("kindex")[0].childNodes[0].data
+            solar_xray = i.getElementsByTagName("xray")[0].childNodes[0].data
+            solar_flux = i.getElementsByTagName("solarflux")[0].childNodes[0].data
+            sunspots = i.getElementsByTagName("sunspots")[0].childNodes[0].data
+            signalnoise = i.getElementsByTagName("signalnoise")[0].childNodes[0].data
+        solar_cond = "A-Index: " + solar_a_index + "\nK-Index: " + solar_k_index + "\nSunspots: " + sunspots + "\nX-Ray Flux: " + solar_xray + "\nSolar Flux: " + solar_flux + "\nSignal Noise: " + signalnoise
+    else:
+        logger.error("Solar: Error fetching solar conditions")
+        solar_cond = ERROR_FETCHING_DATA
+    return solar_cond
+
+def drap_xray_conditions():
+    # DRAP X-ray flux conditions, from NOAA direct
+    drap_cond = ""
+    drap_cond = requests.get("https://services.swpc.noaa.gov/text/drap_global_frequencies.txt", timeout=urlTimeoutSeconds)
+    if(drap_cond.ok):
+        drap_list = drap_cond.text.split('\n')
+        x_filter = '#  X-RAY Message :'
+        for line in drap_list:
+            if x_filter in line:
+                xray_flux = line.split(": ")[1]
+    else:
+        logger.error("Error fetching DRAP X-ray flux")
+        xray_flux = ERROR_FETCHING_DATA
+    return xray_flux
+
+def get_sun(lat=0, lon=0):
+    # get sunrise and sunset times using callers location or default
+    obs = ephem.Observer()
+    obs.date = datetime.now(timezone.utc)
+    sun = ephem.Sun()
+    if lat != 0 and lon != 0:
+        obs.lat = str(lat)
+        obs.lon = str(lon)
+    else:
+        obs.lat = str(latitudeValue)
+        obs.lon = str(longitudeValue)
+
+    sun.compute(obs)
+    sun_table = {}
+
+    # get the sun azimuth and altitude
+    sun_table['azimuth'] = sun.az
+    sun_table['altitude'] = sun.alt
+
+    # sun is up include altitude
+    if sun_table['altitude'] > 0:
+        sun_table['altitude'] = sun.alt
+    else:
+        sun_table['altitude'] = 0
+
+    # get the next rise and set times
+    local_sunrise = ephem.localtime(obs.next_rising(sun))
+    local_sunset = ephem.localtime(obs.next_setting(sun))
+    if zuluTime:
+        sun_table['rise_time'] = local_sunrise.strftime('%a %d %H:%M')
+        sun_table['set_time'] = local_sunset.strftime('%a %d %H:%M')
+    else:
+        sun_table['rise_time'] = local_sunrise.strftime('%a %d %I:%M%p')
+        sun_table['set_time'] = local_sunset.strftime('%a %d %I:%M%p')
+    
+    # if sunset is before sunrise, then data will be for tomorrow format sunset first and sunrise second
+    if local_sunset < local_sunrise:
+        sun_data = "SunSet: " + sun_table['set_time'] + "\nRise: " + sun_table['rise_time']
+    else:
+        sun_data = "SunRise: " + sun_table['rise_time'] + "\nSet: " + sun_table['set_time']
+
+    sun_data += "\nDaylight: " + str((local_sunset - local_sunrise).seconds // 3600) + "h " + str(((local_sunset - local_sunrise).seconds // 60) % 60) + "m"
+    
+    if sun_table['altitude'] > 0:
+        sun_data += "\nRemaining: " + str((local_sunset - datetime.now()).seconds // 3600) + "h " + str(((local_sunset - datetime.now()).seconds // 60) % 60) + "m"
+    
+    sun_data += "\nAzimuth: " + str('{0:.2f}'.format(sun_table['azimuth'] * 180 / ephem.pi)) + "°"
+    if sun_table['altitude'] > 0:
+        sun_data += "\nAltitude: " + str('{0:.2f}'.format(sun_table['altitude'] * 180 / ephem.pi)) + "°"
+    return sun_data
+
+def get_moon(lat=0, lon=0):
+    # get moon phase and rise/set times using callers location or default
+    obs = ephem.Observer()
+    moon = ephem.Moon()
+    if lat != 0 and lon != 0:
+        obs.lat = str(lat)
+        obs.lon = str(lon)
+    else:
+        obs.lat = str(latitudeValue)
+        obs.lon = str(longitudeValue)
+    
+    obs.date = datetime.now(timezone.utc)
+    moon.compute(obs)
+    moon_table = {}
+    illum = moon.phase  # 0 = new, 50 = first/last quarter, 100 = full
+    
+    if illum < 1.0:
+        moon_phase = 'New Moon🌑'
+    elif illum < 49:
+        moon_phase = 'Waxing Crescent 🌒'
+    elif 49 <= illum < 51:
+        moon_phase = 'First Quarter 🌓'
+    elif illum < 99:
+        moon_phase = 'Waxing Gibbous 🌔'
+    elif illum >= 99:
+        moon_phase = 'Full Moon🌕'
+    elif illum > 51:
+        moon_phase = 'Waning Gibbous 🌖'
+    elif 51 >= illum > 49:
+        moon_phase = 'Last Quarter 🌗'
+    else:
+        moon_phase = 'Waning Crescent 🌘'
+    
+    moon_table['phase'] = moon_phase
+    moon_table['illumination'] = moon.phase
+    moon_table['azimuth'] = moon.az
+    moon_table['altitude'] = moon.alt
+
+    local_moonrise = ephem.localtime(obs.next_rising(moon))
+    local_moonset = ephem.localtime(obs.next_setting(moon))
+    if zuluTime:
+        moon_table['rise_time'] = local_moonrise.strftime('%a %d %H:%M')
+        moon_table['set_time'] = local_moonset.strftime('%a %d %H:%M')
+    else:
+        moon_table['rise_time'] = local_moonrise.strftime('%a %d %I:%M%p')
+        moon_table['set_time'] = local_moonset.strftime('%a %d %I:%M%p')
+
+    local_next_full_moon = ephem.localtime(ephem.next_full_moon((obs.date)))
+    local_next_new_moon = ephem.localtime(ephem.next_new_moon((obs.date)))
+    if zuluTime:
+        moon_table['next_full_moon'] = local_next_full_moon.strftime('%a %b %d %H:%M')
+        moon_table['next_new_moon'] = local_next_new_moon.strftime('%a %b %d %H:%M')
+    else:
+        moon_table['next_full_moon'] = local_next_full_moon.strftime('%a %b %d %I:%M%p')
+        moon_table['next_new_moon'] = local_next_new_moon.strftime('%a %b %d %I:%M%p')
+
+    moon_data = "MoonRise: " + moon_table['rise_time'] + "\nSet: " + moon_table['set_time'] + \
+        "\nPhase: " + moon_table['phase'] + " @: " + str('{0:.2f}'.format(moon_table['illumination'])) + "%" \
+        + "\nFullMoon: " + moon_table['next_full_moon'] + "\nNewMoon: " + moon_table['next_new_moon']
+    
+    # if moon is in the sky, add azimuth and altitude
+    if moon_table['altitude'] > 0:
+        moon_data += "\nAz: " + str('{0:.2f}'.format(moon_table['azimuth'] * 180 / ephem.pi)) + "°" + \
+            "\nAlt: " + str('{0:.2f}'.format(moon_table['altitude'] * 180 / ephem.pi)) + "°"
+    
+    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
+
+def measureHeight(lat=0, lon=0, shadow=0):
+    # measure height of a given location using sun angle and shadow length
+    if lat == 0 and lon == 0:
+        return NO_DATA_NOGPS
+    if shadow == 0:
+        return NO_ALERTS
+    obs = ephem.Observer()
+    obs.lat = str(lat)
+    obs.lon = str(lon)
+    obs.date = datetime.now(timezone.utc)
+    sun = ephem.Sun()
+    sun.compute(obs)
+    sun_altitude = sun.alt * 180 / ephem.pi
+    if sun_altitude <= 0:
+        return "☀️Sun is below horizon, I dont belive your shadow measurement"
+    try:
+        if use_metric:
+            height = float(shadow) * math.tan(sun.alt)
+            return f"📏Object Height: {height:.2f} m (Shadow: {shadow} m, 📐Sun Alt: {sun_altitude:.2f}°)"
+        else:
+            # Assume shadow is in feet if imperial, otherwise convert from meters to feet
+            shadow_ft = float(shadow)
+            height_ft = shadow_ft * math.tan(sun.alt)
+            return f"📏Object Height: {height_ft:.2f} ft (Shadow: {shadow_ft} ft, 📐Sun Alt: {sun_altitude:.2f}°)"
+    except Exception as e:
+        logger.error(f"Space: Error calculating height: {e}")
+        return NO_ALERTS

modules/survey.py

@@ -0,0 +1,194 @@
+# Survey Module for meshbot 2025
+# Provides a survey function to collect responses and put into a CSV file
+# this module reads survey definitions from JSON files in the data/surveys directory
+# Each survey is defined in a separate JSON file named <survey_name>_survey.json
+# Example survey file: example_survey.json
+# Example survey response file: example_responses.csv
+# Each survey consists of multiple questions, which can be multiple choice, integer, or text
+# Users can start a survey, answer questions, and end the survey
+# Module acts like a game locking DM until the survey is complete or ended
+
+import json
+import os # For file operations
+from collections import Counter
+from modules.log import *
+
+allowedSurveys = []  # List of allowed survey names
+
+trap_list_survey = ("survey",)
+
+class SurveyModule:
+    def __init__(self):
+        self.base_dir = os.path.dirname(__file__)
+        self.survey_dir = os.path.join(self.base_dir, '..', 'data', 'surveys') # Directory for survey JSON files
+        self.response_dir = os.path.join(self.base_dir, '..', 'data', 'surveys') # Directory for survey response CSV files
+        self.surveys = {}
+        self.responses = {}
+        self.load_surveys()
+
+    def load_surveys(self):
+        """Load all surveys from the surveys directory with _survey.json suffix."""
+        global allowedSurveys
+        allowedSurveys.clear()
+        try:
+            for filename in os.listdir(self.survey_dir):
+                if filename.endswith('_survey.json'):
+                    survey_name = filename[:-12]  # Remove '_survey.json'
+                    allowedSurveys.append(survey_name)
+                    path = os.path.join(self.survey_dir, filename)
+                    try:
+                        with open(path, encoding='utf-8') as f:
+                            self.surveys[survey_name] = json.load(f)
+                    except FileNotFoundError:
+                        logger.error(f"File not found: {path}")
+                        self.surveys[survey_name] = []
+                    except json.JSONDecodeError:
+                        logger.error(f"Error decoding JSON from file: {path}")
+                        self.surveys[survey_name] = []
+        except Exception as e:
+            logger.error(f"Survey: Error loading surveys: {e}")
+
+    def start_survey(self, user_id, survey_name='example', location=None):
+        try:
+            """Begin a new survey session for a user."""
+            if not survey_name:
+                survey_name = default_survey
+            if survey_name not in allowedSurveys:
+                return f"error: survey '{survey_name}' is not allowed."
+            self.responses[user_id] = {
+                'survey_name': survey_name,
+                'current_question': 0,
+                'answers': [],
+                'location': location if surveyRecordLocation and location is not None else 'N/A'
+            }
+            msg = f"'{survey_name}'📝survey\nSend answer' or 'end'\n"
+            msg += self.show_question(user_id)
+            return msg
+        except Exception as e:
+            logger.error(f"Error starting survey for user {user_id}: {e}")
+            return "An error occurred while starting the survey. Please try again later."
+
+    def show_question(self, user_id):
+        """Show the current question for the user, or end the survey."""
+        survey_name = self.responses[user_id]['survey_name']
+        current = self.responses[user_id]['current_question']
+        questions = self.surveys.get(survey_name, [])
+        if current >= len(questions):
+            return self.end_survey(user_id)
+        question = questions[current]
+        msg = f"{question['question']}\n"
+        if question.get('type', 'multiple_choice') == 'multiple_choice':
+            for i, option in enumerate(question['options']):
+                msg += f"{chr(65+i)}. {option}\n"
+        elif question['type'] == 'integer':
+            msg += "(Please enter a number)\n"
+        elif question['type'] == 'text':
+            msg += "(Please enter your response)\n"
+        msg = msg.rstrip('\n')
+        return msg
+
+    def save_responses(self, user_id):
+        """Save user responses to a CSV file."""
+        survey_name = self.responses[user_id]['survey_name']
+        if survey_name not in self.surveys:
+            logger.warning(f"Survey '{survey_name}' not loaded. Responses not saved.")
+            return
+        filename = os.path.join(self.response_dir, f'{survey_name}_responses.csv')
+        try:
+            with open(filename, 'a', encoding='utf-8') as f:
+                row = list(map(str, self.responses[user_id]['answers']))
+                if surveyRecordID:
+                    row.insert(0, str(user_id))
+                if surveyRecordLocation:
+                    location = self.responses[user_id].get('location')
+                    row.insert(1 if surveyRecordID else 0, str(location) if location is not None else "N/A")
+                f.write(','.join(row) + '\n')
+            logger.info(f"Survey: Responses for user {user_id} saved for survey '{survey_name}' to {filename}.")
+        except Exception as e:
+            logger.error(f"Error saving responses to {filename}: {e}")
+
+    def answer(self, user_id, answer, location=None):
+        try:
+            """Record an answer and return the next question or end message."""
+            if user_id not in self.responses:
+                return self.start_survey(user_id, location=location)
+            question_index = self.responses[user_id]['current_question']
+            survey_name = self.responses[user_id]['survey_name']
+            questions = self.surveys.get(survey_name, [])
+            if question_index < 0 or question_index >= len(questions):
+                return "No current question to answer."
+            question = questions[question_index]
+            qtype = question.get('type', 'multiple_choice')
+            if qtype == 'multiple_choice':
+                answer_char = answer.strip().upper()[:1]
+                if len(answer_char) != 1 or not answer_char.isalpha():
+                    return "Please answer with a letter (A, B, C, ...)."
+                option_index = ord(answer_char) - 65
+                if 0 <= option_index < len(question['options']):
+                    self.responses[user_id]['answers'].append(str(option_index))
+                    self.responses[user_id]['current_question'] += 1
+                    return f"Recorded..\n" + self.show_question(user_id)
+                else:
+                    print(f"Invalid option index {option_index} for question with {len(question['options'])} options. user entered '{answer}'")
+                    return "Invalid answer option. Please try again."
+            elif qtype == 'integer':
+                try:
+                    int_answer = int(answer)
+                    self.responses[user_id]['answers'].append(str(int_answer))
+                    self.responses[user_id]['current_question'] += 1
+                    return f"Recorded..\n" + self.show_question(user_id)
+                except ValueError:
+                    return "Please enter a valid integer."
+            elif qtype == 'text':
+                self.responses[user_id]['answers'].append(answer.strip())
+                self.responses[user_id]['current_question'] += 1
+                return f"Recorded..\n" + self.show_question(user_id)
+            else:
+                return f"error: unknown question type '{qtype}' and cannot record answer '{answer}'"
+        except Exception as e:
+            logger.error(f"Error recording answer for user {user_id}: {e}")
+            return "An error occurred while recording your answer. Please try again."
+
+    def end_survey(self, user_id):
+        """End the survey for the user and save responses."""
+        if user_id not in self.responses:
+            return "No active survey session to end."
+        self.save_responses(user_id)
+        self.responses.pop(user_id, None)
+        return "✅ Survey complete. Thank you for your responses!"
+
+    def quiz_report(self, survey_name='example'):
+        """
+        Generate a quick poll report: counts of each answer per question.
+        Returns a string summary.
+        """
+        filename = os.path.join(self.response_dir, f'{survey_name}_responses.csv')
+        questions = self.surveys.get(survey_name, [])
+        if not questions:
+            logger.warning(f"No survey found for '{survey_name}'.")
+            return f"No survey found for '{survey_name}'."
+        all_answers = []
+        try:
+            with open(filename, encoding='utf-8') as f:
+                for line in f:
+                    parts = line.strip().split(',')
+                    if surveyRecordID:
+                        answers = [int(x) for x in parts[1:] if x.strip().isdigit()]
+                    else:
+                        answers = [int(x) for x in parts if x.strip().isdigit()]
+                    all_answers.append(answers)
+        except FileNotFoundError:
+            logger.info(f"No responses recorded yet for '{survey_name}'.")
+            return "No responses recorded yet."
+        report = f"📊 Poll Report for '{survey_name}':\n"
+        for q_idx, question in enumerate(questions):
+            counts = Counter(ans[q_idx] for ans in all_answers if len(ans) > q_idx)
+            report += f"\nQ{q_idx+1}: {question['question']}\n"
+            for opt_idx, option in enumerate(question.get('options', [])):
+                count = counts.get(opt_idx, 0)
+                report += f"  {chr(65+opt_idx)}. {option}: {count}\n"
+        return report
+
+# Initialize the survey module
+survey_module = SurveyModule()
+

modules/udp.py

@@ -0,0 +1,126 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# UDP Interface Listener
+# credit to pdxlocations for all of this core work https://github.com/pdxlocations/
+# depends on: pip install meshtastic protobuf zeroconf pubsub
+# 2025 Kelly Keeton K7MHI
+from pubsub import pub
+from meshtastic.protobuf import mesh_pb2, portnums_pb2
+from mudp import UDPPacketStream, node, conn, send_text_message, send_nodeinfo, send_device_telemetry, send_position, send_environment_metrics, send_power_metrics, send_waypoint, send_data
+from mudp.encryption import generate_hash
+import time
+from zeroconf import Zeroconf, ServiceBrowser
+import socket
+
+MCAST_GRP, MCAST_PORT, CHANNEL_ID, KEY = "224.0.0.69", 4403, "LongFast", "1PG7OiApB1nwvP+rz05pAQ=="
+PUBLIC_CHANNEL_IDS = ["LongFast", "ShortSlow", "MediumFast", "MediumSlow", "ShortFast", "ShortTurbo"]
+mudpEnabled, mudpInterface = True, None
+messages = []
+
+class ZeroconfListner:
+    def add_service(self, zeroconf, type, name):
+        info = zeroconf.get_service_info(type, name)
+        if info:
+            txt = info.properties
+            ip = None
+            if info.addresses:
+                ip = socket.inet_ntoa(info.addresses[0])
+            print(f"Found Meshtastic node: id={txt.get(b'id', b'').decode()} shortname={txt.get(b'shortname', b'').decode()} longname={txt.get(b'longname', b'').decode()} ip={ip}")
+
+    def update_service(self, zeroconf, type, name):
+        # This method is required by zeroconf, but you can leave it empty if you don't need updates.
+        pass
+
+def initalize_mudp():
+    global mudpInterface
+    if mudpEnabled and mudpInterface is None:
+        mudpInterface = UDPPacketStream(MCAST_GRP, MCAST_PORT, key=KEY)
+        print(f"MUDP Interface initialized with multicast group", MCAST_GRP, "port", MCAST_PORT)
+    node.node_id, node.long_name, node.short_name = "!deadbeef", "UDP Test", "UDP"
+    node.channel, node.key = "LongFast", KEY
+    conn.setup_multicast(MCAST_GRP, MCAST_PORT)
+
+def on_recieve(packet: mesh_pb2.MeshPacket, addr=None):
+    print(f"\n[RECV] Packet received from {addr}")
+    print("from:", getattr(packet, "from", None))
+    print("to:", packet.to)
+
+    # Check against all public channels
+    matched_channel = None
+    for channel_name in PUBLIC_CHANNEL_IDS:
+        channel_hash = generate_hash(channel_name, KEY)
+        if packet.channel == channel_hash:
+            matched_channel = channel_name
+            break
+
+    if matched_channel:
+        channel_status = f"Match ({matched_channel})"
+    else:
+        channel_status = f"Hash: {packet.channel}"
+
+    print("channel:", channel_status)
+
+    if packet.HasField("decoded"):
+        port_name = portnums_pb2.PortNum.Name(packet.decoded.portnum) if packet.decoded.portnum else "N/A"
+        try:
+            payload_decoded = True
+            packet_payload = packet.decoded.payload.decode("utf-8", "ignore")
+        except Exception:
+            print("  payload (raw bytes):", packet.decoded.payload)
+    else:
+        print(f"encrypted: { {packet.encrypted} }")
+
+
+    print("id:", packet.id or None)
+    print("rx_time:", packet.rx_time or None)
+    print("rx_snr:", packet.rx_snr or None)
+    print("hop_limit:", packet.hop_limit or None)
+    priority_name = mesh_pb2.MeshPacket.Priority.Name(packet.priority) if packet.priority else "N/A"
+    print("priority:", priority_name or None)
+    print("rx_rssi:", packet.rx_rssi or None)
+    print("hop_start:", packet.hop_start or None)
+    print("next_hop:", packet.next_hop or None)
+    print("relay_node:", packet.relay_node or None)
+
+    print(f"decoded {{portnum: {port_name}, payload: {packet_payload if payload_decoded else 'N/A'}, bitfield: {packet.decoded.bitfield or None}}}" if packet.HasField("decoded") else "No decoded field")
+
+pub.subscribe(on_recieve, "mesh.rx.packet")
+# pub.subscribe(on_text_message, "mesh.rx.port.1")
+# pub.subscribe(on_nodeinfo, "mesh.rx.port.4") # NODEINFO_APP
+
+zeroconf = Zeroconf()
+listener = ZeroconfListner()
+browser = ServiceBrowser(zeroconf, "_meshtastic._tcp.local.", listener)
+
+def main():
+    initalize_mudp()
+    mudpInterface.start()
+    try:
+        while True: time.sleep(0.05)
+    except KeyboardInterrupt: pass
+    finally: mudpInterface.stop()
+
+if __name__ == "__main__":
+    main()
+
+
+# Meshtastic Port Numbers Reference:
+# | Port Number | Name                   | Purpose                        |
+# |-------------|------------------------|--------------------------------|
+# | 1           | TEXT_MESSAGE_APP       | Text messages                  |
+# | 2           | POSITION_APP           | Position updates (GPS)         |
+# | 3           | ROUTING_APP            | Routing info                   |
+# | 4           | NODEINFO_APP           | Node info (name, id, etc)      |
+# | 5           | TELEMETRY_APP          | Telemetry (battery, sensors)   |
+# | 6           | SERIAL_APP             | Serial data                    |
+# | 7           | ENVIRONMENTAL_APP      | Environmental sensors          |
+# | 8           | REMOTE_HARDWARE_APP    | Remote hardware control        |
+# | 9           | STORE_FORWARD_APP      | Store and forward              |
+# | 10          | RANGE_TEST_APP         | Range test                     |
+# | 11          | ADMIN_APP              | Admin/config                   |
+# | 12          | WAYPOINT_APP           | Waypoints                      |
+# | 13          | CHANNEL_NODEINFO_APP   | Channel node info              |
+# | 256         | PRIVATE_APP            | Private app (custom use)       |
+# See: https://github.com/meshtastic/protobufs/blob/main/meshtastic/protobuf/portnums.proto
+
+

modules/web.py

@@ -0,0 +1,62 @@
+#!/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 desired IP address
+server_ip = '127.0.0.1'
+
+# Set the port for the server
+PORT = 8420
+
+# Generate with: openssl req -new -x509 -keyout server.pem -out server.pem -days 365 -nodes
+SSL = False
+
+# Set to True to enable logging sdtout
+webServerLogs = False
+
+# Determine the directory where this script is located.
+script_dir = os.path.dirname(os.path.realpath(__file__))
+
+# Go up one level from the modules directory to the project root.
+project_root = os.path.abspath(os.path.join(script_dir, ".."))
+
+# Build the absolute path to the webRoot folder; to where index.html is located.
+webRoot = os.path.join(project_root, "etc", "www")
+
+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)
+
+# Create the HTTP server instance with the desired IP address
+httpd = http.server.HTTPServer((server_ip, 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 https://{server_ip}:{PORT} Press ^C to quit.\n\n")
+else:
+    print(f"Serving reports at http://{server_ip}:{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)

modules/wiki.py

@@ -0,0 +1,122 @@
+# meshbot wiki module
+
+from modules.log import *
+import wikipedia # pip install wikipedia
+
+# Kiwix support for local wiki
+if use_kiwix_server:
+    import requests
+    from bs4 import BeautifulSoup
+    from urllib.parse import quote
+    from bs4.element import Comment
+
+# Kiwix helper functions (only loaded if use_kiwix_server is True)
+if wikipedia_enabled and use_kiwix_server:
+    def tag_visible(element):
+        """Filter visible text from HTML elements for Kiwix"""
+        if element.parent.name in ['style', 'script', 'head', 'title', 'meta', '[document]']:
+            return False
+        if isinstance(element, Comment):
+            return False
+        return True
+
+    def text_from_html(body):
+        """Extract visible text from HTML content"""
+        soup = BeautifulSoup(body, 'html.parser')
+        texts = soup.find_all(string=True)
+        visible_texts = filter(tag_visible, texts)
+        return " ".join(t.strip() for t in visible_texts if t.strip())
+
+    def get_kiwix_summary(search_term):
+        """Query local Kiwix server for Wikipedia article"""
+        try:
+            search_encoded = quote(search_term)
+            # Try direct article access first
+            wiki_article = search_encoded.capitalize().replace("%20", "_")
+            exact_url = f"{kiwix_url}/raw/{kiwix_library_name}/content/A/{wiki_article}"
+            
+            response = requests.get(exact_url, timeout=urlTimeoutSeconds)
+            if response.status_code == 200:
+                # Extract and clean text
+                text = text_from_html(response.text)
+                # Remove common Wikipedia metadata prefixes
+                text = text.split("Jump to navigation", 1)[-1]
+                text = text.split("Jump to search", 1)[-1]
+                # Truncate to reasonable length (first few sentences)
+                sentences = text.split('. ')
+                summary = '. '.join(sentences[:wiki_return_limit])
+                if summary and not summary.endswith('.'):
+                    summary += '.'
+                return summary.strip()[:500]  # Hard limit at 500 chars
+            
+            # If direct access fails, try search
+            search_url = f"{kiwix_url}/search?content={kiwix_library_name}&pattern={search_encoded}"
+            response = requests.get(search_url, timeout=urlTimeoutSeconds)
+            
+            if response.status_code == 200 and "No results were found" not in response.text:
+                soup = BeautifulSoup(response.text, 'html.parser')
+                links = [a['href'] for a in soup.find_all('a', href=True) if "start=" not in a['href']]
+                
+                for link in links[:3]:  # Check first 3 results
+                    article_name = link.split("/")[-1]
+                    if not article_name or article_name[0].islower():
+                        continue
+                        
+                    article_url = f"{kiwix_url}{link}"
+                    article_response = requests.get(article_url, timeout=urlTimeoutSeconds)
+                    if article_response.status_code == 200:
+                        text = text_from_html(article_response.text)
+                        text = text.split("Jump to navigation", 1)[-1]
+                        text = text.split("Jump to search", 1)[-1]
+                        sentences = text.split('. ')
+                        summary = '. '.join(sentences[:wiki_return_limit])
+                        if summary and not summary.endswith('.'):
+                            summary += '.'
+                        return summary.strip()[:500]
+            
+            logger.warning(f"System: No Kiwix Results for:{search_term}")
+            # try to fall back to online Wikipedia if available
+            return get_wikipedia_summary(search_term, force=True)
+            
+            
+        except requests.RequestException as e:
+            logger.warning(f"System: Kiwix connection error: {e}")
+            return "Unable to connect to local wiki server"
+        except Exception as e:
+            logger.warning(f"System: Error with Kiwix for:{search_term} {e}")
+            return ERROR_FETCHING_DATA
+
+def get_wikipedia_summary(search_term, location=None, force=False):
+    lat, lon = location if location else (None, None)
+    # Use Kiwix if configured
+    if use_kiwix_server and not force:
+        return get_kiwix_summary(search_term)
+    
+    try:
+        # Otherwise use online Wikipedia
+        wikipedia_search = wikipedia.search(search_term, results=3)
+        wikipedia_suggest = wikipedia.suggest(search_term)
+        #wikipedia_aroundme = wikipedia.geosearch(lat,lon, results=3)
+        #logger.debug(f"System: Wikipedia Nearby:{wikipedia_aroundme}")
+    except Exception as e:
+        logger.debug(f"System: Wikipedia search error for:{search_term} {e}")
+        return ERROR_FETCHING_DATA
+    
+    if len(wikipedia_search) == 0:
+        logger.warning(f"System: No Wikipedia Results for:{search_term}")
+        return ERROR_FETCHING_DATA
+    
+    try:
+        logger.debug(f"System: Searching Wikipedia for:{search_term}, First Result:{wikipedia_search[0]}, Suggest Word:{wikipedia_suggest}")
+        summary = wikipedia.summary(search_term, sentences=wiki_return_limit, auto_suggest=False, redirect=True)
+    except wikipedia.DisambiguationError as e:
+        logger.warning(f"System: Disambiguation Error for:{search_term} trying {wikipedia_search[0]}")
+        summary = wikipedia.summary(wikipedia_search[0], sentences=wiki_return_limit, auto_suggest=True, redirect=True)
+    except wikipedia.PageError as e:
+        logger.warning(f"System: Wikipedia Page Error for:{search_term} {e} trying {wikipedia_search[0]}")
+        summary = wikipedia.summary(wikipedia_search[0], sentences=wiki_return_limit, auto_suggest=True, redirect=True)
+    except Exception as e:
+        logger.warning(f"System: Error with Wikipedia for:{search_term} {e}")
+        return ERROR_FETCHING_DATA
+    
+    return summary

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

pong_bot.py

@@ -2,30 +2,42 @@
 # 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
 DEBUGpacket = False # Debug print the packet rx
 
-def auto_response(message, snr, rssi, hop, message_from_id, channel_number, deviceID):
+def auto_response(message, snr, rssi, hop, pkiStatus, message_from_id, channel_number, deviceID, isDM):
     # Auto response to messages
     message_lower = message.lower()
     bot_response = "I'm sorry, I'm afraid I can't do that."
 
     command_handler = {
-        "ping": lambda: handle_ping(message, hop, snr, rssi),
-        "pong": lambda: "🏓Ping!!",
+        # 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: handle_cmd(message, message_from_id, deviceID),
+        "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),
+        "echo": lambda: handle_echo(message, message_from_id, deviceID, isDM, channel_number),
+        "lheard": lambda: handle_lheard(message, message_from_id, deviceID, isDM),
         "motd": lambda: handle_motd(message, MOTD),
-        "cmd": lambda: help_message,
-        "cmd?": lambda: help_message,
-        "lheard": lambda: handle_lheard(interface1, interface2_enabled, myNodeNum1, myNodeNum2),
-        "sitrep": lambda: handle_lheard(interface1, interface2_enabled, myNodeNum1, myNodeNum2),
-        "ack": lambda: handle_ack(hop, snr, rssi),
-        "testing": lambda: handle_testing(hop, snr, rssi),
-        "test": lambda: handle_testing(hop, snr, rssi),
+        "ping": lambda: handle_ping(message_from_id, deviceID, message, hop, snr, rssi, isDM, channel_number),
+        "pong": lambda: "🏓PING!!🛜",
+        "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),
     }
     cmds = [] # list to hold the commands found in the message
     for key in command_handler:
@@ -44,85 +56,172 @@ def auto_response(message, snr, rssi, hop, message_from_id, channel_number, devi
     
     return bot_response
 
-def handle_ping(message, hop, snr, rssi):
-    if "@" in message:
-        if hop == "Direct":
-            return "🏓PONG, " + f"SNR:{snr} RSSI:{rssi}" + " and copy: " + message.split("@")[1]
-        else:
-            return "🏓PONG, " + hop + " and copy: " + message.split("@")[1]
-    else:
-        if hop == "Direct":
-            return "🏓PONG, " + f"SNR:{snr} RSSI:{rssi}"
-        else:
-            return "🏓PONG, " + hop
+def handle_cmd(message, message_from_id, deviceID):
+    # why CMD? its just a command list. a terminal would normally use "Help"
+    # I didnt want to invoke the word "help" in Meshtastic due to its possible emergency use
+    if " " in message and message.split(" ")[1] in trap_list:
+        return "🤖 just use the commands directly in chat"
+    return help_message
 
-def handle_motd(message):
+def handle_ping(message_from_id, deviceID,  message, hop, snr, rssi, isDM, channel_number):
+    global multiPing
+    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"
+    
+    msg = ""
+    type = ''
+
+    if "ping" in message.lower():
+        msg = "🏓PONG\n"
+        type = "🏓PING"
+    elif "test" in message.lower() or "testing" in message.lower():
+        msg = random.choice(["🎙Testing 1,2,3\n", "🎙Testing\n",\
+                             "🎙Testing, testing\n",\
+                             "🎙Ah-wun, ah-two...\n", "🎙Is this thing on?\n",\
+                             "🎙Roger that!\n",])
+        type = "🎙TEST"
+    elif "ack" in message.lower():
+        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)
+        msg = f"QSP QSL OM DE  {myname}   K\n"
+    else:
+        msg = "🔊 Can you hear me now?"
+
+    if hop == "Direct":
+        msg = msg + f"SNR:{snr} RSSI:{rssi}"
+    else:
+        msg = msg + hop
+
+    if "@" in message:
+        msg = msg + " @" + message.split("@")[1]
+        type = type + " @" + message.split("@")[1]
+    elif "#" in message:
+        msg = msg + " #" + message.split("#")[1]
+        type = type + " #" + message.split("#")[1]
+
+
+    # check for multi ping request
+    if " " in message:
+        # if stop multi ping
+        if "stop" in message.lower():
+            for i in range(0, len(multiPingList)):
+                if multiPingList[i].get('message_from_id') == message_from_id:
+                    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."
+            pingCount = -1
+        else:
+            # set inital pingCount
+            try:
+                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:
+                pingCount = -1
+    
+        if pingCount > 1:
+            multiPingList.append({'message_from_id': message_from_id, 'count': pingCount + 1, 'type': type, 'deviceID': deviceID, 'channel_number': channel_number, 'startCount': pingCount})
+            if type == "🎙TEST":
+                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
+
+def handle_motd(message, message_from_id, isDM):
     global MOTD
-    if "$" in message:
+    isAdmin = False
+    msg = ""
+    # check if the message_from_id is in the bbs_admin_list
+    if bbs_admin_list != ['']:
+        for admin in bbs_admin_list:
+            if str(message_from_id) == admin:
+                isAdmin = True
+                break
+    else:
+        isAdmin = True
+
+    # admin help via DM
+    if  "?" in message and isDM and isAdmin:
+        msg = "Message of the day, set with 'motd $ HelloWorld!'"
+    elif  "?" in message and isDM and not isAdmin:
+        # non-admin help via DM
+        msg = "Message of the day"
+    elif "$" in message and isAdmin:
         motd = message.split("$")[1]
         MOTD = motd.rstrip()
-        return "MOTD Set to: " + MOTD
+        logger.debug(f"System: {message_from_id} changed MOTD: {MOTD}")
+        msg = "MOTD changed to: " + MOTD
     else:
-        return MOTD
+        msg = "MOTD: " + MOTD
+    return msg
 
-def handle_lheard(interface1, interface2_enabled, myNodeNum1, myNodeNum2):
-    bot_response = "Last heard:\n" + str(get_node_list(1))
-    chutil1 = interface1.nodes.get(decimal_to_hex(myNodeNum1), {}).get("deviceMetrics", {}).get("channelUtilization", 0)
-    chutil1 = "{:.2f}".format(chutil1)
-    if interface2_enabled:
-        bot_response += "Port2:\n" + str(get_node_list(2))
-        chutil2 = interface2.nodes.get(decimal_to_hex(myNodeNum2), {}).get("deviceMetrics", {}).get("channelUtilization", 0)
-        chutil2 = "{:.2f}".format(chutil2)
+def handle_echo(message, message_from_id, deviceID, isDM, channel_number):
+    if "?" in message.lower():
+        return "echo command returns your message back to you. Example:echo Hello World"
+    elif "echo " in message.lower():
+        parts = message.lower().split("echo ", 1)
+        if len(parts) > 1 and parts[1].strip() != "":
+            echo_msg = parts[1]
+            if channel_number != echoChannel:
+                echo_msg = "@" + get_name_from_number(message_from_id, 'short', deviceID) + " " + echo_msg
+            return echo_msg
+        else:
+            return "Please provide a message to echo back to you. Example:echo Hello World"
+    else:
+        return "Please provide a message to echo back to you. Example:echo Hello World"
+    
+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:
+        return message.split("?")[0].title() + " command returns a list of the nodes that have been heard recently"
+
+    # display last heard nodes add to response
+    bot_response = "Last Heard\n"
+    bot_response += str(get_node_list(1))
+
+    # bot_response += getNodeTelemetry(deviceID)
     return bot_response
 
-def handle_ack(hop, snr, rssi):
-    if hop == "Direct":
-        return "✋ACK-ACK! " + f"SNR:{snr} RSSI:{rssi}"
-    else:
-        return "✋ACK-ACK! " + hop
-
-def handle_testing(hop, snr, rssi):
-    if hop == "Direct":
-        return "🎙Testing 1,2,3 " + f"SNR:{snr} RSSI:{rssi}"
-    else:
-        return "🎙Testing 1,2,3 " + hop
-
-def onDisconnect(interface):
-    global retry_int1, retry_int2
-    rxType = type(interface).__name__
-    if rxType == 'SerialInterface':
-        rxInterface = interface.__dict__.get('devPath', 'unknown')
-        logger.critical(f"System: Lost Connection to Device {rxInterface}")
-        if port1 in rxInterface:
-            retry_int1 = True
-        elif interface2_enabled and port2 in rxInterface:
-            retry_int2 = True
-
-    if rxType == 'TCPInterface':
-        rxHost = interface.__dict__.get('hostname', 'unknown')
-        logger.critical(f"System: Lost Connection to Device {rxHost}")
-        if hostname1 in rxHost and interface1_type == 'tcp':
-            retry_int1 = True
-        elif interface2_enabled and hostname2 in rxHost and interface2_type == 'tcp':
-            retry_int2 = True
-
-    if rxType == 'BLEInterface':
-        logger.critical(f"System: Lost Connection to Device BLE")
-        if interface1_type == 'ble':
-            retry_int1 = True
-        elif interface2_enabled and interface2_type == 'ble':
-            retry_int2 = True
-
 def onReceive(packet, interface):
-    # extract interface  defailts from interface object
+    global seenNodes
+    # Priocess the incoming packet, handles the responses to the packet with auto_response()
+    # Sends the packet to the correct handler for processing
+
+    # extract interface details from inbound packet
     rxType = type(interface).__name__
-    rxNode = 0
-    message_from_id = 0
-    snr = 0
-    rssi = 0
-    hop = 0
-    hop_away = 0
-    
+
+    # 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:
         # Debug print the interface object
         for item in interface.__dict__.items(): intDebug = f"{item}\n"
@@ -130,112 +229,183 @@ def onReceive(packet, interface):
         # Debug print the packet for debugging
         logger.debug(f"Packet Received\n {packet} \n END of packet \n")
 
+    # 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 rxHost and hostname1 in rxHost and interface1_type == 'tcp': rxNode = 1
+        elif multiple_interface and rxHost and hostname2 in rxHost and interface2_type == 'tcp': rxNode = 2
+        elif multiple_interface and rxHost and hostname3 in rxHost and interface3_type == 'tcp': rxNode = 3
+        elif multiple_interface and rxHost and hostname4 in rxHost and interface4_type == 'tcp': rxNode = 4
+        elif multiple_interface and rxHost and hostname5 in rxHost and interface5_type == 'tcp': rxNode = 5
+        elif multiple_interface and rxHost and hostname6 in rxHost and interface6_type == 'tcp': rxNode = 6
+        elif multiple_interface and rxHost and hostname7 in rxHost and interface7_type == 'tcp': rxNode = 7
+        elif multiple_interface and rxHost and hostname8 in rxHost and interface8_type == 'tcp': rxNode = 8
+        elif multiple_interface and rxHost 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')
+        channel_name = "unknown"
+    # get channel hashes for the interface
+    device = next((d for d in channel_list if d["interface_id"] == rxNode), None)
+    if device:
+        # Find the channel name whose hash matches channel_number
+        for chan_name, info in device['channels'].items():
+            if info['hash'] == channel_number:
+                print(f"Matched channel hash {info['hash']} to channel name {chan_name}")
+                channel_name = chan_name
+                break
 
-    # check for a message packet and process it
+    # check if the packet has a simulator flag
+    simulator_flag = packet.get('decoded', {}).get('simulator', False)
+    if isinstance(simulator_flag, dict):
+        # assume Software Simulator
+        simulator_flag = True
+
+    # set the message_from_id
+    message_from_id = packet['from']
+
+    # check if the packet has a channel flag use it
+    if packet.get('channel'):
+        channel_number = packet.get('channel', 0)
+
+    # handle TEXT_MESSAGE_APP
     try:
         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']
-            try:
-                snr = packet['rxSnr']
-                rssi = packet['rxRssi']
-            except KeyError:
-                snr = 0
-                rssi = 0
+            via_mqtt = packet['decoded'].get('viaMqtt', False)
+            transport_mechanism = packet['decoded'].get('transport_mechanism', 'unknown')
+
+            # 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'):
+                snr = packet.get('rxSnr', 0)
+                rssi = packet.get('rxRssi', 0)
+
+            # check if the packet has a publicKey flag use it
+            if packet.get('publicKey'):
+                pkiStatus = packet.get('pkiEncrypted', False), packet.get('publicKey', 'ABC')
+            
+            # check if the packet has replyId flag // currently unused in the code
+            if packet.get('replyId'):
+                replyIDset = packet.get('replyId', False)
+            
+            # check if the packet has emoji flag set it // currently unused in the code
+            if packet.get('emoji'):
+                emojiSeen = packet.get('emoji', False)
 
-            if packet.get('channel'):
-                channel_number = packet['channel']
-            else:
-                channel_number = publicChannel
-        
             # check if the packet has a hop count flag use it
             if packet.get('hopsAway'):
-                hop_away = packet['hopsAway']
-            else:
-                # if the packet does not have a hop count try other methods
-                hop_away = 0
-                if packet.get('hopLimit'):
-                    hop_limit = packet['hopLimit']
-                else:
-                    hop_limit = 0
-                
-                if packet.get('hopStart'):
-                    hop_start = packet['hopStart']
-                else:
-                    hop_start = 0
+                hop_away = packet.get('hopsAway', 0)
 
-            if hop_start == hop_limit:
-                hop = "Direct"
-            else:
-                # set hop to Direct if the message was sent directly otherwise set the hop count
-                if hop_away > 0:
-                    hop_count = hop_away
-                else:
-                    hop_count = hop_start - hop_limit
-                    #print (f"calculated hop count: {hop_start} - {hop_limit} = {hop_count}")
+            if packet.get('hopStart'):
+                hop_start = packet.get('hopStart', 0)
 
-                hop = f"{hop_count} hops"
+            if packet.get('hopLimit'):
+                hop_limit = packet.get('hopLimit', 0)
             
-            if message_string == help_message or message_string == welcome_message or "CMD?:" in message_string:
+            # calculate hop count
+            hop = ""
+            if hop_limit > 0 and hop_start >= hop_limit:
+                hop_count = hop_away + (hop_start - hop_limit)
+            elif hop_limit > 0 and hop_start < hop_limit:
+                hop_count = hop_away + (hop_limit - hop_start)
+            else:
+                hop_count = hop_away
+
+            if hop_away == 0 and hop_limit == 0 and hop_start == 0:
+                hop = "Last Hop"
+
+            if hop_start == hop_limit and "lora" in str(transport_mechanism).lower():
+                hop = "Direct"
+
+            if ((hop_start == 0 and hop_limit >= 0) or via_mqtt or ("mqtt" in str(transport_mechanism).lower())):
+                hop = "MQTT"
+
+            if "unknown" in str(transport_mechanism).lower() and (snr == 0 and rssi == 0):
+                hop = "IP-Network"
+
+            if enableHopLogs:
+                logger.debug(f"System: Packet HopDebugger: hop_away:{hop_away} hop_limit:{hop_limit} hop_start:{hop_start} calculated_hop_count:{hop_count} final_hop_value:{hop} via_mqtt:{via_mqtt} transport_mechanism:{transport_mechanism}")
+
+            # check with stringSafeChecker if the message is safe
+            if stringSafeCheck(message_string) is False:
+                logger.warning(f"System: Possibly Unsafe Message from {get_name_from_number(message_from_id, 'long', rxNode)}")
+
+            if help_message in message_string or welcome_message in message_string or "CMD?:" in message_string:
                 # ignore help and welcome messages
                 logger.warning(f"Got Own Welcome/Help header. From: {get_name_from_number(message_from_id, 'long', rxNode)}")
                 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:
                 # message is DM to us
-
+                isDM = True
                 # check if the message contains a trap word, DMs are always responded to
-                if messageTrap(message_string):
+                if (messageTrap(message_string) and not llm_enabled) or messageTrap(message_string.split()[0]):
+                    # log the message to stdout
                     logger.info(f"Device:{rxNode} Channel: {channel_number} " + CustomFormatter.green + f"Received DM: " + CustomFormatter.white + f"{message_string} " + CustomFormatter.purple +\
                                 "From: " + CustomFormatter.white + f"{get_name_from_number(message_from_id, 'long', rxNode)}")
                     # respond with DM
-                    send_message(auto_response(message_string, snr, rssi, hop, message_from_id, channel_number, rxNode), channel_number, message_from_id, rxNode)
-                else: 
-                    # respond with welcome message on DM
+                    send_message(auto_response(message_string, snr, rssi, hop, pkiStatus, message_from_id, channel_number, rxNode, isDM), channel_number, message_from_id, rxNode)
+                else:
                     logger.warning(f"Device:{rxNode} Ignoring DM: {message_string} From: {get_name_from_number(message_from_id, 'long', rxNode)}")
                     send_message(welcome_message, channel_number, message_from_id, rxNode)
-                    msgLogger.info(f"Device:{rxNode} Channel:{channel_number} | {get_name_from_number(message_from_id, 'long', rxNode)} | {message_string}")
+                    
+                    # log the message to the message log
+                    if log_messages_to_file:
+                        msgLogger.info(f"Device:{rxNode} Channel:{channel_number} | {get_name_from_number(message_from_id, 'long', rxNode)} | DM | " + message_string.replace('\n', '-nl-'))
             else:
                 # message is on a channel
                 if messageTrap(message_string):
-                    # message is for bot to respond to
-                    logger.info(f"Device:{rxNode} Channel:{channel_number} " + CustomFormatter.green + "Received: " + CustomFormatter.white + f"{message_string} " + CustomFormatter.purple +\
-                                 "From: " + CustomFormatter.white + f"{get_name_from_number(message_from_id, 'long', rxNode)}")
-                    if useDMForResponse:
-                        # respond to channel message via direct message
-                        send_message(auto_response(message_string, snr, rssi, hop, message_from_id, channel_number, rxNode), channel_number, message_from_id, rxNode)
+                    if ignoreDefaultChannel and channel_number == publicChannel:
+                        logger.debug(f"System: ignoreDefaultChannel CMD:{message_string} From: {get_name_from_number(message_from_id, 'short', rxNode)}")
                     else:
-                        # or respond to channel message on the channel itself
-                        if channel_number == publicChannel and antiSpam:
-                            # warning user spamming default channel
-                            logger.error(f"System: AntiSpam protection, sending DM to: {get_name_from_number(message_from_id, 'long', rxNode)}")
-                        
+                        # message is for bot to respond to
+                        logger.info(f"Device:{rxNode} Channel:{channel_number} " + CustomFormatter.green + "ReceivedChannel: " + CustomFormatter.white + f"{message_string} " + CustomFormatter.purple +\
+                                    "From: " + CustomFormatter.white + f"{get_name_from_number(message_from_id, 'long', rxNode)}")
+                        if useDMForResponse:
                             # respond to channel message via direct message
-                            send_message(auto_response(message_string, snr, rssi, hop, message_from_id, channel_number, rxNode), channel_number, message_from_id, rxNode)
+                            send_message(auto_response(message_string, snr, rssi, hop, pkiStatus, message_from_id, channel_number, rxNode, isDM), channel_number, message_from_id, rxNode)
                         else:
-                            # respond to channel message on the channel itself
-                            send_message(auto_response(message_string, snr, rssi, hop, message_from_id, channel_number, rxNode), channel_number, 0, rxNode)
+                            # or respond to channel message on the channel itself
+                            if channel_number == publicChannel and antiSpam:
+                                # warning user spamming default channel
+                                logger.warning(f"System: AntiSpam protection, sending DM to: {get_name_from_number(message_from_id, 'long', rxNode)}")
+                            
+                                # respond to channel message via direct message
+                                send_message(auto_response(message_string, snr, rssi, hop, pkiStatus, message_from_id, channel_number, rxNode, isDM), channel_number, message_from_id, rxNode)
+                            else:
+                                # respond to channel message on the channel itself
+                                send_message(auto_response(message_string, snr, rssi, hop, pkiStatus, message_from_id, channel_number, rxNode, isDM), channel_number, 0, rxNode)
+
                 else:
                     # message is not for bot to respond to
                     # ignore the message but add it to the message history list
@@ -257,45 +427,66 @@ 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, channel_number)
     except KeyError as e:
         logger.critical(f"System: Error processing packet: {e} Device:{rxNode}")
-        print(packet) # print the packet for debugging
-        print("END of packet \n")
+        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)
     # 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 useDMForResponse:
+        logger.debug(f"System: Respond by DM only")
     if log_messages_to_file:
         logger.debug("System: Logging Messages to disk")
+    if syslog_to_file:
+        logger.debug("System: Logging System Logs to disk")
+    if motd_enabled:
+        logger.debug(f"System: MOTD Enabled using {MOTD}")
+    if enableEcho:
+        logger.debug(f"System: Echo command Enabled")
     if sentry_enabled:
-        logger.debug("System: Sentry Enabled")
-    if store_forward_enabled:
-        logger.debug(f"System: Store and Forward Enabled using limit: {storeFlimit}")
-    if useDMForResponse:
-        logger.debug("System: Respond by DM only")
-    if repeater_enabled and interface2_enabled:
+        logger.debug(f"System: Sentry Mode Enabled {sentry_radius}m radius reporting to channel:{secure_channel}")
+    if highfly_enabled:
+        logger.debug(f"System: HighFly Enabled using {highfly_altitude}m limit reporting to channel:{highfly_channel}")
+    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 bbs_enabled:
+        logger.debug(f"System: BBS Enabled, {bbsdb} has {len(bbs_messages)} messages. Direct Mail Messages waiting: {(len(bbs_dm) - 1)}")
+        if bbs_link_enabled:
+            if len(bbs_link_whitelist) > 0:
+                logger.debug(f"System: BBS Link Enabled with {len(bbs_link_whitelist)} peers")
+            else:
+                logger.debug(f"System: BBS Link Enabled allowing all")
+    if scheduler_enabled:
+        # Examples of using the scheduler, Times here are in 24hr format
+        # https://schedule.readthedocs.io/en/stable/
+        
+        # Reminder Scheduler is enabled every Monday at noon send a log message
+        schedule.every().monday.at("12:00").do(lambda: logger.info("System: Scheduled Broadcast Reminder"))
+        logger.debug("System: Starting the broadcast scheduler")
+        await BroadcastScheduler()
 
     # here we go loopty loo
     while True:
@@ -304,16 +495,49 @@ async def start_rx():
 
 # Hello World 
 async def main():
-    meshRxTask = asyncio.create_task(start_rx())
-    watchdogTask = asyncio.create_task(watchdog())
-    await asyncio.wait([meshRxTask, watchdogTask])
+    tasks = []
+    
+    try:
+        # Create core tasks
+        tasks.append(asyncio.create_task(start_rx(), name="pong_rx"))
+        tasks.append(asyncio.create_task(watchdog(), name="watchdog"))
+        
+        # Add optional tasks
+        if file_monitor_enabled:
+            tasks.append(asyncio.create_task(handleFileWatcher(), name="file_monitor"))
+        
+        logger.debug(f"System: Starting {len(tasks)} async tasks")
+        
+        # Wait for all tasks with proper exception handling
+        results = await asyncio.gather(*tasks, return_exceptions=True)
+        
+        # Check for exceptions in results
+        for i, result in enumerate(results):
+            if isinstance(result, Exception):
+                logger.error(f"Task {tasks[i].get_name()} failed with: {result}")
+        
+    except Exception as e:
+        logger.error(f"Main loop error: {e}")
+    finally:
+        # Cleanup tasks
+        logger.debug("System: Cleaning up async tasks")
+        for task in tasks:
+            if not task.done():
+                task.cancel()
+                try:
+                    await task
+                except asyncio.CancelledError:
+                    logger.debug(f"Task {task.get_name()} cancelled successfully")
+                except Exception as e:
+                    logger.warning(f"Error cancelling task {task.get_name()}: {e}")
 
-try:
-    asyncLoop = asyncio.new_event_loop()
-    if __name__ == "__main__":
+    await asyncio.sleep(0.01)
+
+if __name__ == "__main__":
+    try:
         asyncio.run(main())
-except KeyboardInterrupt:
-    exit_handler()
-    pass
-
+    except KeyboardInterrupt:
+        exit_handler()
+    except SystemExit:
+        pass
 # EOF

requirements.txt

@@ -3,17 +3,10 @@ pubsub
 datetime
 pyephem
 requests
-geopy
 maidenhead
 beautifulsoup4
 dadjokes
-openmeteo_requests
-retry_requests
-numpy
 geopy
 schedule
 wikipedia
-langchain
-langchain-ollama
-ollama
 googlesearch-python

script/addFav.py

@@ -0,0 +1,130 @@
+#!/usr/bin/env python3
+# Add a favorite node to all interfaces from config.ini data
+# meshing-around - helper script
+import sys
+import os
+import pickle
+import argparse
+
+favList = []
+roofNodeList = []
+roof_node = False
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description="Add favorite nodes or print pickle contents.")
+    parser.add_argument('-pickle', '-p', action='store_true', help="Print the contents of roofNodeList.pkl and exit")
+    args = parser.parse_args()
+
+    if args.pickle:
+        try:
+            with open('roofNodeList.pkl', 'rb') as f:
+                data = pickle.load(f)
+            #print a simple list of nodeID:x\n
+            for item in data:
+                print(f"{item.get('nodeID', 'N/A')}")
+        except Exception as e:
+            print(f"Error reading roofNodeList.pkl: {e}")
+        exit(0)
+
+# welcome header
+print("meshing-around: addFav - Auto-Add favorite nodes to all interfaces from config.ini data")
+print("This script may need API improvments still in progress")
+print("---------------------------------------------------------------")
+
+try:
+    # set the path to import the modules and config.ini
+    sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+    from modules.log import *
+    from modules.system import *
+except Exception as e:
+    print(f"Error importing modules run this program from the main repo directory 'python3 script/addFav.py'")
+    print(f"if you forgot the rest of it.. git clone https://github.com/spudgunman/meshing-around")
+    print(f"Import Error: {e}")
+    exit(1)
+
+try:
+    # ask if we are running on a roof node
+    print("This script can be run on a client_base or on the bot under a roof node.")
+    print("The purpose of this script is to add favorite nodes to the bot to retain DM keys.")
+    print("If you are running this script on a roof (base) node, stop and rerun it on the bot first to collect all node ID's.")
+    roof_node = input("Are you running this script on a client_base node which has no BOT? (y/n): ").strip().lower()
+    if roof_node not in ['y', 'n']:
+        raise ValueError("Invalid input. Please enter 'y' or 'n'.")
+    roof_node = (roof_node == 'y')
+except Exception as e:
+    print(f"Error: {e}")
+    exit(1)
+
+try:
+    if roof_node:
+        # load roofNodeList from pickle file
+        try:
+            with open('roofNodeList.pkl', 'rb') as f:
+                roofNodeList = pickle.load(f)
+            logger.info(f"addFav: Loaded {len(roofNodeList)} connected nodes from roofNodeList.pkl for use on roof client_base only")
+            print(f"Loaded {len(roofNodeList)} connected nodes from roofNodeList.pkl for use on roof client_base only")
+        except Exception as e:
+            logger.error(f"addFav: Error loading roofNodeList.pkl: {e} - run this program from the main program directory 'python3 script/addFav.py'")
+            exit(1)
+        favList = roofNodeList
+    else:
+        # compile the favorite list wich returns node,interface tuples
+        roofNodeList = compileFavoriteList(True)
+        favList = compileFavoriteList(False)
+
+        #combine favList and roofNodeList to save for next step
+        for node in roofNodeList:
+            if node not in favList:
+                favList.append(node)
+
+        #save roofNodeList to a pickle file for running on the roof node
+        with open('roofNodeList.pkl', 'wb') as f:
+            pickle.dump(roofNodeList, f)
+        logger.info(f"addFav: Saved {len(roofNodeList)} connected nodes to roofNodeList.pkl for use on roof client_base only")
+        print(f"Saved {len(roofNodeList)} connected nodes to roofNodeList.pkl for use on roof client_base only")
+
+except Exception as e:
+    logger.error(f"addFav: Error compiling favorite list: {e} - run this program from the main program directory 'python3 script/addFav.py'")
+    exit(1)
+
+#confirm you want all these added
+try:
+    if favList:
+        print(f"The following {len(favList)} favorite nodes will be added to the device(s):")
+        count_devices = set([fav['deviceID'] for fav in favList])
+        count_nodes = set([fav['nodeID'] for fav in favList])
+        for fav in favList:
+            print(f"addFav: adding nodeID {fav['nodeID']} meshtastic --set-favorite-node {fav['nodeID']}")
+        confirm = input(f"Are you sure you want to add these {len(count_nodes)} favorite nodes to {len(count_devices)} device(s)? (y/n): ").strip().lower()
+        if confirm != 'y':
+            print("Operation cancelled by user.")
+            exit(0)
+    else:
+        print("No favorite nodes to add to device(s). Exiting.")
+        exit(0)
+except Exception as e:
+    logger.error(f"addFav: Error during confirmation: {e}")
+    exit(1)
+
+if favList:
+    # for each node,interface tuple add the favorite node
+    for fav in favList:
+        try:
+            handleFavoriteNode(fav['deviceID'], fav['nodeID'], True)
+            logger.info(f"addFav: waiting 15 seconds to avoid API rate limits")
+            time.sleep(15)  # wait to avoid API rate limits
+        except Exception as e:
+            logger.error(f"addFav: Error adding favorite node {fav['nodeID']} to device {fav['deviceID']}: {e}")
+else:
+    logger.info("addFav: No favorite nodes to add to device(s)")
+    exit(0)
+
+count_devices = set([fav['deviceID'] for fav in favList])
+count_nodes = set([fav['nodeID'] for fav in favList])
+logger.info(f"addFav: Finished adding {len(count_nodes)} favorite nodes to {len(count_devices)} device(s)")
+logger.info("addFav: You may need to restart the mesh service on the device(s)")
+print(f"Finished adding {len(count_nodes)} favorite nodes to {len(count_devices)} device(s)")
+print(f"Data file for roof client_base has been saved to roofNodeList.pkl")
+if not roof_node:
+    logger.info(f"addFav: You can now run this repo+script & roofNodeList.pkl on the roof node to add the favorite nodes to the roof client_base")
+exit(0)

script/configMerge.py

@@ -0,0 +1,104 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+# Configuration Merge Script
+# Merges user configuration with default settings
+# 2025 Kelly Keeton K7MHI mesh-around and its meshtastic
+import shutil
+import configparser
+import os
+
+
+def merge_configs(default_config_path, user_config_path, output_config_path):
+    # Load default configuration (INI)
+    default_config = configparser.ConfigParser()
+    default_config.read(default_config_path)
+
+    # Load user configuration (INI)
+    user_config = configparser.ConfigParser()
+    user_config.read(user_config_path)
+
+    # Merge configurations
+    for section in user_config.sections():
+        if not default_config.has_section(section):
+            default_config.add_section(section)
+        for key, value in user_config.items(section):
+            default_config.set(section, key, value)
+
+    # Save merged configuration as INI
+    with open(output_config_path, 'w', encoding='utf-8') as f:
+        default_config.write(f)
+
+def backup_config(config_path, backup_path):
+    shutil.copyfile(config_path, backup_path)
+
+def show_config_changes(user_config_path, merged_config_path):
+    if not os.path.exists(merged_config_path) or os.path.getsize(merged_config_path) == 0:
+        print(f"Error: {merged_config_path} is empty or missing!")
+        return
+
+    # Load user config (as dict)
+    user_config = configparser.ConfigParser()
+    user_config.read(user_config_path)
+    user_dict = {s: dict(user_config.items(s)) for s in user_config.sections()}
+
+    # Load merged config (as dict)
+    merged_config = configparser.ConfigParser()
+    merged_config.read(merged_config_path)
+    merged_dict = {s: dict(merged_config.items(s)) for s in merged_config.sections()}
+
+    print("\n--- Changes in merged configuration ---")
+    for section in merged_dict:
+        if section not in user_dict:
+            print(f"[{section}] (new section)")
+            for k, v in merged_dict[section].items():
+                print(f"  {k} = {v} (added)")
+        else:
+            for k, v in merged_dict[section].items():
+                if k not in user_dict[section]:
+                    print(f"[{section}] {k} = {v} (added)")
+                elif user_dict[section][k] != v:
+                    print(f"[{section}] {k}: {user_dict[section][k]} -> {v} (changed)")
+    print("--- End of changes ---\n")
+
+if __name__ == "__main__":
+    print("MESHING-AROUND: Configuration Merge Script for config.ini checking updates from config.template")
+    print("---------------------------------------------------------------")
+    master_config_path = 'config.template'
+    user_config_path = 'config.ini'
+    output_config = 'config_new.ini'
+    backup_config_path = 'config.bak'
+
+    # Step 1: Check master config
+    try:
+        if not os.path.exists(master_config_path) or os.path.getsize(master_config_path) == 0:
+            raise FileNotFoundError(f"Master configuration file {master_config_path} is missing or empty.")
+    except Exception as e:
+        print(f"Error: {e}")
+        print("Run the tool from the meshing-around/script/ directory where the config.template is located.")
+        print("  python3 script/configMerge.py")
+        exit(1)
+
+    # Step 2: Backup user config
+    try:
+        backup_config(user_config_path, backup_config_path)
+        print(f"Backup of user config created at {backup_config_path}")
+    except Exception as e:
+        print(f"Error backing up user config: {e}")
+        exit(1)
+
+    # Step 3: Merge configs
+    try:
+        merge_configs(master_config_path, user_config_path, output_config)
+        print(f"Merged configuration saved to {output_config}")
+    except Exception as e:
+        print(f"Error merging configuration: {e}")
+        exit(1)
+
+    # Step 4: Show changes
+    try:
+        show_config_changes(user_config_path, output_config)
+        print("Please review the new configuration and replace your existing config.ini if needed.")
+        print(" cp config_new.ini config.ini")
+    except Exception as e:
+        print(f"Error showing configuration changes: {e}")
+        exit(1)

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
+    ```

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

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"

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

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

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

script/injectDM.py

@@ -0,0 +1,53 @@
+#!/usr/bin/env python3
+# Usage: python3 script/injectDM.py -s NODEID -d NODEID -m "message"
+# meshing-around - helper script
+import sys
+import os
+import argparse
+
+# welcome header
+print("meshing-around: injectDM.py -s NODEID -d NODEID -m 'Hello World'")
+print("Auto-Inject DM messages to data/bbsdm.pkl")
+print(" needs config.ini [bbs] bbsAPI_enabled = True ")
+print("---------------------------------------------------------------")
+
+try:
+    # set the path to import the modules and config.ini
+    sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..')))
+    from modules.log import *
+    from modules.bbstools import *
+except Exception as e:
+    print(f"Error importing modules run this program from the main program directory 'python3 script/injectDM.py'")
+    exit(1)
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(description='Inject DM messages to data/bbsdm.pkl')
+    parser.add_argument('-s', '--src', type=str, required=True, help='Source NODEID')
+    parser.add_argument('-d', '--dst', type=str, required=True, help='Destination NODEID')
+    parser.add_argument('-m', '--msg', type=str, required=True, help="'Message to send'")
+    args = parser.parse_args()
+    dst = args.dst
+    src = args.src
+    message = args.msg
+    if not message:
+        logger.error("Message cannot be empty")
+        exit(1)
+    if dst == src:
+        logger.error("Source and Destination cannot be the same")
+        exit(1)
+
+    if not isinstance(bbs_dm, list):
+        logger.error("bbs_dm is corrupt, something is wrong")
+        exit(1)
+
+    # inject the message
+    if bbs_post_dm(dst, message, src):
+        logger.info(f"Injected message from {src} to {dst}: {message}")
+    else:
+        logger.error("Failed to inject message")
+        exit(1)
+
+    # show stats get_bbs_stats
+    stats = get_bbs_stats()
+    stats = stats.replace("\n", " | ")
+    logger.info(f"BBS Stats: {stats}")

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"

script/sysEnv.sh

@@ -0,0 +1,44 @@
+#!/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"
+
+# attempt check for updates
+if command -v git &> /dev/null
+then
+    if [ -d ../.git ]; then
+        # check for updates
+        git fetch --quiet
+        local_branch=$(git rev-parse --abbrev-ref HEAD)
+        if [ "$local_branch" != "HEAD" ] && git show-ref --verify --quiet "refs/remotes/origin/$local_branch"; then
+            local_commit=$(git rev-parse "$local_branch")
+            remote_commit=$(git rev-parse "origin/$local_branch")
+            if [ "$local_commit" != "$remote_commit" ]; then
+                echo "Bot Update Available!"
+            fi
+        fi
+    fi
+fi

update.sh

@@ -0,0 +1,87 @@
+#!/bin/bash
+# MeshBot Update Script
+# Usage: bash update.sh or ./update.sh after making it executable with chmod +x update.sh
+
+# Check if the mesh_bot.service or pong_bot.service 
+if systemctl is-active --quiet mesh_bot.service; then
+    echo "Stopping mesh_bot.service..."
+    systemctl stop mesh_bot.service
+    service_stopped=true
+fi
+if systemctl is-active --quiet pong_bot.service; then
+    echo "Stopping pong_bot.service..."
+    systemctl stop pong_bot.service
+    service_stopped=true
+fi
+if systemctl is-active --quiet mesh_bot_reporting.service; then
+    echo "Stopping mesh_bot_reporting.service..."
+    systemctl stop mesh_bot_reporting.service
+    service_stopped=true
+fi
+if systemctl is-active --quiet mesh_bot_w3.service; then
+    echo "Stopping mesh_bot_w3.service..."
+    systemctl stop mesh_bot_w3.service
+    service_stopped=true
+fi
+
+# Fetch latest changes from GitHub
+echo "Fetching latest changes from GitHub..."
+if ! git fetch origin; then
+    echo "Error: Failed to fetch from GitHub, check your network connection."
+    exit 1
+fi
+
+# git pull with rebase to avoid unnecessary merge commits
+echo "Pulling latest changes from GitHub..."
+if ! git pull origin main --rebase; then
+    read -p "Git pull resulted in conflicts. Do you want to reset hard to origin/main? This will discard local changes. (y/n): " choice
+    if [[ "$choice" == "y" || "$choice" == "Y" ]]; then
+        git fetch --all
+        git reset --hard origin/main
+        echo "Local repository updated."
+    else
+        echo "Update aborted due to git conflicts."
+    fi
+fi
+
+# Backup the data/ directory
+echo "Backing up data/ directory..."
+#backup_file="backup_$(date +%Y%m%d_%H%M%S).tar.gz"
+backup_file="data_backup.tar.gz"
+path2backup="data/"
+tar -czf "$backup_file" "$path2backup"
+if [ $? -ne 0 ]; then
+    echo "Error: Backup failed."
+else
+    echo "Backup of ${path2backup} completed: ${backup_file}"
+fi
+
+
+# Build a config_new.ini file merging user config with new defaults
+echo "Merging configuration files..."
+python3 script/configMerge.py > ini_merge_log.txt 2>&1
+
+if [ -f ini_merge_log.txt ]; then
+    if grep -q "Error during configuration merge" ini_merge_log.txt; then
+        echo "Configuration merge encountered errors. Please check ini_merge_log.txt for details."
+    else
+        echo "Configuration merge completed. Please review config_new.ini and ini_merge_log.txt."
+    fi
+else
+    echo "Configuration merge log (ini_merge_log.txt) not found. check out the script/configMerge.py tool!"
+fi
+
+# if service was stopped earlier, restart it
+if [ "$service_stopped" = true ]; then
+    echo "Restarting services..."
+    systemctl start mesh_bot.service
+    systemctl start pong_bot.service
+    systemctl start mesh_bot_reporting.service
+    systemctl start mesh_bot_w3.service
+    echo "Services restarted."
+fi
+
+# Print completion message
+echo "Update completed successfully?"
+exit 0
+# End of script