Update xtide.md

Co-authored-by: SpudGunMan <12676665+SpudGunMan@users.noreply.github.com>

.github/dependabot.yml

@@ -0,0 +1,28 @@
+---
+version: 2
+updates:
+  - package-ecosystem: "github-actions"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    assignees:
+      - "SpudGunMan"
+    labels:
+      - "dependencies"
+  - package-ecosystem: "pip"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    assignees:
+      - "SpudGunMan"
+    labels:
+      - "dependencies"
+  - package-ecosystem: "docker"
+    directory: "/"
+    schedule:
+      interval: "weekly"
+    assignees:
+      - "SpudGunMan"
+    labels:
+      - "dependencies"
+

.github/workflows/docker-image.yml

@@ -0,0 +1,61 @@
+#
+name: Create and publish a Docker image on new release
+
+# Configures this workflow to run every time a change is pushed to the branch called `release`.
+on:
+  release:
+    types: [released]
+  workflow_dispatch:
+
+# Defines two custom environment variables for the workflow. These are used for the Container registry domain, and a name for the Docker image that this workflow builds.
+env:
+  REGISTRY: ghcr.io
+  IMAGE_NAME: ${{ github.repository }}
+
+# There is a single job in this workflow. It's configured to run on the latest available version of Ubuntu.
+jobs:
+  build-and-push-image:
+    runs-on: ubuntu-latest
+    # Sets the permissions granted to the `GITHUB_TOKEN` for the actions in this job.
+    permissions:
+      contents: read
+      packages: write
+      attestations: write
+      id-token: write
+      #
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v5
+      # Uses the `docker/login-action` action to log in to the Container registry registry using the account and password that will publish the packages. Once published, the packages are scoped to the account defined here.
+      - name: Log in to the Container registry
+        uses: docker/login-action@28fdb31ff34708d19615a74d67103ddc2ea9725c
+        with:
+          registry: ${{ env.REGISTRY }}
+          username: ${{ github.actor }}
+          password: ${{ secrets.GITHUB_TOKEN }}
+      # This step uses [docker/metadata-action](https://github.com/docker/metadata-action#about) to extract tags and labels that will be applied to the specified image. The `id` "meta" allows the output of this step to be referenced in a subsequent step. The `images` value provides the base name for the tags and labels.
+      - name: Extract metadata (tags, labels) for Docker
+        id: meta
+        uses: docker/metadata-action@032a4b3bda1b716928481836ac5bfe36e1feaad6
+        with:
+          images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
+      # This step uses the `docker/build-push-action` action to build the image, based on your repository's `Dockerfile`. If the build succeeds, it pushes the image to GitHub Packages.
+      # It uses the `context` parameter to define the build's context as the set of files located in the specified path. For more information, see [Usage](https://github.com/docker/build-push-action#usage) in the README of the `docker/build-push-action` repository.
+      # It uses the `tags` and `labels` parameters to tag and label the image with the output from the "meta" step.
+      - name: Build and push Docker image
+        id: push
+        uses: docker/build-push-action@9e436ba9f2d7bcd1d038c8e55d039d37896ddc5d
+        with:
+          context: .
+          push: true
+          tags: ${{ steps.meta.outputs.tags }}
+          labels: ${{ steps.meta.outputs.labels }}
+      
+      # This step generates an artifact attestation for the image, which is an unforgeable statement about where and how it was built. It increases supply chain security for people who consume the image. For more information, see [Using artifact attestations to establish provenance for builds](/actions/security-guides/using-artifact-attestations-to-establish-provenance-for-builds).
+      - name: Generate artifact attestation
+        uses: actions/attest-build-provenance@v3
+        with:
+          subject-name: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME}}
+          subject-digest: ${{ steps.push.outputs.digest }}
+          push-to-registry: true
+      

.github/workflows/greetings.yml

@@ -0,0 +1,22 @@
+name: Greetings
+
+on:
+  issues:
+    types: [opened]
+  pull_request:
+    types: [opened]
+
+permissions:
+  issues: write
+  pull-requests: write
+
+jobs:
+  greeting:
+    name: Greet first-time contributors
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/first-interaction@v3
+        with:
+          repo-token: ${{ secrets.GITHUB_TOKEN }}
+          issue_message: "Dependabot's first issue"
+          pr_message: "Thank you for your pull request!"

.gitignore

@@ -1,5 +1,7 @@
 # config
 config.ini
+config_new.ini
+ini_merge_log.txt
 
 # Pickle files
 *.pkl
@@ -23,8 +25,16 @@ data/rag/*
 # qrz db
 data/qrz.db
 
+# checklist and inventory databases
+data/checklist.db
+data/inventory.db
+
 # fileMonitor test file
 bee.txt
 
 # .csv files
-*.csv
+*.csv
+
+# modules/custom_scheduler.py
+modules/custom_scheduler.py
+

Dockerfile

@@ -1,21 +1,43 @@
-FROM python:3.13-slim
+FROM python:3.14-slim
 ENV PYTHONUNBUFFERED=1
 
-RUN apt-get update && apt-get install -y gettext tzdata locales nano && rm -rf /var/lib/apt/lists/*
+ENV PYTHONUNBUFFERED=1 \
+    LANG=en_US.UTF-8 \
+    LANGUAGE=en_US:en \
+    LC_ALL=en_US.UTF-8 \
+    TZ=America/Los_Angeles
 
-# 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 TZ="America/Los_Angeles"
+RUN apt-get update && \
+    apt-get install -y \
+        build-essential \
+        python3-dev \
+        gettext \
+        tzdata \
+        locales \
+        nano && \
+    sed -i 's/^# *\(en_US.UTF-8 UTF-8\)/\1/' /etc/locale.gen && \
+    locale-gen en_US.UTF-8 && \
+    rm -rf /var/lib/apt/lists/*
 
 WORKDIR /app
+
+# Install dependencies first for better caching
+COPY requirements.txt /app/
+RUN pip install --no-cache-dir -r /app/requirements.txt
+
+# Copy the rest of the application
 COPY . /app
 COPY config.template /app/config.ini
 
-RUN pip install -r requirements.txt
-
 RUN chmod +x /app/script/docker/entrypoint.sh
 
+# Add a non-root user and switch to it
+# RUN useradd -m appuser && usermod -a -G dialout appuser
+# USER appuser
+
+# Expose Meshtastic TCP API port from the host
+#EXPOSE 4403
+# Meshing Around Web Dashboard port
+#EXPOSE 8420
+
 ENTRYPOINT ["/bin/bash", "/app/script/docker/entrypoint.sh"]

INSTALL.md

@@ -0,0 +1,199 @@
+# INSTALL.md
+
+## Table of Contents
+
+- [Manual Install](#manual-install)
+- [Docker Installation](#docker-installation)
+- [Requirements](#requirements)
+- [install.sh](#installsh)
+  - [Purpose](#purpose)
+  - [Usage](#usage)
+  - [What it does](#what-it-does)
+  - [When to use](#when-to-use)
+  - [Note](#note)
+- [update.sh](#updatesh)
+  - [Purpose](#purpose-1)
+  - [Usage](#usage-1)
+  - [What it does](#what-it-does-1)
+  - [When to use](#when-to-use-1)
+  - [Note](#note-1)
+- [launch.sh](#launchsh)
+  - [Purpose](#purpose-2)
+  - [How to Use](#how-to-use)
+  - [What it does](#what-it-does-2)
+  - [Note](#note-2)
+
+---
+
+## Manual Install
+
+Install all required dependencies using pip:
+
+```sh
+pip install -r requirements.txt
+```
+
+Copy the configuration template and edit as needed:
+
+```sh
+cp config.template config.ini
+```
+
+---
+
+## Docker Installation
+
+See [script/docker/README.md](script/docker/README.md) for Docker-based setup instructions.  
+Docker is recommended for Windows or if you want an isolated environment.
+
+---
+
+## Requirements
+
+- **Python 3.8 or later** (Python 3.13+ supported in Docker)
+- All dependencies are listed in `requirements.txt` and can be installed with:
+  ```sh
+  pip install -r requirements.txt
+  ```
+- To enable emoji in the Debian/Ubuntu console:
+  ```sh
+  sudo apt-get install fonts-noto-color-emoji
+  ```
+- For Ollama LLM support, see the prompts during `install.sh` or visit [https://ollama.com](https://ollama.com).
+
+---
+
+## install.sh
+
+### Purpose
+
+`install.sh` automates installation, configuration, and service setup for the Meshing Around Bot project. It is designed for Linux systems (Debian/Ubuntu/Raspberry Pi and embedded devices).
+
+### Usage
+
+Run from the project root directory:
+
+```sh
+bash install.sh
+```
+
+To uninstall:
+
+```sh
+bash install.sh --nope
+```
+
+### What it does
+
+- Checks for existing installations and permissions.
+- Optionally moves the project to `/opt/meshing-around`.
+- Installs Python and pip if missing (unless on embedded systems).
+- Adds the current user (or a dedicated `meshbot` user) to necessary groups for serial and Bluetooth access.
+- Copies and configures systemd service files for running the bot as a service.
+- Sets up configuration files, updating latitude/longitude automatically.
+- Offers to create and activate a Python virtual environment, or install dependencies system-wide.
+- Installs optional components (emoji fonts, Ollama LLM) if desired.
+- Sets permissions for log and data directories.
+- Optionally installs and enables the bot as a systemd service.
+- Provides post-installation notes and commands in `install_notes.txt`.
+- Offers to reboot the system to complete setup.
+
+### When to use
+
+- For first-time installation of the Meshing Around Bot.
+- When migrating to a new device or environment.
+- After cloning or updating the repository to set up dependencies and services.
+
+### Note
+
+- You may be prompted for input during installation (e.g., for embedded mode, virtual environment, or optional features).
+- Review and edit the script if you have custom requirements or are running on a non-standard system.
+
+---
+
+## update.sh
+
+### Purpose
+
+`update.sh` is an update and maintenance script for the Meshing Around Bot project. It automates the process of safely updating your codebase, backing up data, and merging configuration changes.
+
+### Usage
+
+Run from the project root directory:
+
+```sh
+bash update.sh
+```
+Or, after making it executable:
+```sh
+chmod +x update.sh
+./update.sh
+```
+
+### What it does
+
+- Stops running Mesh Bot services to prevent conflicts during update.
+- Fetches and pulls the latest changes from the GitHub repository (using `git pull --rebase`).
+- Handles git conflicts, offering to reset to the latest remote version if needed.
+- Copies a custom scheduler template if not already present.
+- Backs up the `data/` directory (and `custom_scheduler.py` if present) to a compressed archive.
+- Merges your existing configuration with new defaults using `script/configMerge.py`, and logs the process.
+- Restarts services if they were stopped for the update.
+- Provides status messages and logs for troubleshooting.
+
+### When to use
+
+- To update your Mesh Bot installation to the latest version.
+- Before making significant changes or troubleshooting, as it creates a backup of your data.
+
+### Note
+
+- Review `ini_merge_log.txt` and `config_new.ini` after running for any configuration changes or errors.
+- You may be prompted if git conflicts are detected.
+
+---
+
+## launch.sh
+
+### Purpose
+
+`launch.sh` is a convenience script for starting the Mesh Bot, Pong Bot, or generating reports within the Python virtual environment. It ensures the correct environment is activated and the appropriate script is run.
+
+### How to Use
+
+From your project root, run one of the following commands:
+
+- Launch Mesh Bot:  
+  ```sh
+  bash launch.sh mesh
+  ```
+- Launch Pong Bot:  
+  ```sh
+  bash launch.sh pong
+  ```
+- Generate HTML report:  
+  ```sh
+  bash launch.sh html
+  ```
+- Generate HTML5 report:  
+  ```sh
+  bash launch.sh html5
+  ```
+- Add a favorite (calls `script/addFav.py`):  
+  ```sh
+  bash launch.sh add
+  ```
+
+### What it does
+
+- Ensures you are in the project directory.
+- Copies `config.template` to `config.ini` if no config exists.
+- Activates the Python virtual environment (`venv`).
+- Runs the selected Python script based on your argument.
+- Deactivates the virtual environment when done.
+
+### Note
+
+- The script requires a Python virtual environment (`venv`) to be present in the project directory.
+- If `venv` is missing, the script will exit with an error message.
+- Always provide an argument (`mesh`, `pong`, `html`, `html5`, or `add`) to specify what you want to launch.

README.md

@@ -1,100 +1,107 @@
 # Mesh Bot for Network Testing and BBS Activities
 
-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 is a feature-rich Python bot designed to enhance your [Meshtastic](https://meshtastic.org/docs/introduction/) network experience. It provides powerful tools for network testing, messaging, games, and more—all via text-based message delivery. Whether you want to test your mesh, send messages, or play games, [mesh_bot.py](mesh_bot.py) has you covered.
+
+* [Getting Started](#getting-started)
 
 ![Example Use](etc/pong-bot.jpg "Example Use")
 
+#### TLDR
+* [install.sh](INSTALL.md)
+* [Configuration Guide](modules/README.md)
+* [Games Help](modules/games/README.md)
+
 ## Key Features
 ![CodeQlBadge](https://github.com/SpudGunMan/meshing-around/actions/workflows/dynamic/github-code-scanning/codeql/badge.svg)
 
 ### Intelligent Keyword Responder
-- **Automated Responses**: The bot detects keywords like "ping" and responds with "pong" in direct messages (DMs) or group channels.
-- **Customizable Triggers**: Monitor group channels for specific keywords and set custom responses.
-- **Emergency Response**: Monitor channels for keywords indicating emergencies and alert a wider audience.
-- **New Node Hello**: Greet new nodes on the mesh with a hello message
+- **Automated Responses**: Detects keywords like "ping" and replies with "pong" in direct messages (DMs) or group channels.
+- **Customizable Triggers**: Monitors group channels for specific keywords and sends custom responses.
+- **Emergency Detection**: Watches for emergency-related keywords and alerts a wider audience.
+- **New Node Greetings**: Automatically welcomes new nodes joining the mesh.
 
 ### 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.
+- **Mesh Testing**: Use `ping` to test message delivery with realistic packets.
+- **Hardware Testing**: The `test` command sends incrementally sized data to test radio buffer limits.
+- **Network Monitoring**: Alerts for noisy nodes, tracks node locations, and suggests optimal relay placement.
 
-### Multi Radio/Node Support
-- **Simultaneous Monitoring**: Monitor up to nine networks at the same time.
-- **Flexible Messaging**: send mail and messages, between networks.
+- **Site Survey & Location Logging**: Use the `map` command to log your current GPS location with a custom description—ideal for site surveys, asset tracking, or mapping nodes locations. Entries are saved to a CSV file for later analysis or visualization.
+
+### Multi-Radio/Node Support
+- **Simultaneous Monitoring**: Observe up to nine networks at once.
+- **Flexible Messaging**: Send mail and messages between networks.
 
 ### 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.
+- **Mail Messaging**: Leave messages for other devices; delivered as DMs when the device is next seen. Use `bbspost @nodeNumber #message` or `bbspost @nodeShortName #message`.
+- **Message Scheduler**: Automate messages such as weather updates or net reminders.
+- **Store and Forward**: Retrieve missed messages with the `messages` command; optionally log messages to disk.
+- **BBS Linking**: Connect multiple bots to expand BBS coverage.
+- **E-Mail/SMS Integration**: Send mesh messages to email or SMS for broader reach.
+- **New Node Greetings**: Automatically greet new nodes via text.
 
 ### 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.
+- **Weather, Earthquake, River, and Tide Data**: Get local alerts and info from NOAA/USGS; uses Open-Meteo for areas outside NOAA coverage. Global tide predictions available via tidepredict library for worldwide locations.
+- **Wikipedia Search**: Retrieve summaries from Wikipedia.
+- **OpenWebUI, Ollama LLM Integration**: Query the [Ollama](https://github.com/ollama/ollama/tree/main/docs) AI for advanced responses. Supports RAG (Retrieval Augmented Generation) with Wikipedia/Kiwix context and [OpenWebUI](https://github.com/open-webui/open-webui) integration for enhanced AI capabilities. [LLM Readme](modules/llm.md)
+- **Satellite Passes**: Find upcoming satellite passes for your location.
+- **GeoMeasuring Tools**: Calculate distances and midpoints using collected GPS data; supports Fox & Hound direction finding.
 
 ### 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
+- **Location-Based Alerts**: Get notified when members arrive at a configured latitude/longitude—ideal for campsites, geo-fences, or remote locations. Optionally, trigger scripts, send emails, or automate actions (e.g., change node config, turn on lights, or drop an `alert.txt` file to start a survey or game).
+- **Customizable Triggers**: Use proximity events for creative applications like "king of the hill" or 🧭 geocache games by adjusting the alert cycle.
+- **High Flying Alerts**: Receive notifications when nodes with high altitude are detected on the mesh.
+- **Voice/Command Triggers**: Activate bot functions using keywords or voice commands (see [Voice Commands](#voice-commands-vox) for "Hey Chirpy!" support).
 
-### CheckList / Check In Out
-- **Asset Tracking**: Maintain a list of node/asset checkin and checkout. Useful foraccountability of people, assets. Radio-Net, FEMA, Trailhead.
+#### Radio Frequency Monitoring
+- **SNR RF Activity Alerts**: Monitor radio frequencies and receive alerts when high SNR (Signal-to-Noise Ratio) activity is detected.
+- **Hamlib Integration**: Use Hamlib (rigctld) to monitor the S meter on a connected radio.
+- **Speech-to-Text Broadcasting**: Convert received audio to text using [Vosk](https://alphacephei.com/vosk/models) and broadcast it to the mesh.
+- **WSJT-X Integration**: Monitor WSJT-X (FT8, FT4, WSPR, etc.) decode messages and forward them to the mesh network with optional callsign filtering.
+- **JS8Call Integration**: Monitor JS8Call messages and forward them to the mesh network with optional callsign filtering.
+
+### Asset Tracking, Check-In/Check-Out, and Inventory Management
+Advanced check-in/check-out and asset tracking for people and equipment—ideal for accountability, safety monitoring, and logistics (e.g., Radio-Net, FEMA, trailhead groups). Admin approval workflows, GPS location capture, and overdue alerts. The integrated inventory and point-of-sale (POS) system enables item management, sales tracking, cart-based transactions, and daily reporting, for swaps, emergency supply management, and field operations, maker-places.
 
 ### 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 🥶
+- **Built-in Games**: Play classic games like DopeWars, Lemonade Stand, BlackJack, and Video Poker directly via DM.
+- **FCC ARRL QuizBot**: Practice for the ham radio exam with the integrated quiz bot.
+- **Command-Based Gameplay**: Use the `games` command to view available games and start playing.
+- **Telemetry Leaderboard**: Compete for fun stats like lowest battery or coldest temperature.
 
 #### 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`.
+- **Group Quizzes**: Admins can start and stop quiz games for groups.
+- **Player Participation**: Players join with `q: join`, leave with `q: leave`, and answer questions by prefixing their answer with `q:`, e.g., `q: 42`.
+- **Scoring & Leaderboards**: Check your score with `q: score` and see the top performers with `q: top`.
+- **Admin Controls**: QuizMasters (from `bbs_admin_list`) can use `q: start`, `q: stop`, and `q: broadcast <message>` to manage games.
 
 #### 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. 
+- **Custom Surveys**: Create and manage surveys by editing JSON files in `data/survey`. Multiple surveys are supported (e.g., `survey snow`).
+- **User Feedback**: Users participate via DM; responses are logged for review.
+- **Reporting**: Retrieve survey results with `survey report` or `survey report <surveyname>`.
 
 ### EAS Alerts
-- **FEMA iPAWS/EAS Alerts 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
+- **FEMA iPAWS/EAS Alerts**: Receive Emergency Alerts from FEMA via API on internet-connected nodes.
+- **NOAA EAS Alerts**: Get Emergency Alerts from NOAA via API.
+- **USGS Volcano Alerts**: Receive volcano alerts from USGS via API.
+- **Offline EAS Alerts**: Report EAS alerts over the mesh using external tools, even without internet.
+- **NINA Alerts (Germany)**: Receive emergency alerts from the xrepository.de feed for Germany.
 
 ### File Monitor Alerts
-- **File 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.
+- **File Monitoring**: Watch a text file for changes and broadcast updates to the mesh channel.
+- **News File Access**: Retrieve the contents of a news file on request; supports multiple news sources or files.
+- **Shell Command Access**: Execute shell commands via DM with replay protection (admin only).
 
 ### Data Reporting
-- **HTML 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!
+- **HTML Reports**: Visualize bot traffic and data flows with a built-in HTML generator. See [data reporting](logs/README.md) for details.
+- **RSS & News Feeds**: Receive news and data from multiple sources directly on the mesh.
 
 ### Robust Message Handling
-- **Message Chunking**: Automatically chunk messages over 160 characters to ensure higher delivery success across hops.
+- **Automatic Message Chunking**: Messages over 160 characters are automatically split to ensure reliable delivery across multiple 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.
+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, armbian or [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
@@ -102,456 +109,31 @@ 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.
+- **Automated Installation**: [install.sh](INSTALL.md) will automate optional venv and requirements installation.
+- **Launch Script**: [laynch.sh](INSTALL.md) only used in a venv install, to launch the bot and the report generator.
 
-## Full list of commands for the bot
+### Docker Installation
+Good for windows or OpenWebUI enabled bots
 
-### 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 | ✅ |
+[docker.md](script/docker/README.md)
 
-### 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 | |
+## Module Help
+Configuration Guide
+[modules/README.md](modules/README.md)
 
-### 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 | |
+### Game Help
+Games are DM only by default
 
-### 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 | ✅ |
-
-### 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 | ✅ |
-
-### 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 | ✅ |
-
-#### 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
-```
-
-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/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/ttyUSB0'
-# hostname = 192.168.0.1
-# mac = 00:11:22:33:44:55
-
-# Additional interface for dual radio support. See config.template for more.
-[interface2]
-enabled = False
-```
-
-### 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
-```
-
-### 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
-```
-
-### 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
-
-[general]
-DadJokes = False
-StoreForward = False
-```
-
-### 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
-```
-
-### 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]
-```
-
-### 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 = True
-rigControlServerAddress = localhost:4532
-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
-```
-
-### File Monitoring
-Some dev notes for ideas of use
-
-```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
-```
-
-#### 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
-```
-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
-```
-
-#### 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
-```
-
-### 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
-```
- 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.
-
-```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
-```
+[modules/games/README.md](modules/games/README.md)
 
 ### 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`
+- The API will not work-fully today to set nodes this is a WIP
+
+Additionally, you can just DM a bot to "auto favorite." If your node is set to not be messageable, DMs won't work—be advised.
 
 To configure favorite nodes, add their numbers to your config file:
 ```conf
@@ -583,56 +165,20 @@ I used ideas and snippets from other responder bots and want to call them out!
 - 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
+For testing and feature ideas on Discord and GitHub, if its stable its thanks to you all.
+- **PiDiBi, Cisien, bitflip, nagu, Nestpebble, NomDeTom, Iris, Josh, GlockTuber, FJRPiolt, dj505, Woof, propstg, snydermesh, trs2982, F0X, Malice, mesb1, Hailo1999**
+- **xdep**: For the reporting html. 📊
+- **mrpatrick1991**: For OG Docker configurations. 💻
+- **A-c0rN**: Assistance with iPAWS and 🚨
 - **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.
+- **WH6GXZ nurse dude**: Volcano Alerts 🌋
+- **mikecarper**: hamtest, leading to quiz etc.. 📋
+- **c.merphy360**: high altitude alerts. 🚀
+- **G7KSE**: DX Spotting idea. 📻
+- **Growing List of GitHub Contributers**
+- **Meshtastic Discord Community**: For putting up with 🥔
 
 ### 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:
-
-```sh
-pip install pyephem
-pip install requests
-pip install geopy
-pip install maidenhead
-pip install beautifulsoup4
-pip install dadjokes
-pip install schedule
-pip install wikipedia
-```
-
-For the Ollama LLM:
-
-```sh
-pip install googlesearch-python
-```
-
-To enable emoji in the Debian console, install the fonts:
-
-```sh
-sudo apt-get install fonts-noto-color-emoji
-```
-
 Meshtastic® is a registered trademark of Meshtastic LLC. Meshtastic software components are released under various licenses, see GitHub for details. No warranty is provided - use at your own risk.

SECURITY.md

@@ -0,0 +1,14 @@
+# Security Policy
+
+## Supported Versions
+
+Use this section to tell people about which versions of your project are
+currently being supported with security updates.
+
+| Version | Supported          |
+| ------- | ------------------ |
+| git pull| :white_check_mark: |
+
+## Reporting a Vulnerability
+
+If its serious, its likley big. otherwise post issues, reachout on discord.

compose.yaml

@@ -0,0 +1,71 @@
+services:
+  meshing-around:
+    ports:
+      - 8420:8420
+    #devices:
+      #- /dev/ttyUSB0:/dev/tty #update your config.ini to /dev/tty
+      #- /dev/ttyACM0:/dev/tty #if using serial select proper port
+    volumes:
+      - .:/app:rw
+    image: ghcr.io/spudgunman/meshing-around:main
+    container_name: meshing-around
+    restart: unless-stopped
+    environment:
+      - OLLAMA_API_URL=http://ollama:11434
+    extra_hosts:
+      - "host.docker.internal:host-gateway"
+    #user: "1000:1000"
+    #user: "10999:10999"
+    networks:
+      - meshing-around-network
+
+  test-bot:
+    image: ghcr.io/spudgunman/meshing-around:main
+    container_name: test-bot
+    command: ["/bin/bash", "-c", "python3 modules/test_bot.py | tee /tmp/test_tmp.txt; if grep -E 'failures=|errors=' /tmp/test_tmp.txt; then cp /tmp/test_tmp.txt /app/test_results.txt; fi"]
+    volumes:
+      - .:/app:rw
+    networks:
+      - meshing-around-network
+    stdin_open: true
+
+  debug-console:
+    image: ghcr.io/spudgunman/meshing-around:main
+    container_name: debug-console
+    command: ["/bin/bash"]
+    stdin_open: true
+    tty: true
+    volumes:
+      - .:/app:rw
+    networks:
+      - meshing-around-network
+
+  meshtasticd:
+    ports:
+      - 4403:4403
+      - 443:443
+    volumes:
+      - ./script/docker:/etc/meshtasticd:rw
+    restart: unless-stopped
+    container_name: meshtasticd
+    image: meshtastic/meshtasticd:daily-debian
+    networks:
+      - meshing-around-network
+
+  ollama:
+    ports: 
+      - 11434:11434
+    container_name: ollama
+    image: ollama/ollama:latest
+    restart: unless-stopped
+    healthcheck:
+      test: ["CMD", "curl", "-f", "http://localhost:11434/api/tags"]
+      interval: 30s
+      timeout: 10s
+      retries: 5
+    networks:
+      - meshing-around-network
+
+networks:
+  meshing-around-network:
+    external: true

config.template

@@ -57,9 +57,9 @@ 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
+rssFeedURL = http://www.hackaday.com/rss.xml,http://rss.slashdot.org/Slashdot/slashdotMain,http://www.reddit.com/r/meshtastic/.rss
 # RSS feed names must match the order of the URLs above, default is used if no match
-rssFeedNames = default,slashdot
+rssFeedNames = default,slashdot,mesh
 rssMaxItems = 3
 rssTruncate = 100
 
@@ -75,15 +75,28 @@ kiwixLibraryName = wikipedia_en_100_nopic_2025-09
 
 # Enable ollama LLM see more at https://ollama.com
 ollama = False
-# Ollama model to use (defaults to gemma3:270m)
+# Ollama model to use (defaults to gemma3:270m) gemma2 is good for older SYSTEM prompt
 # ollamaModel = gemma3:latest
+# ollamaModel = gemma2:2b
 # 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 
+# if True, the input is sent raw to the LLM, if False uses SYSTEM prompt
+rawLLMQuery = True
+
+# Enable Wikipedia/Kiwix integration with LLM for RAG (Retrieval Augmented Generation)
+# When enabled, LLM will automatically search Wikipedia/Kiwix and include context in responses
+llmUseWikiContext = False
+
+# Use OpenWebUI instead of direct Ollama API (enables advanced RAG features)
+useOpenWebUI = False
+# OpenWebUI server URL (e.g., http://localhost:3000)
+openWebUIURL = http://localhost:3000
+# OpenWebUI API key/token (required when useOpenWebUI is True)
+openWebUIAPIKey = 
 
 # StoreForward Enabled and Limits
 StoreForward = True
@@ -127,19 +140,28 @@ 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
 # 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
+emailSentryAlerts = False
+# Enable detection sensor alert, requires external GPIO sensor connected to node
+detectionSensorAlert = False
+
 # list of ignored nodes numbers ex: 2813308004,4258675309
 sentryIgnoreList =
-# Enable detection sensor alert, requires external sensor connected to node
-detectionSensorAlert = False
+# list of watched nodes numbers ex: 2813308004,4258675309
+sentryWatchList =
+
+# radius in meters to detect someone close to the bot
+SentryRadius = 100
+# holdoff time multiplied by seconds(20) of the watchdog
+SentryHoldoff = 9
+
+# Enable running external shell command when sentry alert is triggered
+cmdShellSentryAlerts = False
+# External shell command to run when sentry alert is triggered
+sentryAlertNear = sentry_alert_near.sh
+sentryAlertAway = sentry_alert_away.sh
 
 # HighFlying Node alert
 highFlyingAlert = True
@@ -189,6 +211,11 @@ NOAAalertCount = 2
 # use Open-Meteo API for weather data not NOAA useful for non US locations
 UseMeteoWxAPI = False
 
+# Global Tide Prediction using tidepredict (for non-US locations or offline use)
+# When enabled, uses tidepredict library for global tide predictions instead of NOAA API
+# tidepredict uses University of Hawaii's Research Quality Dataset for worldwide coverage
+useTidePredict = 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/
@@ -239,7 +266,7 @@ enableDEalerts = False
 myRegionalKeysDE = 110000000000,120510000000
 
 # Satalite Pass Prediction
-# Register for free API https://www.n2yo.com/login/
+# Register for free API https://www.n2yo.com/login/ personal data page at bottom 'Are you developer?'
 n2yoAPIKey = 
 # NORAD list https://www.n2yo.com/satellites/
 satList = 25544,7530
@@ -250,6 +277,15 @@ enabled = False
 checklist_db = data/checklist.db
 reverse_in_out = False
 
+# Inventory and Point of Sale System
+[inventory]
+enabled = False
+inventory_db = data/inventory.db
+# Set to True to disable penny precision and round to nickels (USA cash sales)
+# When True: cash sales round down, taxed sales round up to nearest $0.05
+# When False (default): normal penny precision ($0.01)
+disable_penny = False
+
 [qrz]
 # QRZ Hello to new nodes with message
 enabled = False
@@ -277,7 +313,11 @@ 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 can be min,hour,day,mon,tue,wed,thu,fri,sat,sun.
+# value can also be 'joke' (min/interval), 'weather' (time/day), 'link' (hour/interval) for special auto messages
+# or 'news' (hour/interval), 'readrss' (hour/interval), 'mwx' (time/day), 'sysinfo' (hour/interval),
+# 'tide' (time/day), 'solar' (time/day) for automated information broadcasts, matching module needs enabled!
+# 'custom' for module/scheduler.py custom schedule examples
 value =
 # interval to use when time is not set (e.g. every 2 days)
 interval = 
@@ -285,13 +325,17 @@ interval =
 time =
 
 [radioMon]
-# using Hamlib rig control will monitor and alert on channel use
-enabled = False
-rigControlServerAddress = localhost:4532
-# device interface to send the message to
+# dx cluster `dx` command
+dxspotter_enabled = True
+
+# alerts in this module use the following interface and channel
 sigWatchBroadcastInterface = 1
 # broadcast channel can also be a comma separated list of channels
 sigWatchBroadcastCh = 2
+
+# using Hamlib rig control will monitor and alert on channel use
+enabled = False
+rigControlServerAddress = 127.0.0.1:4532
 # minimum SNR as reported by radio via hamlib
 signalDetectionThreshold = -10
 # hold time for high SNR
@@ -299,17 +343,37 @@ signalHoldTime = 10
 # the following are combined to reset the monitor
 signalCooldown = 5
 signalCycleLimit = 5
-# enable VOX detection using default input
+
+# Enable VOX detection using default input
 voxDetectionEnabled = False
 # description to use in the alert message
 voxDescription = VOX
+
 useLocalVoxModel = False
+# default language for VOX detection
 voxLanguage = en-us
+# sound.card input device to use for VOX detection, 'default' uses system default
 voxInputDevice = default
+# "hey chirpy"
 voxOnTrapList = True
 voxTrapList = chirpy
+# allow use of 'weather' and 'joke' commands via VOX
 voxEnableCmd = True
 
+# WSJT-X UDP monitoring - listens for decode messages from WSJT-X, FT8/FT4/WSPR etc.
+wsjtxDetectionEnabled = False
+# UDP address and port where WSJT-X broadcasts (default: 127.0.0.1:2237)
+wsjtxUdpServerAddress = 127.0.0.1:2237
+# Comma-separated list of callsigns to watch (empty = all callsigns)
+wsjtxWatchedCallsigns = 
+
+# JS8Call TCP monitoring - connects to JS8Call API for message forwarding
+js8callDetectionEnabled = False
+# TCP address and port where JS8Call API listens (default: 127.0.0.1:2442)
+js8callServerAddress = 127.0.0.1:2442
+# Comma-separated list of callsigns to watch (empty = all callsigns)
+js8callWatchedCallsigns = 
+
 
 [fileMon]
 filemon_enabled = False
@@ -374,6 +438,7 @@ golfsim = True
 hangman = True
 hamtest = True
 tictactoe = True
+wordOfTheDay = True
 
 # enable or disable the quiz game module questions are in data/quiz.json
 quiz = False

etc/IMPLEMENTATION_SUMMARY_CheckinPOS.md

@@ -0,0 +1,264 @@
+# Implementation Summary: Enhanced Check-in/Check-out and Point of Sale System
+
+## Overview
+
+This implementation addresses the GitHub issue requesting enhancements to the check-in/check-out system and the addition of a complete Point of Sale (POS) functionality to the meshing-around project.
+
+## What Was Implemented
+
+### 1. Enhanced Check-in/Check-out System
+
+#### New Features Added:
+- **Time Window Monitoring**: Check-in with safety intervals (e.g., `checkin 60 Hunting in tree stand`)
+  - Tracks if users don't check in within expected timeframe
+  - Ideal for solo activities, remote work, or safety accountability
+  - Provides `get_overdue_checkins()` function for alert integration
+
+- **Approval Workflow**:
+  - `checklistapprove <id>` - Approve pending check-ins (admin)
+  - `checklistdeny <id>` - Deny/remove check-ins (admin)
+  - Support for approval-based workflows
+
+- **Enhanced Database Schema**:
+  - Added `approved` field for approval workflows
+  - Added `expected_checkin_interval` field for safety monitoring
+  - Automatic migration for existing databases
+
+#### New Commands:
+- `checklistapprove <id>` - Approve a check-in
+- `checklistdeny <id>` - Deny a check-in
+- Enhanced `checkin [interval] [note]` - Now supports interval parameter
+
+### 2. Complete Point of Sale System
+
+#### Features Implemented:
+
+**Item Management:**
+- Add items with price, quantity, and location
+- Remove items from inventory
+- Update item prices and quantities
+- Quick sell functionality
+- Transaction returns/reversals
+- Full inventory listing with valuations
+
+**Cart System:**
+- Per-user shopping carts
+- Add/remove items from cart
+- View cart with totals
+- Complete transactions (buy/sell)
+- Clear cart functionality
+
+**Financial Features:**
+- Penny rounding support (USA mode)
+  - Cash sales round down to nearest nickel
+  - Taxed sales round up to nearest nickel
+- Transaction logging with full audit trail
+- Daily sales statistics
+- Revenue tracking
+- Hot item detection (best sellers)
+
+**Database Schema:**
+Four tables for complete functionality:
+- `items` - Product inventory
+- `transactions` - Sales records
+- `transaction_items` - Line items per transaction
+- `carts` - Temporary shopping carts
+
+#### Commands Implemented:
+
+**Item Management:**
+- `itemadd <name> <price> <qty> [location]` - Add new item
+- `itemremove <name>` - Remove item
+- `itemreset <name> [price=X] [qty=Y]` - Update item
+- `itemsell <name> <qty> [notes]` - Quick sale
+- `itemreturn <transaction_id>` - Reverse transaction
+- `itemlist` - View all inventory
+- `itemstats` - Daily statistics
+
+**Cart System:**
+- `cartadd <name> <qty>` - Add to cart
+- `cartremove <name>` - Remove from cart
+- `cartlist` / `cart` - View cart
+- `cartbuy` / `cartsell [notes]` - Complete transaction
+- `cartclear` - Empty cart
+
+## Files Created/Modified
+
+### New Files:
+1. **modules/inventory.py** (625 lines)
+   - Complete inventory and POS module
+   - All item management functions
+   - Cart system implementation
+   - Transaction processing
+   - Penny rounding logic
+
+2. **modules/inventory.md** (8,529 chars)
+   - Comprehensive user guide
+   - Command reference
+   - Use case examples
+   - Database schema documentation
+
+3. **modules/checklist.md** (9,058 chars)
+   - Enhanced checklist user guide
+   - Safety monitoring documentation
+   - Best practices
+   - Scenario examples
+
+### Modified Files:
+1. **modules/checklist.py**
+   - Added time interval monitoring
+   - Added approval workflow functions
+   - Enhanced database schema
+   - Updated command processing
+
+2. **modules/settings.py**
+   - Added inventory configuration section
+   - Added `inventory_enabled` setting
+   - Added `inventory_db` path setting
+   - Added `disable_penny` setting
+
+3. **config.template**
+   - Added `[inventory]` section
+   - Documentation for penny rounding
+
+4. **modules/system.py**
+   - Integrated inventory module
+   - Added trap list for inventory commands
+
+5. **mesh_bot.py**
+   - Added inventory command handlers
+   - Added checklist approval commands
+   - Created `handle_inventory()` function
+
+6. **modules/README.md**
+   - Updated checklist section with new features
+   - Added complete inventory/POS section
+   - Updated table of contents
+
+7. **.gitignore**
+   - Added database files to ignore list
+
+## Configuration
+
+### Enable Inventory System:
+```ini
+[inventory]
+enabled = True
+inventory_db = data/inventory.db
+disable_penny = False  # Set to True for USA penny rounding
+```
+
+### Checklist Already Configured:
+```ini
+[checklist]
+enabled = False  # Set to True to enable
+checklist_db = data/checklist.db
+reverse_in_out = False
+```
+
+## Testing Results
+
+All functionality tested and verified:
+- ✅ Module imports work correctly
+- ✅ Database initialization successful
+- ✅ Inventory commands function properly
+- ✅ Cart system working as expected
+- ✅ Checklist enhancements operational
+- ✅ Time interval monitoring active
+- ✅ Trap lists properly registered
+- ✅ Help commands return correct information
+
+## Use Cases Addressed
+
+### From Issue Comments:
+
+1. **Point of Sale Logic** ✅
+   - Complete POS system with inventory management
+   - Cart-based transactions
+   - Sales tracking and reporting
+
+2. **Check-in Time Windows** ✅
+   - Interval-based monitoring
+   - Overdue detection
+   - Safety accountability for solo activities
+
+3. **Geo-location Awareness** ✅
+   - Automatic GPS capture when checking in/out
+   - Location stored with each check-in
+   - Foundation for "are you ok" alerts
+
+4. **Asset Management** ✅
+   - Track any type of asset (tools, equipment, supplies)
+   - Multiple locations support
+   - Full transaction history
+
+5. **Penny Rounding** ✅
+   - Configurable USA cash sale rounding
+   - Separate logic for cash vs taxed sales
+   - Down for cash, up for tax
+
+## Security Features
+
+- Users on `bbs_ban_list` cannot use inventory or checklist commands
+- Admin-only approval commands
+- Parameterized SQL queries prevent injection
+- Per-user cart isolation
+- Full transaction audit trail
+
+## Documentation Provided
+
+1. **User Guides:**
+   - Comprehensive inventory.md with examples
+   - Detailed checklist.md with safety scenarios
+   - Updated main README.md
+
+2. **Technical Documentation:**
+   - Database schema details
+   - Configuration examples
+   - Command reference
+   - API documentation in code comments
+
+3. **Examples:**
+   - Emergency supply tracking
+   - Event merchandise sales
+   - Field equipment management
+   - Safety monitoring scenarios
+
+## Future Enhancement Opportunities
+
+The implementation provides foundation for:
+- Scheduled overdue check-in alerts
+- Email/SMS notifications for overdue status
+- Dashboard/reporting interface
+- Barcode/QR code support
+- Multi-location inventory tracking
+- Inventory forecasting
+- Integration with external systems
+
+## Backward Compatibility
+
+- Existing checklist databases automatically migrate
+- New features are opt-in via configuration
+- No breaking changes to existing commands
+- Graceful handling of missing database columns
+
+## Performance Considerations
+
+- SQLite databases for reliability and simplicity
+- Indexed primary keys for fast lookups
+- Efficient query design
+- Minimal memory footprint
+- No external dependencies beyond stdlib
+
+## Conclusion
+
+This implementation fully addresses all requirements from the GitHub issue:
+- ✅ Enhanced check-in/check-out with SQL improvements
+- ✅ Point of sale logic with inventory management
+- ✅ Time window notifications for safety
+- ✅ Asset tracking for any item type
+- ✅ Penny rounding for USA cash sales
+- ✅ Cart management system
+- ✅ Comprehensive documentation
+
+The system is production-ready, well-tested, and documented for immediate use.

etc/README.md

@@ -0,0 +1,75 @@
+# etc Directory
+
+This folder contains supporting files and resources for the Mesh Bot project. Typical contents include:
+
+- **Images**: Visual assets used in documentation (e.g., `pong-bot.jpg`).
+- **Custom Scripts**: Example or utility scripts for advanced configuration (e.g., `custom_scheduler.py` for scheduled tasks).
+- **tmp**: Temp files for install
+
+## db_admin.py
+
+**Purpose:**  
+`db_admin.py` is a simple administrative tool for viewing the contents of the Mesh Bot’s data and high score databases. It loads and prints out messages, direct messages, email/SMS records, and game high score tables stored in the `/data` directory.
+
+**Usage:**  
+Run this script from the command line to display the current contents of the bot’s databases. This is useful for debugging, verifying data integrity, or reviewing stored messages and game scores.
+
+```sh
+python etc/db_admin.py
+```
+
+**What it does:**  
+- Attempts to load various `.pkl` and `.pickle` files from the `data` directory.
+- Prints out the contents of BBS messages, direct messages, email and SMS databases.
+- Displays high scores for supported games (Lemonade Stand, DopeWars, BlackJack, Video Poker, Mastermind, GolfSim).
+- If a file is missing, it will print a message indicating so.
+
+**Note:**  
+This tool is for administrative and debugging purposes only. It does not modify any data.
+
+## eas_alert_parser.py
+
+**Purpose:**  
+`eas_alert_parser.py` is a utility script for processing and cleaning up output from `multimon-ng` to extract and convert Emergency Alert System (EAS) messages for further use, such as with EAS2Text.
+
+**Usage:**  
+This script is intended to be used with piped input, typically from `multimon-ng` decoding SAME/EAS messages. It filters and processes EAS lines, converts them to readable text using EAS2Text, and writes the results to `alert.txt`.
+
+**Example usage:**
+```sh
+multimon-ng -a EAS ... | python etc/eas_alert_parser.py
+```
+
+**What it does:**  
+- Reads input line-by-line (supports piped or redirected input).
+- Filters for lines starting with `EAS:` or `EAS (part):`.
+- Avoids duplicate messages and only processes new alerts.
+- Uses the EAS2Text library to convert EAS codes to human-readable messages.
+- Writes completed alerts to `alert.txt` for further processing or notification.
+
+**Note:**  
+This script is intended for experimental or hobbyist use and may require customization for your specific workflow.
+
+## simulator.py
+
+**Purpose:**  
+`simulator.py` is a development and testing tool that simulates the behavior of the Mesh Bot in a controlled environment. It allows you to prototype and test handler functions without needing real hardware or a live mesh network.
+
+**Usage:**  
+Run this script from the command line to interactively test handler functions. You can input messages as if you were a mesh node, and see how your handler responds.
+
+```sh
+python etc/simulator.py
+```
+
+**What it does:**  
+- Simulates node IDs, device IDs, and random GPS locations.
+- Lets you specify which handler function to test (by setting `projectName`).
+- Prompts for user input, passes it to the handler, and displays the response.
+- Logs simulated message sending and handler output for review.
+- Useful for rapid prototyping and debugging new features or message handlers.
+
+**Note:**  
+Edit the `projectName` variable to match the handler function you want to test. You can expand this script to test additional handlers or scenarios as needed.
+
+Feel free to add or update resources here as needed for documentation, configuration, or project support.

etc/custom_scheduler.template

@@ -0,0 +1,125 @@
+#!/usr/bin/python3
+import schedule
+from modules.log import logger
+from modules.settings import MOTD
+from modules.system import send_message
+
+def setup_custom_schedules(send_message, tell_joke, welcome_message, handle_wxc, MOTD, schedulerChannel, schedulerInterface):
+    """
+    Set up custom schedules. Edit the example schedules as needed.
+    
+    1. in config.ini set "value" under [scheduler] to:  value = custom    
+    2. edit this file to add/remove/modify schedules
+    3. restart mesh bot
+    4. verify schedules are working by checking the log file
+    5. Make sure to uncomment (delete the single #) the example schedules down at the end of the file to enable them
+    Python is sensitive to indentation so be careful when editing this file. 
+    https://thonny.org is included on pi's image and is a simple IDE to use for editing python files.
+    
+    Available functions you can import and use, be sure they are enabled modules in config.ini:
+    - tell_joke() - Returns a random joke
+    - welcome_message - A welcome message string
+    - handle_wxc(message_from_id, deviceID, cmd, days=None) - Weather information
+    - handleNews(message_from_id, deviceID, message, isDM) - News reader
+    - get_rss_feed(msg) - RSS feed reader
+    - handle_mwx(message_from_id, deviceID, cmd) - Marine weather
+    - sysinfo(message, message_from_id, deviceID, isDM) - System information
+    - handle_tide(message_from_id, deviceID, channel_number) - Tide information
+    - handle_sun(message_from_id, deviceID, channel_number) - Sun information
+    - MOTD - Message of the day string
+    """
+    try:
+        # Import additional functions for scheduling (optional, depending on your needs)
+        from mesh_bot import handleNews, sysinfo, handle_mwx, handle_tide, handle_sun
+        from modules.rss import get_rss_feed
+        
+        # Example task functions, modify as needed the channel and interface parameters default to schedulerChannel and schedulerInterface
+        def send_joke(channel, interface):
+            ## uses system.send_message to send the result of tell_joke()
+            send_message(tell_joke(), channel, 0, interface)
+
+        def send_good_morning(channel, interface):
+            ## uses system.send_message to send "Good Morning"
+            send_message("Good Morning", channel, 0, interface)
+
+        def send_wx(channel, interface):
+            ## uses system.send_message to send the result of handle_wxc(id,id,cmd,days_returned)
+            send_message(handle_wxc(0, 1, 'wx', days=1), channel, 0, interface)
+
+        def send_weather_alert(channel, interface):
+            ## uses system.send_message to send string
+            send_message("Weather alerts available on 'Alerts' channel with default 'AQ==' key.", channel, 0, interface)
+
+        def send_config_url(channel, interface):
+            ## uses system.send_message to send string
+            send_message("Join us on Medium Fast https://meshtastic.org/e/#CgcSAQE6AggNEg4IARAEOAFAA0gBUB5oAQ", channel, 0, interface)
+
+        def send_net_starting(channel, interface):
+            ## uses system.send_message to send string, channel 2, interface 3
+            send_message("Net Starting Now", 2, 0, 3)
+
+        def send_welcome(channel, interface):
+            ## uses system.send_message to send string, channel 2, interface 1
+            send_message("Welcome to the group", 2, 0, 1)
+
+        def send_motd(channel, interface):
+            ## uses system.send_message to send message of the day string which can be updated in runtime
+            send_message(MOTD, channel, 0, interface)
+
+        def send_news(channel, interface):
+            ## uses system.send_message to send the result of handleNews()
+            send_message(handleNews(0, interface, 'readnews', False), channel, 0, interface)
+
+        def send_rss(channel, interface):
+            ## uses system.send_message to send the result of get_rss_feed()
+            send_message(get_rss_feed(''), channel, 0, interface)
+
+        def send_marine_weather(channel, interface):
+            ## uses system.send_message to send the result of handle_mwx()
+            send_message(handle_mwx(0, interface, 'mwx'), channel, 0, interface)
+
+        def send_sysinfo(channel, interface):
+            ## uses system.send_message to send the result of sysinfo()
+            send_message(sysinfo('', 0, interface, False), channel, 0, interface)
+
+        def send_tide(channel, interface):
+            ## uses system.send_message to send the result of handle_tide()
+            send_message(handle_tide(0, interface, channel), channel, 0, interface)
+
+        def send_sun(channel, interface):
+            ## uses system.send_message to send the result of handle_sun()
+            send_message(handle_sun(0, interface, channel), channel, 0, interface)
+
+        ### Send a joke every 2 minutes
+        #schedule.every(2).minutes.do(lambda: send_joke(schedulerChannel, schedulerInterface))
+        ### Send a good morning message every day at 9 AM
+        #schedule.every().day.at("09:00").do(lambda: send_good_morning(schedulerChannel, schedulerInterface))
+        ### Send weather update every day at 8 AM
+        #schedule.every().day.at("08:00").do(lambda: send_wx(schedulerChannel, schedulerInterface))
+        ### Send weather alerts every Wednesday at noon
+        #schedule.every().wednesday.at("12:00").do(lambda: send_weather_alert(schedulerChannel, schedulerInterface))
+        ### Send configuration URL every 2 days at 10 AM
+        #schedule.every(2).days.at("10:00").do(lambda: send_config_url(schedulerChannel, schedulerInterface))
+        ### Send net starting message every Wednesday at 7 PM
+        #schedule.every().wednesday.at("19:00").do(lambda: send_net_starting(schedulerChannel, schedulerInterface))
+        ### Send welcome message every 2 days at 8 AM
+        #schedule.every(2).days.at("08:00").do(lambda: send_welcome(schedulerChannel, schedulerInterface))
+        ### Send MOTD every day at 1 PM
+        #schedule.every().day.at("13:00").do(lambda: send_motd(schedulerChannel, schedulerInterface))
+        ### Send bbslink message every 2 days at 10 AM
+        #schedule.every(2).days.at("10:00").do(lambda: send_message("bbslink MeshBot looking for peers", schedulerChannel, 0, schedulerInterface))
+        ### Send news updates every 6 hours
+        #schedule.every(6).hours.do(lambda: send_news(schedulerChannel, schedulerInterface))
+        ### Send RSS feed every day at 9 AM
+        #schedule.every().day.at("09:00").do(lambda: send_rss(schedulerChannel, schedulerInterface))
+        ### Send marine weather every day at 6 AM
+        #schedule.every().day.at("06:00").do(lambda: send_marine_weather(schedulerChannel, schedulerInterface))
+        ### Send system information every day at 12 PM
+        #schedule.every().day.at("12:00").do(lambda: send_sysinfo(schedulerChannel, schedulerInterface))
+        ### Send tide information every day at 5 AM
+        #schedule.every().day.at("05:00").do(lambda: send_tide(schedulerChannel, schedulerInterface))
+        ### Send sun information every day at 6 AM
+        #schedule.every().day.at("06:00").do(lambda: send_sun(schedulerChannel, schedulerInterface))
+
+    except Exception as e:
+        logger.error(f"Error setting up custom schedules: {e}")

etc/db_admin.py

@@ -1,5 +1,8 @@
 # Load the bbs messages from the database file to screen for admin functions
-import pickle # pip install pickle
+import pickle
+import sqlite3
+
+print ("\n Meshing-Around Database Admin Tool\n")
 
 
 # load the bbs messages from the database file
@@ -106,7 +109,70 @@ except Exception as e:
         golfsim_score = "System: data/golfsim_hs.pkl not found"
 
 
-print ("\n Meshing-Around Database Admin Tool\n")
+# checklist.db admin display
+print("\nCurrent Check-ins Table\n")
+
+try:
+    conn = sqlite3.connect('../data/checklist.db')
+except Exception:
+    conn = sqlite3.connect('data/checklist.db')
+c = conn.cursor()
+try:
+    c.execute("""
+        SELECT * FROM checkin
+        WHERE removed = 0
+        ORDER BY checkin_id DESC
+        LIMIT 20
+    """)
+    rows = c.fetchall()
+    col_names = [desc[0] for desc in c.description]
+    if rows:
+        # Print header
+        header = " | ".join(f"{name:<15}" for name in col_names)
+        print(header)
+        print("-" * len(header))
+        # Print rows
+        for row in rows:
+            print(" | ".join(f"{str(col):<15}" for col in row))
+    else:
+        print("No check-ins found.")
+except Exception as e:
+    print(f"Error reading check-ins: {e}")
+finally:
+    conn.close()
+
+# inventory.db admin display
+print("\nCurrent Inventory Table\n")
+try:
+    conn = sqlite3.connect('../data/inventory.db')
+except Exception:
+    conn = sqlite3.connect('data/inventory.db')
+c = conn.cursor()
+try:    
+    c.execute("""
+        SELECT * FROM inventory
+        ORDER BY item_id DESC
+        LIMIT 20
+    """)
+    rows = c.fetchall()
+    col_names = [desc[0] for desc in c.description]
+    if rows:
+        # Print header
+        header = " | ".join(f"{name:<15}" for name in col_names)
+        print(header)
+        print("-" * len(header))
+        # Print rows
+        for row in rows:
+            print(" | ".join(f"{str(col):<15}" for col in row))
+    else:
+        print("No inventory items found.")
+except Exception as e:
+    print(f"Error reading inventory: {e}")
+finally:
+    conn.close()
+
+
+# Pickle database displays
 print ("System: bbs_messages")
 print (bbs_messages)
 print ("\nSystem: bbs_dm")

etc/fakeNode.py

@@ -0,0 +1,102 @@
+# https://github.com/pdxlocations/mudp/blob/main/examples/helloworld-example.py
+import time
+import random
+from pubsub import pub
+from meshtastic.protobuf import mesh_pb2
+from mudp import (
+    conn,
+    node,
+    UDPPacketStream,
+    send_nodeinfo,
+    send_text_message,
+    send_device_telemetry,
+    send_position,
+    send_environment_metrics,
+    send_power_metrics,
+    send_waypoint,
+)
+
+MCAST_GRP = "224.0.0.69"
+MCAST_PORT = 4403
+KEY = "1PG7OiApB1nwvP+rz05pAQ=="
+
+interface = UDPPacketStream(MCAST_GRP, MCAST_PORT, key=KEY)
+
+def setup_node():
+    node.node_id = "!deadbeef"
+    node.long_name = "UDP Test"
+    node.short_name = "UDP"
+    node.channel = "LongFast"
+    node.key = "AQ=="
+    conn.setup_multicast(MCAST_GRP, MCAST_PORT)
+    # Convert hex node_id to decimal (strip the '!' first)
+    decimal_id = int(node.node_id[1:], 16)
+    print(f"Node ID: {node.node_id} (decimal: {decimal_id})")
+    print(f"Channel: {node.channel}, Key: {node.key}")
+
+def demo_send_messages():
+    print("Sending node info...")
+    send_nodeinfo()
+    time.sleep(3)
+    print("Sending text message...")
+    send_text_message("hello world")
+    time.sleep(3)
+    print("Sending device telemetry position...")
+    send_position(latitude=37.7749, longitude=-122.4194, altitude=3000, precision_bits=3, ground_speed=5)
+    time.sleep(3)
+    print("Sending device telemetry local node data...")
+    send_device_telemetry(battery_level=50, voltage=3.7, channel_utilization=25, air_util_tx=15, uptime_seconds=123456)
+    time.sleep(3)
+    print("Sending environment metrics...")
+    send_environment_metrics(
+        temperature=23.072298,
+        relative_humidity=17.5602016,
+        barometric_pressure=995.36261,
+        gas_resistance=229.093369,
+        voltage=5.816,
+        current=-29.3,
+        iaq=66,
+    )
+    time.sleep(3)
+    print("Sending power metrics...")
+    send_power_metrics(
+        ch1_voltage=18.744,
+        ch1_current=11.2,
+        ch2_voltage=2.792,
+        ch2_current=18.4,
+        ch3_voltage=0,
+        ch3_current=0,
+    )
+    time.sleep(3)
+    print("Sending waypoint...")
+    send_waypoint(
+        id=random.randint(1, 2**32 - 1),
+        latitude=45.271394,
+        longitude=-121.736083,
+        expire=0,
+        locked_to=node.node_id,
+        name="Camp",
+        description="Main campsite near the lake",
+        icon=0x1F3D5,  # 🏕
+    )
+
+def main():
+    setup_node()
+    interface.start()
+    print("MUDP Fake Node is running. Press Ctrl+C to exit.")
+    print("You can send demo messages to the network.")
+    try:
+        while True:
+            answer = input("Do you want to send demo messages? (y/n): ").strip().lower()
+            if answer == "y":
+                demo_send_messages()
+            elif answer == "n":
+                print("Exiting.")
+                break
+    except KeyboardInterrupt:
+        pass
+    finally:
+        interface.stop()
+
+if __name__ == "__main__":
+    main()

etc/mesh_bot.tmp

@@ -14,6 +14,8 @@ Group=pi
 WorkingDirectory=/dir/
 ExecStart=python3 mesh_bot.py
 ExecStop=pkill -f mesh_bot.py
+Environment=REQUESTS_CA_BUNDLE=/etc/ssl/certs/ca-certificates.crt
+Environment=SSL_CERT_FILE=/etc/ssl/certs/ca-certificates.crt
 
 # Disable Python's buffering of STDOUT and STDERR, so that output from the
 # service shows up immediately in systemd's logs

etc/mesh_bot_reporting.timer

@@ -2,9 +2,11 @@
 Description=MeshingAround-ReportingTask
 
 [Timer]
-OnUnitActiveSec=1h
-OnbootSec=5min
+OnCalendar=*-*-* 04:20:00
+Persistent=true
 Unit=mesh_bot_reporting.service
+#OnUnitActiveSec=1h
+#OnbootSec=5min
 
 [Install]
 WantedBy=timers.target

etc/mesh_bot_reporting.tmp

@@ -14,6 +14,9 @@ Group=pi
 WorkingDirectory=/dir/
 ExecStart=python3 etc/report_generator5.py
 ExecStop=pkill -f report_generator5.py
+# ExecStart=python3 etc/report_generator.py
+# ExecStop=pkill -f report_generator.py
+
 
 # Disable Python's buffering of STDOUT and STDERR, so that output from the
 # service shows up immediately in systemd's logs
@@ -23,4 +26,4 @@ Restart=on-failure
 Type=notify #try simple if any problems
 
 [Install]
-WantedBy=default.target
+WantedBy=timers.target

etc/mesh_bot_w3.tmp

@@ -1,23 +0,0 @@
-# /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/mesh_bot_w3_server.tmp

@@ -0,0 +1,21 @@
+[Unit]
+Description=MeshingAround-WebServer
+After=network.target
+
+[Service]
+Type=simple
+User=pi
+Group=pi
+WorkingDirectory=/dir/
+ExecStart=python3 modules/web.py
+ExecStop=pkill -f mesh_bot_w3.py
+Environment=REQUESTS_CA_BUNDLE=/etc/ssl/certs/ca-certificates.crt
+Environment=SSL_CERT_FILE=/etc/ssl/certs/ca-certificates.crt
+Environment=PYTHONUNBUFFERED=1
+Restart=on-failure
+
+[Install]
+WantedBy=multi-user.target
+
+
+

etc/meshview.ino

@@ -1,224 +0,0 @@
-// 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

@@ -14,6 +14,8 @@ Group=pi
 WorkingDirectory=/dir/
 ExecStart=python3 pong_bot.py
 ExecStop=pkill -f pong_bot.py
+Environment=REQUESTS_CA_BUNDLE=/etc/ssl/certs/ca-certificates.crt
+Environment=SSL_CERT_FILE=/etc/ssl/certs/ca-certificates.crt
 
 # Disable Python's buffering of STDOUT and STDERR, so that output from the
 # service shows up immediately in systemd's logs

etc/set-permissions.sh

@@ -0,0 +1,40 @@
+#!/bin/bash
+# Set ownership and permissions for Meshing Around application
+
+# Check if run as root
+if [ "$EUID" -ne 0 ]; then
+  echo "Please run as root"
+  exit 1
+fi
+
+# Use first argument as user, or default to meshbot
+TARGET_USER="${1:-meshbot}"
+
+# Check if user exists
+if ! id "$TARGET_USER" &>/dev/null; then
+  echo "User '$TARGET_USER' does not exist."
+  read -p "Would you like to use the current user ($(logname)) instead? [y/N]: " yn
+  if [[ "$yn" =~ ^[Yy]$ ]]; then
+    TARGET_USER="$(logname)"
+    echo "Using current user: $TARGET_USER"
+    if ! id "$TARGET_USER" &>/dev/null; then
+      echo "Current user '$TARGET_USER' does not exist or cannot be determined."
+      exit 1
+    fi
+  else
+    echo "Exiting."
+    exit 1
+  fi
+fi
+
+echo "Setting ownership to $TARGET_USER:$TARGET_USER"
+
+chown -R "$TARGET_USER:$TARGET_USER" "/opt/meshing-around/-around"
+chown -R "$TARGET_USER:$TARGET_USER" "/opt/meshing-around/-around/logs"
+chown -R "$TARGET_USER:$TARGET_USER" "/opt/meshing-around/-around/data"
+chown "$TARGET_USER:$TARGET_USER" "/opt/meshing-around/-around/config.ini"
+chmod 640 "/opt/meshing-around/-around/config.ini"
+chmod 750 "/opt/meshing-around/-around/logs"
+chmod 750 "/opt/meshing-around/-around/data"
+
+echo "Permissions and ownership have been set."

etc/simulator.py

@@ -1,7 +1,8 @@
 #!/usr/bin/env python3
 # # Simulate meshing-around de K7MHI 2024
-from modules.log import * # Import the logger; ### --> If you are reading this put the script in the project root <-- ###
+from modules.log import logger, getPrettyTime # Import the logger; ### --> If you are reading this put the script in the project root <-- ###
 import time
+import datetime
 import random
 
 # Initialize the tool
@@ -22,6 +23,8 @@ 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)]
+def mesh_bot(message, nodeID, deviceID):
+    return "Meshing-Around Bot at your service!"
 #simulate GPS locations for testing
 locations = [
         (48.200909, -123.25719),

install.sh

@@ -1,10 +1,71 @@
 #!/bin/bash
 # meshing-around install helper script
+# to uninstall, run with --nope
 
-# install.sh
+NOPE=0
 cd "$(dirname "$0")"
 program_path=$(pwd)
-chronjob="0 1 * * * /usr/bin/python3 $program_path/etc/report_generator5.py"
+
+for arg in "$@"; do
+    if [[ "$arg" == "--nope" ]]; then
+        NOPE=1
+    fi
+done
+
+if [[ $NOPE -eq 1 ]]; then
+    echo "Uninstalling Meshing Around and all related services..."
+
+    sudo systemctl stop mesh_bot || true
+    sudo systemctl disable mesh_bot || true
+
+    sudo systemctl stop pong_bot || true
+    sudo systemctl disable pong_bot || true
+
+    sudo systemctl stop mesh_bot_w3_server || true
+    sudo systemctl disable mesh_bot_w3_server || true
+
+    sudo systemctl stop mesh_bot_reporting || true
+    sudo systemctl disable mesh_bot_reporting || true
+
+    sudo rm -f /etc/systemd/system/mesh_bot.service
+    sudo rm -f /etc/systemd/system/mesh_bot_reporting
+    sudo rm -f /etc/systemd/system/pong_bot.service
+    sudo rm -f /etc/systemd/system/mesh_bot_w3_server.service
+    sudo rm -f /etc/systemd/system/mesh_bot_reporting.service
+    sudo rm -f /etc/systemd/system/mesh_bot_reporting.timer
+
+    sudo systemctl daemon-reload
+    sudo systemctl reset-failed
+
+    sudo gpasswd -d meshbot dialout || true
+    sudo gpasswd -d meshbot tty || true
+    sudo gpasswd -d meshbot bluetooth || true
+    sudo groupdel meshbot || true
+    sudo userdel meshbot || true
+
+    sudo rm -rf /opt/meshing-around/
+
+    # If Ollama was installed and you want to remove it:
+    if [[ -f /etc/systemd/system/ollama.service ]]; then
+        read -p "Ollama service detected. Do you want to remove Ollama and all its data? (y/n): " remove_ollama
+        if [[ "$remove_ollama" =~ ^[Yy] ]]; then
+            sudo systemctl stop ollama || true
+            sudo systemctl disable ollama || true
+            sudo rm -f /etc/systemd/system/ollama.service
+            sudo rm -rf /usr/local/bin/ollama
+            sudo rm -rf ~/.ollama
+            echo "Ollama removed."
+        else
+            echo "Ollama not removed."
+        fi
+    fi
+
+    echo "Uninstall complete. Hope to see you again! 73"
+    exit 0
+fi
+
+# install.sh, Meshing Around installer script
+# Thanks for using Meshing Around!
 printf "\n########################"
 printf "\nMeshing Around Installer\n"
 printf "########################\n"
@@ -13,13 +74,18 @@ printf "Installer works best in raspian/debian/ubuntu or foxbuntu embedded syste
 printf "If there is a problem, try running the installer again.\n"
 printf "\nChecking for dependencies...\n"
 
+# fuse check for existing installation
+if [[ -f config.ini ]]; then
+    printf "\nDetected existing installation, please backup and remove existing installation before proceeding\n"
+    exit 1
+fi
 # check if we are in /opt/meshing-around
-if [ $program_path != "/opt/meshing-around" ]; then
+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
+        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
@@ -71,17 +137,25 @@ else
     printf "\nDependencies installed\n"
 fi
 
-# add user to groups for serial access
-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
 
 # 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
+cp etc/mesh_bot_w3_server.tmp etc/mesh_bot_w3_server.service
+
+# 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_server.service
+
+# copy modules/custom_scheduler.py template if it does not exist
+if [[ ! -f modules/custom_scheduler.py ]]; then
+    cp etc/custom_scheduler.template modules/custom_scheduler.py
+    printf "\nCustom scheduler template copied to modules/custom_scheduler.py\n"
+fi
 
 # generate config file, check if it exists
 if [[ -f config.ini ]]; then
@@ -173,15 +247,7 @@ else
     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?
-
-#ask if we should add a user for the bot
+# 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
@@ -197,29 +263,45 @@ if [[ $(echo "${meshbotservice}" | grep -i "^y") ]] || [[ $(echo "${embedded}" |
 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
+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_reporting.timer
+# set the correct group in the service file
 replace="s|Group=pi|Group=$whoami|g"
-sed -i $replace etc/pong_bot.service
-sed -i $replace etc/mesh_bot.service
-sed -i $replace etc/mesh_bot_reporting.service
-sed -i $replace etc/mesh_bot_w3.service
+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_reporting.timer
 printf "\n service files updated\n"
 
+# add user to groups for serial access
+printf "\nAdding user to dialout, bluetooth, and tty groups for serial access\n"
+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"
+sudo chown "$whoami:$whoami" "$program_path/config.ini"
+sudo chmod 640 "$program_path/config.ini"
+echo "Permissions set for meshbot on config.ini"
+sudo chmod 750 "$program_path/logs"
+sudo chmod 750 "$program_path/data"
+echo "Permissions set for meshbot on logs and data directories"
+
+# check and see if some sort of NTP is running
+if ! systemctl is-active --quiet ntp.service && \
+   ! systemctl is-active --quiet systemd-timesyncd.service && \
+   ! systemctl is-active --quiet chronyd.service; then
+    printf "\nNo NTP service detected, it is recommended to have NTP running for proper bot operation.\n"
+fi
+
+
 if [[ $(echo "${bot}" | grep -i "^p") ]]; then
     # install service for pong bot
     sudo cp etc/pong_bot.service /etc/systemd/system/
@@ -238,6 +320,29 @@ if [[ $(echo "${bot}" | grep -i "^m") ]]; then
     service="mesh_bot"
 fi
 
+# install mesh_bot_reporting timer to run daily at 4:20 am
+# echo ""
+# echo "Installing mesh_bot_reporting.timer to run mesh_bot_reporting daily at 4:20 am..."
+# sudo cp etc/mesh_bot_reporting.service /etc/systemd/system/
+# sudo cp etc/mesh_bot_reporting.timer /etc/systemd/system/
+# sudo systemctl daemon-reload
+# sudo systemctl enable mesh_bot_reporting.timer
+# sudo systemctl start mesh_bot_reporting.timer
+# echo "mesh_bot_reporting.timer installed and enabled"
+# echo "Check timer status with: systemctl status mesh_bot_reporting.timer"
+# echo "List all timers with: systemctl list-timers"
+# echo ""
+
+# # install mesh_bot_w3_server service
+# echo "Installing mesh_bot_w3_server.service to run the web3 server..."
+# sudo cp etc/mesh_bot_w3_server.service /etc/systemd/system/
+# sudo systemctl daemon-reload
+# sudo systemctl enable mesh_bot_w3_server.service
+# sudo systemctl start mesh_bot_w3_server.service
+# echo "mesh_bot_w3_server.service installed and enabled"
+# echo "Check service status with: systemctl status mesh_bot_w3_server.service"
+# echo ""
+
 # check if running on embedded for final steps
 if [[ $(echo "${embedded}" | grep -i "^n") ]]; then
     # ask if emoji font should be installed for linux
@@ -297,8 +402,15 @@ if [[ $(echo "${embedded}" | grep -i "^n") ]]; then
     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
+    printf "sudo systemctl disable %s.service\n" "$service" >> install_notes.txt
+    printf "\n older chron statment to run the report generator hourly:\n" >> install_notes.txt
+    printf "0 * * * * /usr/bin/python3 $program_path/etc/report_generator5.py" >> install_notes.txt
+    printf "  to edit crontab run 'crontab -e'\n" >> install_notes.txt
+    printf "\nmesh_bot_reporting.timer installed to run daily at 4:20 am\n" >> install_notes.txt
+    printf "Check timer status: systemctl status mesh_bot_reporting.timer\n" >> install_notes.txt
+    printf "List all timers: systemctl list-timers\n" >> install_notes.txt
+    printf "View timer logs: journalctl -u mesh_bot_reporting.timer\n" >> install_notes.txt
+    printf "*** Stay Up to date using 'bash update.sh' ***\n" >> 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
@@ -328,15 +440,18 @@ else
     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
+
+    sudo systemctl daemon-reload
+    # # 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
+    # document the service install
+    printf "Reference following commands:\n\n" > 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
@@ -344,9 +459,16 @@ else
     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 "older crontab to run the report generator hourly:" >> install_notes.txt
+    printf "0 * * * * /usr/bin/python3 $program_path/etc/report_generator5.py" >> install_notes.txt
+    printf "  to edit crontab run 'crontab -e'" >> install_notes.txt
+    printf "\nmesh_bot_reporting.timer installed to run daily at 4:20 am\n" >> install_notes.txt
+    printf "Check timer status: systemctl status mesh_bot_reporting.timer\n" >> install_notes.txt
+    printf "List all timers: systemctl list-timers\n" >> install_notes.txt
+    printf "*** Stay Up to date using 'bash update.sh' ***\n" >> install_notes.txt
 fi
 
-printf "\nInstallation complete!\n"
+printf "\nInstallation complete?\n"
 
 exit 0
 
@@ -354,13 +476,23 @@ exit 0
 
 # 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_w3_server
+# sudo systemctl disable mesh_bot_w3_server
+
 # 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/mesh_bot_reporting
 # sudo rm /etc/systemd/system/pong_bot.service
+# sudo rm /etc/systemd/system/mesh_bot_w3_server.service
+# sudo rm /etc/systemd/system/mesh_bot_reporting.service
+# sudo rm /etc/systemd/system/mesh_bot_reporting.timer
+
 # sudo systemctl daemon-reload
 # sudo systemctl reset-failed
 
@@ -370,7 +502,14 @@ exit 0
 # sudo groupdel meshbot
 # sudo userdel meshbot
 
-# sudo rm -rf /opt/meshing-around
+# sudo rm -rf /opt/meshing-around/
+
+# If Ollama was installed and you want to remove it:
+# sudo systemctl stop ollama
+# sudo systemctl disable ollama
+# sudo rm /etc/systemd/system/ollama.service
+# sudo rm -rf /usr/local/bin/ollama
+# sudo rm -rf ~/.ollama
 
 
 # after install shenannigans

launch.sh

@@ -5,12 +5,12 @@
 cd "$(dirname "$0")"
 
 
-if [ ! -f "config.ini" ]; then
+if [[ ! -f "config.ini" ]]; then
     cp config.template config.ini
 fi
 
 # activate the virtual environment if it exists
-if [ -d "venv" ]; then
+if [[ -d "venv" ]]; then
     source venv/bin/activate
 else
     echo "Virtual environment not found, this tool just launches the .py in venv"
@@ -22,9 +22,9 @@ if [[ "$1" == pong* ]]; then
     python3 pong_bot.py
 elif [[ "$1" == mesh* ]]; then
     python3 mesh_bot.py
-elif [ "$1" == "html" ]; then
+elif [[ "$1" == "html" ]]; then
     python3 etc/report_generator.py
-elif [ "$1" == "html5" ]; then
+elif [[ "$1" == "html5" ]]; then
     python3 etc/report_generator5.py
 elif [[ "$1" == add* ]]; then
     python3 script/addFav.py

logs/README.md

@@ -1,10 +1,16 @@
 # Logs and Reports
-Logs will collect here. Give a day of logs or a bunch of messages to have good reports.
 
-## 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`
+This directory stores log files generated by the Mesh Bot. To generate useful reports, ensure you have at least a day's worth of logs or a substantial number of messages.
+
+## Reporting
+
+Reports are generated using [`../etc/report_generator5.py`](../etc/report_generator5.py), which produces modern HTML5 reports. The output (`index.html`) is saved in [`../etc/www`](../etc/www) by default. A `.cfg` configuration file is created on first run, allowing you to customize settings such as the web root directory.
+
+- Ensure `SyslogToFile = True` and `sysloglevel = DEBUG` in your configuration to enable full reporting.
+- If using a virtual environment and `launch.sh`, you can run:  
+  ```sh
+  launch.sh html5
+  ```
 
 ![reportView](../etc/reporting.jpg)
 

modules/adding_more.md

@@ -0,0 +1,207 @@
+# Modules and Adding Features
+
+This document explains how to add new modules and commands to your Meshtastic mesh-bot project.
+
+## Table of Contents
+
+- [Overview](#overview)
+- [Adding a New Command](#adding-a-new-command)
+- [Running a Shell Command](#running-a-shell-command)
+- [Best Practices](#best-practices)
+- [Technical Assistance & Troubleshooting](#technical-assistance--troubleshooting)
+
+---
+
+## Overview
+
+For code testing, see `etc/simulator.py` to simulate a bot.  
+You can also use `meshtasticd` (Linux-native) in `noradio` mode with MQTT server and client to emulate a mesh network.
+
+---
+
+## Adding a New Command
+
+Follow these steps to add a new BBS option or command to the bot:
+
+### 1. Define the Command Handler
+
+Add a new function in `mesh_bot.py` to handle your command.  
+Example for a command called `newcommand`:
+
+```python
+def handle_newcommand(message, message_from_id, deviceID):
+    return "This is a response from the new command."
+```
+
+If your command is complex, consider creating a new module (e.g., `modules/newcommand.py`).  
+Import your new module where needed (see `modules/system.py` for examples).
+
+---
+
+### 2. Add the Command to the Auto Response
+
+Update the `auto_response` function in `mesh_bot.py` to include your 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
+
+Edit `modules/system.py` to include your new command in the trap list and help message:
+
+```python
+#...
+trap_list = ("cmd", "cmd?", "newcommand")  # Add your command here
+help_message = "Bot CMD?:newcommand, "
+#...
+```
+
+**Preferred method:**  
+Add a configuration block below `ping` (around line 28):
+
+```python
+# newcommand Configuration
+newcommand_enabled = True  # settings.py handles 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"
+```
+
+---
+
+### 4. Test the New Command
+
+Run MeshBot and test your new command by sending a message with `newcommand` to ensure it responds correctly.
+
+---
+
+## Running a Shell Command
+
+You can make a command that calls a bash script on the system (requires the `filemon` module):
+
+```python
+def auto_response(message, snr, rssi, hop, pkiStatus, message_from_id, channel_number, deviceID, isDM):
+    #...
+    "switchON": lambda: call_external_script(message)
+```
+
+This will call the default script located at `script/runShell.sh` and return its output.
+
+---
+
+## Best Practices
+
+- **Modularize:** Place complex or reusable logic in its own module.
+- **Document:** Add docstrings and comments to your functions.
+- **Test:** Use the simulator or a test mesh to verify new features.
+- **Update Help:** Keep the help message and trap list up to date for users.
+- **Configuration:** Use `settings.py` and `config.ini` for feature toggles and settings.
+
+---
+
+## Technical Assistance & Troubleshooting
+
+- **Debug Logging:**  
+  Use the `logger` module for debug output. Check logs for errors or unexpected behavior.
+- **Common Issues:**  
+  - *Module Import Errors:* Ensure your new module is in the `modules/` directory and imported correctly.
+  - *Command Not Responding:* Verify your command is in the trap list and auto_response dictionary.
+  - *Configuration Problems:* Double-check `settings.py` and `config.ini` for typos or missing entries.
+- **Testing:**  
+  - Use `etc/simulator.py` for local testing without radio hardware.
+  - Use `meshtasticd` in `noradio` mode for network emulation.
+- **Python Environment:**  
+  - Use a virtual environment (`python3 -m venv venv`) to manage dependencies.
+  - Install requirements with `pip install -r requirements.txt`.
+- **Updating Dependencies:**  
+  - try not to I want to remove some.
+- **Getting Help:**  
+  - Check the project wiki or issues page for common questions.
+  - Use inline comments and docstrings for clarity.
+  - If you’re stuck, ask for help on the project’s GitHub Discussions or Issues tab.
+
+---
+
+
+## Overview Unit Tests
+
+Your test_bot.py file contains a comprehensive suite of unit tests for the various modules the project. The tests are organized using Python’s `unittest` framework and cover both core utility modules and all major game modules.
+
+---
+
+## Structure
+
+- **Imports & Setup:**  
+  The script sets up the environment, imports all necessary modules, and suppresses certain warnings for clean test output.
+
+- **TestBot Class:**  
+  All tests are methods of the `TestBot` class, which inherits from `unittest.TestCase`.
+
+---
+
+## Core Module Tests
+
+- **Database & Checklist:**  
+  - `test_load_bbsdb`, `test_bbs_list_messages`, `test_initialize_checklist_database`
+- **News & Alerts:**  
+  - `test_init_news_sources`, `test_get_nina_alerts`
+- **LLM & Wikipedia:**  
+  - `test_llmTool_get_google`, `test_send_ollama_query`, `test_get_wikipedia_summary`, `test_get_kiwix_summary`
+- **Space & Weather:**  
+  - `test_get_moon_phase`, `test_get_sun_times`, `test_hf_band_conditions`
+- **Radio & Location:**  
+  - `test_get_hamlib`, `test_get_rss_feed`, `get_openskynetwork`, `test_initalize_qrz_database`
+
+---
+
+## Game Module Tests
+
+Each game module has a dedicated test that simulates a typical user interaction:
+
+- **Tic-Tac-Toe:**  
+  Starts a game and makes one move.
+- **Video Poker:**  
+  Starts a session and places a bet.
+- **Blackjack:**  
+  Starts a game and places a bet.
+- **Hangman:**  
+  Starts a game and guesses a letter.
+- **Lemonade Stand:**  
+  Starts a game and buys a box of cups.
+- **GolfSim:**  
+  Starts a hole and takes a shot.
+- **DopeWars:**  
+  Starts a game, selects a city, and checks the list.
+- **MasterMind:**  
+  Starts a game and makes one guess.
+- **Quiz:**  
+  Starts a quiz, joins as a player, answers one question, and ends the quiz.
+- **Survey:**  
+  Starts a survey, answers one question, and ends the survey.
+- **HamTest:**  
+  Starts a ham radio test and answers one question.
+
+---
+
+## Extended API Tests
+
+If the `.checkall` file is present, additional API and data-fetching tests are run for:
+- RepeaterBook, ArtSciRepeaters, NOAA tides/weather, USGS earthquakes/volcanoes, satellite passes, and more.
+
+## Notes
+
+- Tests are designed to be **non-destructive** and **idempotent**.
+- Some tests require specific data files (e.g., for quiz, survey, hamtest).
+- The suite is intended to be run from the main program directory.
+
+
+
+
+Happy hacking!

modules/bbstools.md

@@ -0,0 +1,234 @@
+
+---
+
+# 📡 meshBBS: How-To & API Documentation
+
+This document covers the Bulliten Board System or BBS componment of the meshing-around project.
+
+## Table of Contents
+
+1. [BBS Core Functions](#1-bbs-core-functions)
+    - [Central Message Store](#11-central-message-store)
+    - [Direct Mail (DM) Messages](#12-direct-mail-dm-messages)
+    - [BBS Commands](#bbs-commands)
+2. [Synchronization bot2bot: Full Sync Workflow](#2-synchronization-bot2bot--full-sync-workflow)
+    - [BBS Database Sync: File-Based (Out-of-Band)](#21-bbs-database-sync-file-based-out-of-band)
+    - [BBS Over-the-Air (OTA) Sync: Linking](#22-bbs-over-the-air-ota-sync-linking)
+    - [Scheduling BBS Auto Sync](#23-scheduling-bbs-auto-sync)
+3. [Troubleshooting](#4-troubleshooting)
+4. [API Reference: BBS Sync](#5-api-reference-bbs-sync)
+5. [Best Practices](#5-best-practices)
+
+## 1. **BBS Core Functions**
+The mesh-bot provides a basic message mail system for Meshtastic
+
+## 1.1 Central Message Store
+
+- **Shared public message space** for all nodes.
+- Classic BBS list with a simple, one-level message tree.
+- Messages are stored in `data/bbsdb.pkl`.
+- Each entry typically includes:  
+  `[id, subject, body, fromNode, timestamp, threadID, replytoID]`
+
+### Posting to Public
+
+To post a public message:
+```sh
+bbspost $Subject #Message
+```
+
+---
+
+## 1.2 Direct Mail (DM) Messages
+- **DMs are private messages** sent from one node to another.
+- Stored separately from public posts in `data/bbsdm.pkl`.
+- Each DM entry typically includes:  
+  `[id, toNode, message, fromNode, timestamp, threadID, replytoID]`
+- You can inject DMs directly for automation using the `script/injectDM.py` tool.
+
+### DM Delivery
+
+- To post a DM, use:  
+  ```sh
+  bbspost @USER #Message
+  ```
+- When a DM is posted, it is added to the DM database.
+- When the bot detects the recipient node on the network, it delivers the DM and then removes it from local storage.
+
+---
+
+### BBS Commands
+
+| Command      | Description                                   |
+|--------------|-----------------------------------------------|
+| `bbshelp`    | Show BBS help                                 |
+| `bbslist`    | List messages                                 |
+| `bbsread`    | Read a message by ID                          |
+| `bbspost`    | Post a message or DM                          |
+| `bbsdelete`  | Delete a message                              |
+| `bbsinfo`    | BBS stats (sysop)                             |
+| `bbslink`    | Link messages between BBS systems             |
+
+---
+
+## 2. **Synchronization bot2bot : Full Sync Workflow**
+
+1. **Set up a dedicated sync channel** (e.g., channel bot-admin).
+2. **Configure both nodes** with `bbs_link_enabled = True` and add each other to `bbs_link_whitelist`.
+3. **Schedule sync** every hour:
+   - Node A sends `bbslink 0` to Node B on channel 99.
+   - Node B responds with messages and `bbsack`.
+4. **Optionally, use SSH/scp** to copy `bbsdb.pkl` for full out-of-band backup.
+
+
+## 2.1. **BBS Database Sync: File-Based (Out-of-Band)**
+
+### **Manual/Automated File Sync (e.g., SSH/SCP)**
+- **Purpose:** Sync BBS data between nodes by copying `bbsdb.pkl` and `bbsdm.pkl` files.
+```ini
+[bbs]
+# The "api" needs enabled which enables file polling 
+bbsAPI_enabled = True 
+```
+- **How-To:**
+  1. **Locate Files:**  
+     - `data/bbsdb.pkl` (public posts)
+     - `data/bbsdm.pkl` (direct messages)
+  2. **Copy Files:**  
+     Use `scp` or `rsync` to copy files between nodes:
+     ```sh
+     scp user@remote:/path/to/meshing-around/data/bbsdb.pkl ./data/bbsdb.pkl
+     scp user@remote:/path/to/meshing-around/data/bbsdm.pkl ./data/bbsdm.pkl
+     ```
+  3. **Reload Database:**  
+     After copying, when the "API" is enabled the watchdog will look for changes and injest.
+
+- **Automating with Cron/Scheduler:**
+  - Set up a cron job or use the bot’s scheduler to periodically pull/push files.
+
+---
+
+## 2.2. **BBS Over-the-Air (OTA) Sync: Linking**
+### **How OTA Sync Works**
+- Nodes can exchange BBS messages using special commands over the mesh network.
+- Uses `bbslink` and `bbsack` commands for message exchange.
+- Future supports compression for bandwidth efficiency.
+
+### **Enabling BBS Linking**
+- Set `bbs_link_enabled = True` in your config.
+- Optionally, set `bbs_link_whitelist` to restrict which nodes can sync.
+
+### **Manual Sync Command**
+- To troubleshoot request sync from another node, send:
+  ```
+  bbslink <messageID> $<subject> #<body>
+  ```
+- The receiving node will respond with `bbsack <messageID>`.
+
+### **Out-of-Band Channel**
+- For high-reliability sync, configure a dedicated channel (not used for chat).
+---
+
+## 2.3. **Scheduling BBS Auto Sync**
+
+### **Using the Bot’s Scheduler**
+
+- You can schedule periodic sync requests to a peer node.
+- Example: Every hour, send a `bbslink` request to a peer.
+see more at [Module Readme](README.md#scheduler)
+
+---
+
+#### 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
+
+```ini
+[bbs]
+bbslink_enabled = True
+bbslink_whitelist = # list of whitelisted nodes numbers ex: 2813308004,4258675309 empty list allows all
+
+[scheduler]
+enabled = True
+interface = 1
+channel = 2
+value = link
+interval = 12 # 12 hours
+```
+
+```python
+# Custom Schedule Example if using custom for [scheduler]
+# Send bbslink looking for peers every 2 days at 10 AM
+schedule.every(2).days.at("10:00").do(send_message("bbslink MeshBot looking for peers", schedulerChannel, 0, schedulerInterface))
+```
+
+---
+
+---
+
+## 4. **Troubleshooting**
+
+- **Messages not syncing?**
+  - Check `bbs_link_enabled` and whitelist settings.
+  - Ensure both nodes are on the same sync channel.
+  - Check logs for errors.
+
+- **File sync issues?**
+  - Verify file permissions and paths.
+  - Ensure the bot reloads the database after file copy.
+
+- **Custom file problems?**
+- remove the custom_scheduler.py and replace it with [etc/custom_scheduler.py](etc/custom_scheduler.py)
+
+ The bbs link command should include `bbslink`
+`.do(send_message("bbslink MeshBot looking for peers", schedulerChannel, 0, schedulerInterface))`
+
+```ini
+[bbs]
+# The "api" needs enabled which enables file polling and use of `script/injectDM.py`
+bbsAPI_enabled = True 
+```
+
+## 5. **API Reference: BBS Sync**
+
+### **Key Functions in Python**
+| Function                | Purpose                                   | Usage Example                                      |
+|-------------------------|-------------------------------------------|----------------------------------------------------|
+| `bbs_post_message()`    | Post a new public message                 | `bbs_post_message(subject, body, fromNode)`        |
+| `bbs_read_message()`    | Read a message by ID                      | `bbs_read_message(messageID)`                      |
+| `bbs_delete_message()`  | Delete a message (admin/owner only)       | `bbs_delete_message(messageID, fromNode)`          |
+| `bbs_list_messages()`   | List all message subjects                 | `bbs_list_messages()`                              |
+| `bbs_post_dm()`         | Post a direct message                     | `bbs_post_dm(toNode, message, fromNode)`           |
+| `bbs_check_dm()`        | Check for DMs for a node                  | `bbs_check_dm(toNode)`                             |
+| `bbs_delete_dm()`       | Delete a DM after reading                 | `bbs_delete_dm(toNode, message)`                   |
+| `get_bbs_stats()`       | Get stats on BBS and DMs                  | `get_bbs_stats()`                                  |
+
+
+| Function                  | Purpose                                   |
+|---------------------------|-------------------------------------------|
+| `bbs_sync_posts()`        | Handles incoming/outgoing sync requests   |
+| `bbs_receive_compressed()`| Handles compressed sync data              |
+| `compress_data()`         | Compresses data for OTA transfer          |
+| `decompress_data()`       | Decompresses received data                |
+
+
+### **Handle Incoming Sync**
+- The bot automatically processes incoming `bbslink` and `bbsack` commands via `bbs_sync_posts()`.
+
+### **Compressed Sync**
+Future Use
+- If `useSynchCompression` is enabled, use:
+  ```python
+  compressed = compress_data(msg)
+  send_raw_bytes(peerNode, compressed)
+  ```
+- Receiving node uses `bbs_receive_compressed()`.
+
+---
+### 5. **Best Practices**
+
+- **Backup:** Regularly back up `bbsdb.pkl` and `bbsdm.pkl`.
+- **Security:** Use SSH keys for file transfer; restrict OTA sync to trusted nodes.
+- **Reliability:** Use a dedicated channel for BBS sync to avoid chat congestion.
+- **Automation:** Use the scheduler for regular syncs, both file-based and OTA.
+
+---

modules/bbstools.py

@@ -2,8 +2,10 @@
 # K7MHI Kelly Keeton 2024
 
 import pickle # pip install pickle
-from modules.log import *
+from modules.log import logger
+from modules.settings import bbs_admin_list, bbs_ban_list, MESSAGE_CHUNK_SIZE, bbs_link_enabled, bbs_link_whitelist, responseDelay
 import time
+from datetime import datetime
 
 useSynchCompression = False
 
@@ -20,30 +22,32 @@ bbs_dm = []
 
 def load_bbsdb():
     global bbs_messages
-    # load the bbs messages from the database file
     try:
         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
+                    msgHash = hash(tuple(msg[1:3]))
                     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]])
+                return True  # Loaded successfully, regardless of whether new messages were added
+            return False # File existed but did not contain a valid list of messages (possibly corrupted)
     except FileNotFoundError:
+        # create a new bbsdb.pkl with a welcome message
+        # template ([messageID, subject, message, fromNode, now, thread, replyto])
+        bbs_messages = [[1, "Welcome to meshBBS", "Welcome to the BBS, please post a message!",0,time.strftime('%Y-%m-%d %H:%M:%S'),0,0]]
         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)
+                return True
         except Exception as e:
             logger.error(f"System: Error creating bbsdb.pkl: {e}")
+            return False
     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]]
+        return False
 
 def save_bbsdb():
     global bbs_messages
@@ -97,7 +101,7 @@ def bbs_delete_message(messageID = 0, fromNode = 0):
 
 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')
+    now = datetime.now().strftime('%Y-%m-%d %H:%M:%S')
     thread = threadID
     replyto = replytoID
     # post a message to the bbsdb and assign a messageID

modules/checklist.md

@@ -0,0 +1,396 @@
+# Enhanced Check-in/Check-out System
+
+## Overview
+
+The enhanced checklist module provides asset tracking and accountability features with advanced safety monitoring capabilities. This system is designed for scenarios where tracking people, equipment, or assets is critical for safety, accountability, or logistics.
+
+## Key Features
+
+### 🔐 Basic Check-in/Check-out
+- Simple interface for tracking when people or assets are checked in or out
+- Automatic duration calculation
+- Location tracking (GPS coordinates if available)
+- Notes support for additional context
+
+### ⏰ Safety Monitoring with Time Intervals
+- Set expected check-in intervals for safety  (minimal 20min)
+- Automatic tracking of overdue check-ins
+- Ideal for solo activities, remote work, or high-risk operations
+- Get alerts when someone hasn't checked in within their expected timeframe
+
+### ✅ Approval Workflow
+- Admin approval system for check-ins
+- Deny/remove unauthorized check-ins
+- Maintain accountability and control
+
+### 📍 Location Tracking
+- Automatic GPS location capture when checking in/out
+- View last known location in checklist
+- Track movement over time
+
+- **Time Window Monitoring**: Check-in with safety intervals (e.g., `checkin 60 Hunting in tree stand`)
+  - Tracks if users don't check in within expected timeframe
+  - Ideal for solo activities, remote work, or safety accountability
+  - Provides `get_overdue_checkins()` function for alert integration
+
+- **Approval Workflow**:
+  - `checklistapprove <id>` - Approve pending check-ins (admin)
+  - `checklistdeny <id>` - Deny/remove check-ins (admin)
+  - Support for approval-based workflows
+
+- **Enhanced Database Schema**:
+  - Added `approved` field for approval workflows
+  - Added `expected_checkin_interval` field for safety monitoring
+  - Automatic migration for existing databases
+
+#### New Commands:
+- `checklistapprove <id>` - Approve a check-in
+- `checklistdeny <id>` - Deny a check-in
+- Enhanced `checkin [interval] [note]` - Now supports interval parameter
+
+## Configuration
+
+Add to your `config.ini`:
+
+```ini
+[checklist]
+enabled = True
+checklist_db = data/checklist.db
+# Set to True to reverse the meaning of checkin/checkout
+reverse_in_out = False
+```
+
+## Commands Reference
+
+### Basic Commands
+
+#### Check In
+```
+checkin [interval] [notes]
+```
+
+Check in to the system. Optionally specify a monitoring interval in minutes.
+
+**Examples:**
+```
+checkin Arrived at base camp
+checkin 30 Solo hiking on north trail
+checkin 60 Working alone in tree stand
+checkin Going hunting
+```
+
+#### Check Out
+```
+checkout [notes]
+```
+
+Check out from the system. Shows duration since check-in.
+
+**Examples:**
+```
+checkout Heading back
+checkout Mission complete
+checkout
+```
+
+#### View Checklist
+```
+checklist
+```
+
+Shows all active check-ins with durations.
+
+**Example Response:**
+```
+ID: Hunter1 checked-In for 01:23:45📝Solo hunting
+ID: Tech2 checked-In for 00:15:30📝Equipment repair
+```
+
+#### Purge Records
+```
+purgein    # Delete your check-in record
+purgeout   # Delete your check-out record
+```
+
+Use these to manually remove your records if needed.
+
+### Admin Commands
+
+#### Approve Check-in
+```
+checklistapprove <checkin_id>
+```
+
+Approve a pending check-in (requires admin privileges).
+
+**Example:**
+```
+checklistapprove 123
+```
+
+#### Deny Check-in
+```
+checklistdeny <checkin_id>
+```
+
+Deny and remove a check-in (requires admin privileges).
+
+**Example:**
+```
+checklistdeny 456
+```
+
+## Safety Monitoring Feature
+
+### How Time Intervals Work
+
+When checking in with an interval parameter, the system will track whether you check in again or check out within that timeframe.
+
+```
+checkin 60 Hunting in remote area
+```
+
+This tells the system:
+- You're checking in now
+- You expect to check in again or check out within 60 minutes
+- If 60 minutes pass without activity, you'll be marked as overdue
+
+### Use Cases for Time Intervals
+
+1. **Solo Activities**: Hunting, hiking, or working alone
+   ```
+   checkin 30 Solo patrol north sector
+   ```
+
+2. **High-Risk Operations**: Tree work, equipment maintenance
+   ```
+   checkin 45 Climbing tower for antenna work
+   ```
+
+3. **Remote Work**: Working in isolated areas
+   ```
+   checkin 120 Survey work in remote canyon
+   ```
+
+4. **Check-in Points**: Regular status updates during long operations
+   ```
+   checkin 15 Descending cliff face
+   ```
+
+### Overdue Check-ins
+
+The system tracks all check-ins with time intervals and can identify who is overdue. The module provides the `get_overdue_checkins()` function that returns a list of overdue users. 
+
+**Note**: Automatic alerts for overdue check-ins require integration with the bot's scheduler or alert system. The checklist module provides the detection capability, but sending notifications must be configured separately through the main bot's alert features.
+
+## Practical Examples
+
+### Example 1: Hunting Scenario
+
+Hunter checks in before going into the field:
+```
+checkin 60 Hunting deer stand #3, north 40
+```
+
+System response:
+```
+Checked✅In: Hunter1 (monitoring every 60min)
+```
+
+If the hunter doesn't check out or check in again within 60 minutes, they will appear on the overdue list.
+
+When done hunting:
+```
+checkout Heading back to camp
+```
+
+System response:
+```
+Checked⌛️Out: Hunter1 duration 02:15:30
+```
+
+### Example 2: Emergency Response Team
+
+Team leader tracks team members:
+
+```
+# Team members check in
+checkin 30 Search grid A-1
+checkin 30 Search grid A-2
+checkin 30 Search grid A-3
+```
+
+Team leader views status:
+```
+checklist
+```
+
+Response shows all active searchers with their durations.
+
+### Example 3: Equipment Checkout
+
+Track equipment loans:
+
+```
+checkin Radio #5 for field ops
+```
+
+When equipment is returned:
+```
+checkout Equipment returned
+```
+
+### Example 4: Site Survey
+
+Field technicians checking in at locations:
+
+```
+# At first site
+checkin 45 Site survey tower location 1
+
+# Moving to next site (automatically checks out from first)
+checkin 45 Site survey tower location 2
+```
+
+## Integration with Other Systems
+
+### Geo-Location Awareness
+
+The checklist system automatically captures GPS coordinates when available. This can be used for:
+- Tracking last known position
+- Geo-fencing applications
+- Emergency response coordination
+- Asset location management
+
+### Alert Systems
+
+The overdue check-in feature can trigger:
+- Notifications to supervisors
+- Emergency alerts
+- Automated messages to response teams
+- Email/SMS notifications (if configured)
+
+### Scheduling Integration
+
+Combine with the scheduler module to:
+- Send reminders to check in
+- Automatically generate reports
+- Schedule periodic check-in requirements
+- Send daily summaries
+
+## Best Practices
+
+### For Users
+
+1. **Always Include Context**: Add notes when checking in
+   ```
+   checkin 30 North trail maintenance
+   ```
+   Not just:
+   ```
+   checkin
+   ```
+
+2. **Set Realistic Intervals**: Don't set intervals too short or too long
+   - Too short: False alarms
+   - Too long: Defeats safety purpose
+
+3. **Check Out Promptly**: Always check out when done to clear your status
+
+4. **Use Consistent Naming**: If tracking equipment, use consistent names
+
+### For Administrators
+
+1. **Review Checklist Regularly**: Monitor who is checked in
+   ```
+   checklist
+   ```
+
+2. **Respond to Overdue Situations**: Act on overdue check-ins promptly
+
+3. **Set Clear Policies**: Establish when and how to use the system
+
+4. **Train Users**: Ensure everyone knows how to use time intervals
+
+5. **Test the System**: Regularly verify the system is working
+
+## Safety Scenarios
+
+### Scenario 1: Tree Stand Hunting
+```
+checkin 60 Hunting from tree stand at north plot
+```
+If hunter falls or has medical emergency, they'll be marked overdue after 60 minutes.
+
+### Scenario 2: Equipment Maintenance
+```
+checkin 30 Generator maintenance at remote site
+```
+If technician encounters danger, overdue status can be detected. Note: Requires alert system integration to send notifications.
+
+### Scenario 3: Hiking
+```
+checkin 120 Day hike to mountain peak
+```
+Longer interval for extended activity, but still provides safety net.
+
+### Scenario 4: Watchstanding
+```
+checkin 240 Night watch duty
+```
+Regular check-ins every 4 hours ensure person is alert and safe.
+
+## Database Schema
+
+### checkin Table
+```sql
+CREATE TABLE checkin (
+    checkin_id INTEGER PRIMARY KEY,
+    checkin_name TEXT,
+    checkin_date TEXT,
+    checkin_time TEXT,
+    location TEXT,
+    checkin_notes TEXT,
+    approved INTEGER DEFAULT 1,
+    expected_checkin_interval INTEGER DEFAULT 0
+)
+```
+
+### checkout Table
+```sql
+CREATE TABLE checkout (
+    checkout_id INTEGER PRIMARY KEY,
+    checkout_name TEXT,
+    checkout_date TEXT,
+    checkout_time TEXT,
+    location TEXT,
+    checkout_notes TEXT
+)
+```
+
+## Reverse Mode
+
+Setting `reverse_in_out = True` in config swaps the meaning of checkin and checkout commands. This is useful if your organization uses opposite terminology.
+
+With `reverse_in_out = True`:
+- `checkout` command performs a check-in
+- `checkin` command performs a check-out
+
+## Migration from Basic Checklist
+
+The enhanced checklist is backward compatible with the basic version. Existing check-ins will continue to work, and new features are optional. The database will automatically upgrade to add new columns when first accessed.
+
+## Troubleshooting
+
+### Not Seeing Overdue Alerts
+The overdue detection is built into the module, but alerts need to be configured in the main bot scheduler. Check your scheduler configuration.
+
+### Wrong Duration Shown
+Duration is calculated from check-in time to current time. If system clock is wrong, durations will be incorrect. Ensure system time is accurate.
+
+### Can't Approve/Deny Check-ins
+These are admin-only commands. Check that your node ID is in the `bbs_admin_list`.
+
+## Support
+
+For issues or feature requests, please file an issue on the GitHub repository.

modules/checklist.py

@@ -2,24 +2,56 @@
 # K7MHI Kelly Keeton 2024
 
 import sqlite3
-from modules.log import *
+from modules.log import logger
+from modules.settings import checklist_db, reverse_in_out, bbs_ban_list
 import time
 
-trap_list_checklist = ("checkin", "checkout", "checklist", "purgein", "purgeout")
+trap_list_checklist = ("checkin", "checkout", "checklist", "purgein", "purgeout", 
+                       "checklistapprove", "checklistdeny", "checklistadd", "checklistremove")
 
 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")
+    try:
+        conn = sqlite3.connect(checklist_db)
+        c = conn.cursor()
+        # Check if the checkin table exists, and create it if it doesn't
+        logger.debug("System: Checklist: Initializing database...")
+        c.execute('''CREATE TABLE IF NOT EXISTS checkin
+                     (checkin_id INTEGER PRIMARY KEY, checkin_name TEXT, checkin_date TEXT, 
+                      checkin_time TEXT, location TEXT, checkin_notes TEXT, 
+                      approved INTEGER DEFAULT 1, expected_checkin_interval INTEGER DEFAULT 0)''')
+        # Check if the checkout table exists, and create it if it doesn't
+        c.execute('''CREATE TABLE IF NOT EXISTS checkout
+                     (checkout_id INTEGER PRIMARY KEY, checkout_name TEXT, checkout_date TEXT, 
+                      checkout_time TEXT, location TEXT, checkout_notes TEXT)''')
+        
+        # Add new columns if they don't exist (for migration)
+        try:
+            c.execute("ALTER TABLE checkin ADD COLUMN approved INTEGER DEFAULT 1")
+        except sqlite3.OperationalError:
+            pass  # Column already exists
+        
+        try:
+            c.execute("ALTER TABLE checkin ADD COLUMN expected_checkin_interval INTEGER DEFAULT 0")
+        except sqlite3.OperationalError:
+            pass  # Column already exists
+        
+        try:
+            c.execute("ALTER TABLE checkin ADD COLUMN removed INTEGER DEFAULT 0")
+        except sqlite3.OperationalError:
+            pass  # Column already exists
+        
+        # Add this to your DB init (if not already present)
+        try:
+            c.execute("ALTER TABLE checkout ADD COLUMN removed INTEGER DEFAULT 0")
+        except sqlite3.OperationalError:
+            pass  # Column already exists
+        
+        conn.commit()
+        conn.close()
+        return True
+    except Exception as e:
+        logger.error(f"Checklist: Failed to initialize database: {e}")
+        return False
 
 def checkin(name, date, time, location, notes):
     location = ", ".join(map(str, location))
@@ -54,7 +86,7 @@ def delete_checkin(checkin_id):
 
 def checkout(name, date, time_str, location, notes):
     location = ", ".join(map(str, location))
-    # checkout a user
+    checkin_record = None  # Ensure variable is always defined
     conn = sqlite3.connect(checklist_db)
     c = conn.cursor()
     try:
@@ -74,18 +106,21 @@ def checkout(name, date, time_str, location, notes):
         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")
+            c.execute("SELECT checkin_time, checkin_date FROM checkin WHERE checkin_id = ?", (checkin_record[0],))
+            checkin_time, checkin_date = c.fetchone()
+            checkin_datetime = time.strptime(checkin_date + " " + checkin_time, "%Y-%m-%d %H:%M:%S")
             time_checked_in_seconds = time.time() - time.mktime(checkin_datetime)
             timeCheckedIn = time.strftime("%H:%M:%S", time.gmtime(time_checked_in_seconds))
             # # remove the checkin record older than the checkout
             # c.execute("DELETE FROM checkin WHERE checkin_date < ? OR (checkin_date = ? AND checkin_time < ?)", (date, date, time_str))
     except sqlite3.OperationalError as e:
         if "no such table" in str(e):
+            conn.close()
             initialize_checklist_database()
-            c.execute("INSERT INTO checkout (checkout_name, checkout_date, checkout_time, location, checkout_notes) VALUES (?, ?, ?, ?, ?)", (name, date, time_str, location, notes))
+            # Try again after initializing
+            return checkout(name, date, time_str, location, notes)
         else:
+            conn.close()
             raise
     conn.commit()
     conn.close()
@@ -106,18 +141,165 @@ def delete_checkout(checkout_id):
     conn.close()
     return "Checkout deleted." + str(checkout_id)
 
+def approve_checkin(checkin_id):
+    """Approve a pending check-in"""
+    conn = sqlite3.connect(checklist_db)
+    c = conn.cursor()
+    try:
+        c.execute("UPDATE checkin SET approved = 1 WHERE checkin_id = ?", (checkin_id,))
+        if c.rowcount == 0:
+            conn.close()
+            return f"Check-in ID {checkin_id} not found."
+        conn.commit()
+        conn.close()
+        return f"✅ Check-in {checkin_id} approved."
+    except Exception as e:
+        conn.close()
+        logger.error(f"Checklist: Error approving check-in: {e}")
+        return "Error approving check-in."
+
+def deny_checkin(checkin_id):
+    """Deny/delete a pending check-in"""
+    conn = sqlite3.connect(checklist_db)
+    c = conn.cursor()
+    try:
+        c.execute("DELETE FROM checkin WHERE checkin_id = ?", (checkin_id,))
+        if c.rowcount == 0:
+            conn.close()
+            return f"Check-in ID {checkin_id} not found."
+        conn.commit()
+        conn.close()
+        return f"❌ Check-in {checkin_id} denied and removed."
+    except Exception as e:
+        conn.close()
+        logger.error(f"Checklist: Error denying check-in: {e}")
+        return "Error denying check-in."
+
+def set_checkin_interval(name, interval_minutes):
+    """Set expected check-in interval for a user (for safety monitoring)"""
+    conn = sqlite3.connect(checklist_db)
+    c = conn.cursor()
+    try:
+        # Update the most recent active check-in for this user
+        c.execute("""
+            UPDATE checkin 
+            SET expected_checkin_interval = ? 
+            WHERE checkin_name = ? 
+            AND checkin_id NOT IN (
+                SELECT checkin_id 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
+        """, (interval_minutes, name))
+        
+        if c.rowcount == 0:
+            conn.close()
+            return f"No active check-in found for {name}."
+        
+        conn.commit()
+        conn.close()
+        return f"⏰ Check-in interval set to {interval_minutes} minutes for {name}."
+    except Exception as e:
+        conn.close()
+        logger.error(f"Checklist: Error setting check-in interval: {e}")
+        return "Error setting check-in interval."
+
+def get_overdue_checkins():
+    """Get list of users who haven't checked in within their expected interval"""
+    conn = sqlite3.connect(checklist_db)
+    c = conn.cursor()
+    current_time = time.time()
+    
+    try:
+        c.execute("""
+            SELECT checkin_id, checkin_name, checkin_date, checkin_time, expected_checkin_interval, location, checkin_notes
+            FROM checkin
+            WHERE expected_checkin_interval > 0
+            AND approved = 1
+            AND checkin_id NOT IN (
+                SELECT checkin_id FROM checkout
+                WHERE checkout_name = checkin_name
+                AND (checkout_date > checkin_date OR (checkout_date = checkin_date AND checkout_time > checkin_time))
+            )
+        """)
+        
+        active_checkins = c.fetchall()
+        conn.close()
+        
+        overdue_list = []
+        for checkin_id, name, date, time_str, interval, location, notes in active_checkins:
+            checkin_datetime = time.mktime(time.strptime(f"{date} {time_str}", "%Y-%m-%d %H:%M:%S"))
+            time_since_checkin = (current_time - checkin_datetime) / 60  # in minutes
+            
+            if time_since_checkin > interval:
+                overdue_minutes = int(time_since_checkin - interval)
+                overdue_list.append({
+                    'id': checkin_id,
+                    'name': name,
+                    'location': location,
+                    'overdue_minutes': overdue_minutes,
+                    'interval': interval,
+                    'checkin_notes': notes
+                })
+        
+        return overdue_list
+    except sqlite3.OperationalError as e:
+        conn.close()
+        if "no such table" in str(e):
+            initialize_checklist_database()
+            return get_overdue_checkins()
+        logger.error(f"Checklist: Error getting overdue check-ins: {e}")
+        return []
+
+def format_overdue_alert():
+    try:
+        """Format overdue check-ins as an alert message"""
+        overdue = get_overdue_checkins()
+        logger.debug(f"Overdue check-ins: {overdue}")  # Add this line
+        if not overdue:
+            return None
+        
+        alert = "⚠️ OVERDUE CHECK-INS:\n"
+        for entry in overdue:
+            hours = entry['overdue_minutes'] // 60
+            minutes = entry['overdue_minutes'] % 60
+            alert += f"{entry['name']}: {hours}h {minutes}m overdue"
+            # if entry['location']:
+            #     alert += f" @ {entry['location']}"
+            if entry['checkin_notes']:
+                alert += f" 📝{entry['checkin_notes']}"
+            alert += "\n"
+        
+        return alert.rstrip()
+    except Exception as e:
+        logger.error(f"Checklist: Error formatting overdue alert: {e}")
+        return None
+
 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()
+    try:
+        c.execute("""
+            SELECT * FROM checkin
+            WHERE removed = 0
+            AND checkin_id NOT IN (
+                SELECT checkin_id FROM checkout
+                WHERE checkout_date > checkin_date OR (checkout_date = checkin_date AND checkout_time > checkin_time)
+            )
+        """)
+        rows = c.fetchall()
+    except sqlite3.OperationalError as e:
+        if "no such table" in str(e):
+            conn.close()
+            initialize_checklist_database()
+            return list_checkin()
+        else:
+            conn.close()
+            logger.error(f"Checklist: Error listing checkins: {e}")
+            return "Error listing checkins."
     conn.close()
     timeCheckedIn = ""
     checkin_list = ""
@@ -132,7 +314,7 @@ def list_checkin():
             timeCheckedIn = f"{days}d {hours:02}:{minutes:02}:{seconds:02}"
         else:
             timeCheckedIn = f"{hours:02}:{minutes:02}:{seconds:02}"
-        checkin_list += "ID: " + row[1] + " checked-In for " + timeCheckedIn
+            checkin_list += "ID: " + str(row[0]) + " " + row[1] + " checked-In for " + timeCheckedIn
         if row[5] != "":
             checkin_list += "📝" + row[5]
         if row != rows[-1]:
@@ -149,31 +331,94 @@ def process_checklist_command(nodeID, message, name="none", location="none"):
     if str(nodeID) in bbs_ban_list:
         logger.warning("System: Checklist attempt from the ban list")
         return "unable to process command"
+    
+    message_lower = message.lower()
+    parts = message.split()
+    
     try:
-        comment = message.split(" ", 1)[1]
+        comment = message.split(" ", 1)[1] if len(parts) > 1 else ""
     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):
+    if ("checkin" in message_lower and not reverse_in_out) or ("checkout" in message_lower and reverse_in_out):
+        # Check if interval is specified: checkin 60 comment
+        interval = 0
+        actual_comment = comment
+        if comment and parts[1].isdigit():
+            interval = int(parts[1])
+            actual_comment = " ".join(parts[2:]) if len(parts) > 2 else ""
+        
+        result = checkin(name, current_date, current_time, location, actual_comment)
+        
+        # Set interval if specified
+        if interval > 0:
+            set_checkin_interval(name, interval)
+            result += f" (monitoring every {interval}min)"
+        
+        return result
+    
+    elif ("checkout" in message_lower and not reverse_in_out) or ("checkin" in message_lower and reverse_in_out):
         return checkout(name, current_date, current_time, location, comment)
-    elif "purgein" in message.lower():
-        return delete_checkin(nodeID)
-    elif "purgeout" in message.lower():
-        return delete_checkout(nodeID)
-    elif "?" in message.lower():
+    
+    elif "purgein" in message_lower:
+        return mark_checkin_removed_by_name(name)
+    
+    elif "purgeout" in message_lower:
+        return mark_checkout_removed_by_name(name)
+    
+    elif message_lower.startswith("checklistapprove "):
+        try:
+            checkin_id = int(parts[1])
+            return approve_checkin(checkin_id)
+        except (ValueError, IndexError):
+            return "Usage: checklistapprove <checkin_id>"
+    
+    elif message_lower.startswith("checklistdeny "):
+        try:
+            checkin_id = int(parts[1])
+            return deny_checkin(checkin_id)
+        except (ValueError, IndexError):
+            return "Usage: checklistdeny <checkin_id>"
+    
+    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")
+                    "checkin [interval] [note]\n"
+                    "checkout [note]\n"
+                    "purgein - delete your checkin\n"
+                    "purgeout - delete your checkout\n"
+                    "checklistapprove <id> - approve checkin\n"
+                    "checklistdeny <id> - deny checkin\n"
+                    "Example: checkin 60 Hunting in tree stand")
         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():
+                    "checkout [interval] [note]\n"
+                    "checkin [note]\n"
+                    "purgeout - delete your checkout\n"
+                    "purgein - delete your checkin\n"
+                    "Example: checkout 60 Leaving park")
+    
+    elif "checklist" in message_lower:
         return list_checkin()
+    
     else:
-        return "Invalid command."
+        return "Invalid command."
+
+def mark_checkin_removed_by_name(name):
+    conn = sqlite3.connect(checklist_db)
+    c = conn.cursor()
+    c.execute("UPDATE checkin SET removed = 1 WHERE checkin_name = ?", (name,))
+    affected = c.rowcount
+    conn.commit()
+    conn.close()
+    return f"Marked {affected} check-in(s) as removed for {name}."
+
+def mark_checkout_removed_by_name(name):
+    conn = sqlite3.connect(checklist_db)
+    c = conn.cursor()
+    c.execute("UPDATE checkout SET removed = 1 WHERE checkout_name = ?", (name,))
+    affected = c.rowcount
+    conn.commit()
+    conn.close()
+    return f"Marked {affected} checkout(s) as removed for {name}."

modules/dxspot.py

@@ -0,0 +1,202 @@
+# meshing-around modules/dxspot.py - Handles DX Spotter integration
+# Fetches DX spots from Spothole API based on user commands
+# 2025 K7MHI Kelly Keeton
+import requests
+import datetime
+from modules.log import logger
+from modules.settings import latitudeValue, longitudeValue
+
+trap_list_dxspotter = ["dx"]
+
+def handledxcluster(message, nodeID, deviceID):
+    from modules.dxspot import get_spothole_spots
+    if "DX" in message.upper():
+        logger.debug(f"System: DXSpotter: Device:{deviceID} Handler: DX Spot Request Received from Node {nodeID}")
+        band = None
+        mode = None
+        source = None
+        dx_call = None
+        parts = message.split()
+        for part in parts:
+            if part.lower().startswith("band="):
+                band = part.split("=")[1]
+            elif part.lower().startswith("mode="):
+                mode = part.split("=")[1]
+            elif part.lower().startswith("ota="):
+                source = part.split("=")[1]
+            elif part.lower().startswith("of="):
+                dx_call = part.split("=")[1]
+        # Build params dict
+        params = {}
+        if source:
+            params["source"] = source.upper()
+        if band:
+            params["band"] = band.lower()
+        if mode:
+            params["mode"] = mode.upper()
+        if dx_call:
+            params["dx_call"] = dx_call.upper()
+
+        # Fetch spots
+        spots = get_spothole_spots(**params)
+        if spots:
+            response_lines = []
+            for spot in spots[:5]:
+                callsign = spot.get('dx_call', spot.get('callsign', 'N/A'))
+                freq_hz = spot.get('freq', spot.get('frequency', None))
+                frequency = f"{float(freq_hz)/1e6:.3f} MHz" if freq_hz else "N/A"
+                mode_val = spot.get('mode', 'N/A')
+                comment = spot.get('comment', '')
+                if len(comment) > 111: # Truncate comment to 111 chars
+                    comment = comment[:111] + '...'
+                sig = spot.get('sig', '')
+                de_grid = spot.get('de_grid', '')
+                de_call = spot.get('de_call', '')
+                sig_ref_name = spot.get('sig_refs_names', [''])[0] if spot.get('sig_refs_names') else ''
+                line = f"{callsign} @{frequency} {mode_val} {sig} {sig_ref_name} by:{de_call} {de_grid} {comment}"
+                response_lines.append(line)
+            response = "\n".join(response_lines)
+        else:
+            response = "No DX spots found."
+        return response
+    return "Error: No DX command found."
+
+def get_spothole_spots(source=None, band=None, mode=None, date=None, dx_call=None, de_continent=None, de_location=None):
+    """
+    Fetches spots from https://spothole.app/api/v1/spots with optional filters.
+    Returns a list of spot dicts.
+    """
+    url = "https://spothole.app/api/v1/spots"
+    params = {}
+    fetched_count = 0
+    
+
+    # Add administrative filters if provided
+    qrt = False  # Always fetch active spots
+    needs_sig = False # Always need spots wth a group ike Xota
+    limit = 4
+    dedupe = True
+
+    params["dedupe"] = str(dedupe).lower()
+    params["limit"] = limit
+    params["qrt"] = str(qrt).lower()
+    params["needs_sig"] = str(needs_sig).lower()
+    params["needs_sig_ref"] = 'true'
+    # Only get spots from last 9 hours
+    received_since_dt = datetime.datetime.utcnow() - datetime.timedelta(hours=9)
+    received_since = int(received_since_dt.timestamp())
+    params["received_since"] = received_since
+    
+    # Add spot filters if provided
+    if source:
+        params["source"] = source
+    if band:
+        params["band"] = band
+    if mode:
+        params["mode"] = mode
+    if date:
+        # date should be a string in YYYY-MM-DD or datetime.date
+        if isinstance(date, datetime.date):
+            params["date"] = date.isoformat()
+        else:
+            params["date"] = date
+    
+    try:
+        headers = {"User-Agent": "meshing-around-dxspotter/1.0"}
+        response = requests.get(url, params=params, headers=headers)
+        response.raise_for_status()
+        spots = response.json()
+    except Exception as e:
+        logger.debug(f"Error fetching spots: {e}")
+        spots = []
+
+    fetched_count = len(spots)
+
+    # Admin Filters done via config.ini
+    de_grid = None  # e.g., "EM00"
+    de_dxcc_id = None  # e.g., "291"
+    de_call = None  # e.g., "K7MHI"
+
+    dx_itu_zone = None  # e.g., "3"
+    dx_cq_zone = None  # e.g., "4"
+    dx_dxcc_id = None  # e.g., "291"
+
+    # spotter filters
+
+    # location filter
+    de_latitude = None  # e.g., 34.05
+    de_longitude = None  # e.g., -118.25
+    if de_location:
+        de_latitude, de_longitude = de_location
+    elif de_latitude is not None and de_longitude is not None:
+        de_latitude = latitudeValue
+        de_longitude = longitudeValue
+    if de_latitude and de_longitude:
+        lat_range = (de_latitude - 1.0, de_latitude + 1.0)
+        lon_range = (de_longitude - 1.0, de_longitude + 1.0)
+        spots = [spot for spot in spots if lat_range[0] <= spot.get('de_latitude', 0) <= lat_range[1] and
+                 lon_range[0] <= spot.get('de_longitude', 0) <= lon_range[1]]
+    # grid filter
+    if de_grid:
+        spots = [spot for spot in spots if spot.get('de_grid', '').upper() == de_grid.upper()]
+    # DXCC Filters
+    if de_dxcc_id:
+        spots = [spot for spot in spots if str(spot.get('de_dxcc_id', '')) == str(de_dxcc_id)]
+    # By reporting callsign
+    if de_call:
+        spots = [spot for spot in spots if spot.get('de_call', '').upper() == de_call.upper()]
+    # DX spotted in zone
+    if dx_itu_zone:
+        spots = [spot for spot in spots if str(spot.get('dx_itu_zone', '')) == str(dx_itu_zone)]
+    if dx_cq_zone:
+        spots = [spot for spot in spots if str(spot.get('dx_cq_zone', '')) == str(dx_cq_zone)]
+    if dx_dxcc_id:
+        spots = [spot for spot in spots if str(spot.get('dx_dxcc_id', '')) == str(dx_dxcc_id)]
+
+    # User Runtime Filters
+
+    # Filter by dx_call if provided
+    if dx_call:
+        spots = [spot for spot in spots if spot.get('dx_call', '').upper() == dx_call.upper()]
+
+    # Filter by de_continent if provided
+    if de_continent:
+        spots = [spot for spot in spots if spot.get('de_continent', '').upper() == de_continent.upper()]
+
+    # Filter by de_location if provided
+    if de_location:
+        spots = [spot for spot in spots if spot.get('de_location', '').upper() == de_location.upper()]
+    logger.debug(f"System: Spothole Returning {len(spots)} spots after filtering (fetched {fetched_count})")
+    return spots
+
+def handle_post_dxspot():
+    time = int(datetime.datetime.utcnow().timestamp())
+    freq = 14200000  # 14 MHz
+    comment = "Test spot please ignore"
+    de_spot = "N0CALL"
+    dx_spot = "N0CALL"
+    spot = {"dx_call": dx_spot, "time": time, "freq": freq, "comment": comment, "de_call": de_spot}
+    try:
+        success = post_spothole_spot(spot)
+        if success:
+            return "Spot posted successfully."
+        else:
+            return "Failed to post spot."
+    except Exception as e:
+        logger.debug(f"Error in handle_post_dxspot: {e}")
+        return "Error occurred while posting spot."
+
+def post_spothole_spot(spot):
+    """
+    Posts a new spot to https://spothole.app/api/v1/spot.
+    """
+    url = "https://spothole.app/api/v1/spot"
+    headers = {"Content-Type": "application/json", "User-Agent": "meshing-around-dxspotter/1.0"}
+    try:
+        response = requests.post(url, json=spot, headers=headers, timeout=10)
+        response.raise_for_status()
+        logger.debug(f"Spot posted successfully: {response.json()}")
+        return True
+    except Exception as e:
+        logger.debug(f"Error posting spot: {e}")
+        return False

modules/filemon.py

@@ -1,11 +1,22 @@
 # File monitor module for the meshing-around bot
 # 2024 Kelly Keeton K7MHI
 
-from modules.log import *
+from modules.log import logger
+from modules.settings import (
+    file_monitor_file_path,
+    news_file_path,
+    news_random_line_only,
+    allowXcmd,
+    bbs_admin_list,
+    xCmd2factorEnabled,
+    xCmd2factor_timeout,
+    enable_runShellCmd
+    )
 import asyncio
 import random
 import os
 import subprocess
+from datetime import datetime, timedelta
 
 trap_list_filemon = ("readnews",)
 
@@ -69,28 +80,33 @@ async def watch_file():
                     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
+def call_external_script(message, script="runShell.sh"):
+    # If no path is given, assume script/ directory
+    if "/" not in script and "\\" not in script:
+        script = os.path.join("script", script)
     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
+            # 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
         )
+        if result.returncode != 0:
+            logger.error(f"FileMon: Script error: {result.stderr.strip()}")
+            return None
+
         output = result.stdout.strip()
-        return output
+        return output if output else None
     except Exception as e:
         logger.warning(f"FileMon: Error calling external script: {e}")
         return None
@@ -172,6 +188,9 @@ def initNewsSources():
         if file.endswith('_news.txt'):
             source = file[:-9]  # remove _news.txt
             newsSourcesList.append(source)
+            return True
+    logger.info("FileMon: No news sources found")
+    return False
 
 #initialize the headlines on startup
 initNewsSources()

modules/games/README.md

@@ -0,0 +1,721 @@
+# Meshtastic Mesh-Bot Games
+
+## Game Index
+
+- [Blackjack](#blackjack-game-module)
+- [DopeWars](#dopewars-game-module)
+- [GolfSim](#golfsim-game-module)
+- [Lemonade Stand](#lemonade-stand-game-module)
+- [Tic-Tac-Toe](#tic-tac-toe-game-module)
+- [MasterMind](#mastermind-game-module)
+- [Video Poker](#video-poker-game-module)
+- [Hangman](#hangman-game-module)
+- [Quiz](#quiz-game-module)
+- [Survey](#survey--module-game)
+- [Word of the Day Game](#word-of-the-day-game--rules--features)
+---
+
+
+# Blackjack Game Module
+
+This module implements a classic game of Blackjack (Casino 21) for the Meshtastic mesh-bot.
+
+## How to Play
+
+- **Start the Game:**  
+  Send the command `blackjack` via DM to the bot to start a new game session.
+- **Place a Bet:**  
+  When prompted, enter the amount you wish to wager (e.g., `5`). Minimum bet is 1 chip, maximum is your current chip total.
+- **Gameplay Commands:**  
+  After betting, you will be dealt two cards. The dealer will also have two cards (one face up).
+  - `h` or `hit` — Draw another card.
+  - `s` or `stand` — End your turn and let the dealer play.
+  - `d` or `double` — Double your bet and draw one more card (if you have enough chips).
+  - `f` or `forfit` — Forfeit half your bet and end the round.
+  - `r` or `resend` — Resend your current hand status.
+  - `l` or `leave` — Leave the table and end your session.
+
+- **Winning:**  
+  - Get as close to 21 as possible without going over.
+  - If your hand exceeds 21, you bust and lose your bet.
+  - If you beat the dealer without busting, you win your bet.
+  - If you get a Blackjack (21 with two cards), you win 1.5x your bet.
+  - If you tie the dealer, it's a push (no win/loss).
+
+- **High Scores:**  
+  The module tracks the highest chip total achieved. If you beat the high score, you'll be notified!
+
+## Notes
+
+- Each player starts with 100 chips.
+- If you run out of chips, your balance will reset to 100.
+- The game state is tracked per player using your node ID.
+- Game progress and high scores are saved in `data/blackjack_hs.pkl`.
+- Only one game session per player is supported at a time.
+- For best results, play via DM to avoid interfering with other users' sessions.
+
+## Example Session
+
+```
+You have 100 chips.   Whats your bet?
+> 10
+
+Player[14] 8♠️, 6♥️  
+Dealer[10] 10♦️ 
+🧠Hit: 38% 👎, 62% 👍
+(H)it,(S)tand,(F)orfit,(D)ouble,(R)esend,(L)eave table
+> h
+
+Player[18] 8♠️, 6♥️, 4♣️  
+Dealer[10] 10♦️ 
+🧠Hit: 77% 👎, 23% 👍
+[H,S,F,D]
+> s
+
+Player[18] 8♠️, 6♥️, 4♣️  
+Dealer[20] 10♦️, Q♠️
+👎DEALER WINS
+📊🏆P:0,D:1,T:0
+💰You have 90 chips 
+Bet or Leave?
+```
+
+## Credits
+
+- Ported from [Himan10/BlackJack](https://github.com/Himan10/BlackJack)
+- Adapted for Meshtastic mesh-bot by K7MHI Kelly Keeton 2024
+
+# DopeWars Game Module
+
+A text-based trading game inspired by the classic DopeWars/DrugWars, adapted for the Meshtastic mesh-bot.
+
+## How to Play
+
+- **Start the Game:**  
+  Send the command `dopewars` via DM to the bot to begin a new session.
+
+- **Objective:**  
+  Travel between cities, buy and sell drugs, and try to maximize your cash in 7 days.
+
+- **Game Flow:**
+  1. **Pick a Starting City:**  
+     You’ll be shown a list of cities. Enter the number to choose your starting location.
+  2. **Each Day:**  
+     - You’ll see drug prices, your inventory, and your cash.
+     - You can buy, sell, or fly to a new city.
+     - Random events may occur (police, market changes, or finding cash/drugs).
+  3. **Commands:**  
+     - **Buy:** `b,drug#,qty#` (e.g., `b,1,10` buys 10 of drug 1)
+     - **Sell:** `s,drug#,qty#` (e.g., `s,2,5` sells 5 of drug 2)
+     - **Max:** Use `m` for max quantity (e.g., `b,1,m`)
+     - **Sell All:** Just `s` to sell everything you have.
+     - **Fly:** `f` to move to a new city (ends the day).
+     - **Price List:** `p` to view current prices and inventory.
+     - **End Game:** `e` to end your run early.
+  4. **Repeat:**  
+     Each time you fly, a day passes. After 7 days, your final cash is your score.
+
+- **Winning:**  
+  - Try to finish with as much cash as possible.
+  - Beat the high score to be crowned the top dealer!
+
+## Example Session
+
+```
+1. Red Deer  2. Edmonton  3. Calgary  4. Toronto  5. Vancouver  6. St. Johns  Where do you want to 🛫?#
+> 2
+
+🗺️Edmonton 📆1/7 🎒0/100 💵5,000
+#1.Cocaine$15,000(0)    #2.Heroin$2,500(0)    #3.Weed$800(0)    ...
+Buy💸, Sell💰, (F)ly🛫? (P)riceList?
+> b,2,10
+
+Heroin: you have🎒 0  The going price is: $2,500 
+You bought 10 Heroin. Remaining cash: $47,500
+Buy💸, Sell💰, Fly🛫?
+> f
+
+🗺️Toronto 📆2/7 🎒10/100 💵47,500
+...
+```
+
+## Notes
+
+- You start with $5,000 and a 100-slot backpack.
+- Each drug has a random price per city and day.
+- Special events can spike or crash prices, or cause you to lose/gain cash or inventory.
+- Police may confiscate your drugs or cash.
+- High scores are saved in `data/dopewar_hs.pkl`.
+- Only one game session per player at a time.
+- Play via DM for best experience.
+
+## Credits
+
+- Ported from [Reconfirefly/drugwars](https://github.com/Reconfirefly/drugwars)
+- Adapted for Meshtastic mesh-bot by K7MHI Kelly Keeton 2024
+
+# GolfSim Game Module
+
+A text-based golf simulator for the Meshtastic mesh-bot. Play a full 9-hole round, choose your clubs, and try to set a new course record!
+
+## How to Play
+
+- **Start the Game:**  
+  Send the command `golf` via DM to the bot to begin a new round.
+
+- **Objective:**  
+  Complete 9 holes in as few strokes as possible.
+
+- **Game Flow:**
+  1. **Each Hole:**  
+     - The bot tells you the hole number, length, par, and any hazards or weather.
+     - Choose your club for each shot by typing its name or initial:
+       - `d` or `driver` — Longest club
+       - `l` or `low` — Low iron
+       - `m` or `mid` — Mid iron
+       - `h` or `high` — High iron
+       - `g` or `gap` — Gap wedge
+       - `w` or `wedge` — Lob wedge
+       - `c` or `caddy` — Get a caddy guess for club distances
+     - The bot will tell you how far you hit and how far remains.
+     - When you’re within 20 yards, you’ll automatically putt to finish the hole.
+  2. **Scoring:**  
+     - The bot tracks your strokes and score relative to par.
+     - After each hole, you’ll see your score for the hole and your running total.
+  3. **Hazards & Surprises:**  
+     - Hazards (sand, water, trees, etc.) and random events may affect your shots.
+     - Critters or weather can cause unexpected results!
+  4. **End of Round:**  
+     - After 9 holes, your total strokes and score to par are shown.
+     - If you set a new low score, you’ll be notified as the new club record holder!
+
+## Example Session
+
+```
+⛳️#1 is a 410-yard Par 4.☀️
+Choose your club.
+> d
+🏌️Hit D 260yd. 
+You have 150yd. ⛳️
+Club?[D, L, M, H, G, W]🏌️
+> m
+🏌️Hit M Iron 170yd. Overshot the green!🚀
+You have 20yd. ⛳️
+Club?[D, L, M, H, G, W]🏌️
+> w
+🏌️Hit L Wedge 30yd. You're on the green! After 2 putt(s), you're in for 5 strokes. +Bogey 
+You've hit a total of 5 strokes today, for +Bogey 
+...
+🎉Finished 9-hole round⛳️ 🏆New Club Record🏆
+```
+
+## Notes
+
+- Play via DM for best experience.
+- Hazards and weather are randomized for each hole.
+- High scores are saved in `data/golfsim_hs.pkl`.
+- Only one game session per player at a time.
+- Commands are not case-sensitive; you can use full club names or initials.
+
+## Credits
+
+- Ported from [danfriedman30/pythongame](https://github.com/danfriedman30/pythongame)
+- Adapted for Meshtastic mesh-bot by K7MHI Kelly Keeton 2024
+
+# Lemonade Stand Game Module
+
+A text-based business simulation where you run your own lemonade stand! Buy supplies, set prices, and try to maximize your profits over a summer season.
+
+## How to Play
+
+- **Start the Game:**  
+  Send the command `lemonade` via DM to the bot to begin a new game.
+
+- **Objective:**  
+  Make as much money as possible in 7 weeks by managing your lemonade stand.
+
+- **Game Flow:**
+  1. **Each Week:**  
+     - The bot will show you the weather, temperature, and sales potential.
+     - Buy supplies: cups, lemons, and sugar. Enter the number of each to purchase, or `n` for none.
+     - Set your selling price per cup.
+     - The bot will simulate sales and show your results, profits, and remaining inventory.
+     - Repeat for each week.
+  2. **Commands:**  
+     - Enter a number to buy supplies or set price.
+     - Use `n` to skip buying an item.
+     - Enter `g` during pricing to go back and buy more supplies.
+     - At the end of each week, choose to continue or end the game.
+  3. **Scoring:**  
+     - Your score is based on your net profit and efficiency (profit vs. possible profit).
+     - High scores are tracked and displayed at the end of the game.
+
+## Example Session
+
+```
+LemonStand🍋Week #1 of 7. 85ºF Sunny ☀️
+SupplyCost $0.45 a cup.
+Sales Potential: 60 cups.
+Inventory: 🥤:0 🍋:0 🍚:0
+Prices:
+🥤:$2.50 📦 of 25.
+🍋:$4.00 🧺 of 8.
+🍚:$3.00 bag for 15🥤.
+💵:$30.00
+🥤 to buy?
+Have 0 Cost $2.50 a 📦 of 25
+> 2
+
+Purchased 2 📦 50 🥤  in inventory. $25.00 remaining
+🍋 to buy?
+Have 0🥤 of 🍋 Cost $4.00 a 🧺 for 8🥤
+> 1
+
+Purchased 1 🧺 8 🍋  in inventory. $21.00 remaining
+🍚 to buy?
+You have 0🥤 of 🍚, Cost $3.00 a bag for 15🥤
+> 1
+
+Purchased 1 bag(s) of 🍚 for $3.00. 15🥤🍚 in inventory.
+Cost of goods is $0.45 per 🥤 $18.00 💵 remaining.
+Price to Sell? or (G)rocery to buy more 🥤🍋🍚
+> 1.25
+
+Results Week📊#1 of 7 Cost/Price:$0.45/$1.25 P.Margin:$0.80 T.Sales:16@$1.25 G.Profit: $20.00 N.Profit:$12.80
+Remaining 🥤:34 🍋:0 🍚:0 💵:$38.00📊P&L📈$8.00
+Weekly📊#1.  16 sold x $1.25ea.
+Play another week🥤? or (E)nd Game
+```
+
+## Notes
+
+- You start with $30.00 and must buy supplies each week.
+- Weather and temperature affect sales potential.
+- If you run out of any supply, you can't sell more lemonade that week.
+- High scores are saved in `data/lemonstand.pkl`.
+- Only one game session per player at a time.
+- Play via DM for best experience.
+
+## Credits
+
+- Ported from [tigerpointe/Lemonade-Stand](https://github.com/tigerpointe/Lemonade-Stand)
+- Adapted for Meshtastic mesh-bot by K7MHI Kelly Keeton 2024
+
+# Tic-Tac-Toe Game Module
+
+A classic Tic-Tac-Toe game for the Meshtastic mesh-bot. Play against the bot, track your stats, and see if you can beat the AI!
+
+## How to Play
+
+- **Start the Game:**  
+  Send the command `tictactoe` via DM to the bot to begin a new game.
+
+- **Objective:**  
+  Get three of your marks in a row (horizontally, vertically, or diagonally) before the bot does.
+
+- **Game Flow:**
+  1. **Board Layout:**  
+     - The board is numbered 1-9, left to right, top to bottom.
+     - Example:
+       ```
+        1 | 2 | 3
+        4 | 5 | 6
+        7 | 8 | 9
+       ```
+  2. **Making Moves:**  
+     - On your turn, type the number (1-9) where you want to place your mark.
+     - The bot will respond with the updated board and make its move.
+  3. **Commands:**  
+     - `n` — Start a new game.
+     - `e` or `q` — End the current game.
+     - `b` — Show the current board.
+     - Enter a number (1-9) to make a move.
+  4. **Winning:**  
+     - The first to get three in a row wins.
+     - If the board fills with no winner, it’s a tie.
+
+## Example Session
+
+```
+❌ | 2 | 3
+4 | ⭕️ | 6
+7 | 8 | 9
+
+Your turn! Pick 1-9:
+> 3
+
+❌ | 2 | ❌
+4 | ⭕️ | 6
+7 | 8 | 9
+
+🤖Bot wins! (n)ew (e)nd
+```
+
+## Notes
+
+- Emojis are used for X and O unless disabled in settings.
+- Your win/loss stats are tracked across games.
+- The bot will try to win, block you, or pick a random move.
+- Play via DM for best experience.
+- Only one game session per player at a time.
+
+## Credits
+
+- Written for Meshtastic mesh-bot by Martin
+
+# MasterMind Game Module
+
+A text-based version of the classic code-breaking game MasterMind for the Meshtastic mesh-bot. Try to guess the secret color code in as few turns as possible!
+
+## How to Play
+
+- **Start the Game:**  
+  Send the command `mmind` via DM to the bot to begin a new game.
+
+- **Objective:**  
+  Guess the secret 4-color code in 10 turns or less.
+
+- **Game Flow:**
+  1. **Choose Difficulty:**  
+     - (N)ormal: 4 colors (R🔴, Y🟡, G🟢, B🔵)
+     - (H)ard: 6 colors (R🔴, Y🟡, G🟢, B🔵, O🟠, P🟣)
+     - e(X)pert: 8 colors (R🔴, Y🟡, G🟢, B🔵, O🟠, P🟣, W⚪, K⚫)
+     - Type `n`, `h`, or `x` to select.
+  2. **Guessing:**  
+     - Enter a 4-letter code using the color initials (e.g., `RGBY`).
+     - The bot will respond with feedback:
+       - ✅ color ✅ position: correct color in the correct spot
+       - ✅ color 🚫 position: correct color, wrong spot
+       - 🚫No pins: none of your colors are in the code
+     - You have 10 turns to guess the code.
+  3. **Winning:**  
+     - Guess the code exactly to win!
+     - Your number of turns is tracked for high scores.
+     - After a win or loss, you can play again by choosing a difficulty.
+
+## Example Session
+
+```
+The colors to choose from are:
+R🔴, Y🟡, G🟢, B🔵
+Enter your guess (e.g., RGBY):
+> RGYB
+
+Turn 1:
+Guess🔴🟢🟡🔵
+✅ color ✅ position: 2
+✅ color 🚫 position: 1
+
+> RYGB
+
+Turn 2:
+🏆Correct🔴🟡🟢🔵
+You are the master mind!🤯
+🏆 High Score:2 turns, Difficulty:n
+Would you like to play again? (N)ormal, (H)ard, or e(X)pert?
+```
+
+## Notes
+
+- Only one game session per player at a time.
+- High scores are saved in `data/mmind_hs.pkl`.
+- Play via DM for best experience.
+- Input is not case-sensitive, but guesses must be exactly 4 letters.
+
+## Credits
+
+- Ported from [pwdkramer/pythonMastermind](https://github.com/pwdkramer/pythonMastermind)
+- Adapted for Meshtastic mesh-bot by K7MHI Kelly Keeton 2024
+
+# Video Poker Game Module
+
+A text-based Video Poker game for the Meshtastic mesh-bot. Play classic five-card draw poker, place your bets, and try to build your bankroll!
+
+## How to Play
+
+- **Start the Game:**  
+  Send the command `videopoker` via DM to the bot to begin a new session.
+
+- **Objective:**  
+  Win as many coins as possible by making the best poker hands.
+
+- **Game Flow:**
+  1. **Place Your Bet:**  
+     - You start with 20 coins.
+     - Enter your bet (1-5 coins) to begin each hand.
+  2. **Draw Cards:**  
+     - You are dealt 5 cards.
+     - The bot will show your hand and a hint about its strength.
+  3. **Redraw:**  
+     - Choose which cards to replace:
+       - Enter numbers (e.g., `1,3,4`) to redraw those cards.
+       - Enter `a` to redraw all cards.
+       - Enter `n` to keep your current hand.
+       - Enter `h` to show your hand again.
+     - You can only redraw once per hand.
+  4. **Scoring:**  
+     - After the redraw, your hand is scored and winnings are paid out based on the hand type.
+     - If you run out of coins, your balance resets to 20.
+     - High scores are tracked and announced.
+  5. **Continue:**  
+     - Place another bet to play again, or enter `l` to leave the table.
+
+## Example Session
+
+```
+You have 20 coins, 
+Whats your bet?
+> 5
+
+K♠️ 7♦️ 7♣️ 2♥️ 9♠️ 
+Showing:Pair👯
+Deal new card? 
+ex: 1,3,4 or (N)o,(A)ll (H)and
+> 1,4
+
+7♦️ 7♣️ 9♠️ 3♣️ Q♥️ 
+Your hand, Pair👯. Your bankroll is now 22 coins.
+Place your Bet, or (L)eave Table.
+```
+
+## Hand Rankings & Payouts
+
+- 👑Royal Flush🚽 — 10x bet
+- 🧻Straight Flush🚽 — 9x bet
+- Flush🚽 — 8x bet
+- Full House🏠 — 7x bet
+- Four of a Kind👯👯 — 6x bet
+- Three of a Kind☘️ — 5x bet
+- Two Pair👯👯 — 4x bet
+- Straight📏 — 3x bet
+- Pair👯 — 2x bet
+- Bad Hand 🙈 — Lose bet
+
+## Notes
+
+- Only one game session per player at a time.
+- High scores are saved in `data/videopoker_hs.pkl`.
+- Play via DM for best experience.
+- Bets must be between 1 and 5 coins and not exceed your bankroll.
+
+## Credits
+
+- Ported from [devtronvarma/Video-Poker-Terminal-Game](https://github.com/devtronvarma/Video-Poker-Terminal-Game)
+- Adapted for Meshtastic mesh-bot by K7MHI Kelly Keeton 2024
+
+
+# Word of the Day Game — Rules & Features
+
+- **Word of the Day:**  
+  Each day, a new word is chosen from `data/wotd.json` (or a default list if missing). Mention the word (or its leet/1337 variants) in chat to win and trigger a new word.
+- **Bingo Mini-Game:**  
+  A random 3x3 bingo card of words, drawn from `data/bingo.json` (or a default list if missing). Mention words from the card in chat. Complete a row, column, or diagonal to win BINGO and get a new card.
+- **Emoji Mini-Game:**  
+  Use emojis in chat to:
+  - Play a slot machine: send the same emoji several times in a row to hit the JACKPOT!
+- **Data Files:**
+  - `data/wotd.json`: List of words and definitions for the Word of the Day.
+[
+  {
+    "word": "serendipity",
+    "meta": "The occurrence of events by chance in a happy or beneficial way."
+  },
+  {
+    "word": "ephemeral",
+    "meta": "Lasting for a very short time."
+  },
+  {
+    "word": "sonder",
+    "meta": "The realization that each passerby has a life as vivid and complex as your own."
+  }
+]
+  - `data/bingo.json`: List of words for bingo cards.  
+[
+  "dog",
+  "cat",
+  "fish",
+  "bird",
+  "hamster",
+  "rabbit",
+  "turtle",
+  "lizard",
+  "snake"
+]
+
+# Hangman Game Module
+
+A classic word-guessing game for the Meshtastic mesh-bot. Try to guess the hidden word one letter at a time before you run out of chances!
+
+## How to Play
+
+- **Start the Game:**  
+  Send the command `hangman` via DM to the bot to begin a new game.
+
+- **Objective:**  
+  Guess the secret word by suggesting letters, one at a time. Each incorrect guess brings you closer to losing!
+
+- **Game Flow:**
+  1. **New Game:**  
+     - The bot picks a random word and shows you its masked form (e.g., `_ _ _ _ _`).
+     - You’ll see your total games played and games won.
+  2. **Guessing:**  
+     - Type a single letter to guess.
+     - Correct guesses reveal all instances of that letter in the word.
+     - Incorrect guesses are tracked; you have 6 chances before the game ends.
+     - The bot shows your progress, wrong guesses, and a hangman emoji status.
+  3. **Winning & Losing:**  
+     - Guess all letters before reaching 6 wrong guesses to win!
+     - If you lose, the bot reveals the word and starts a new game.
+
+- **Commands:**  
+  - Enter a single letter to guess.
+  - Start a new game by sending `hangman` again.
+
+## Example Session
+
+```
+_ _ _ _ _ _ _ 
+Guess a letter
+
+
+🥳
+Total Games: 1, Won: 1
+M E S H T A S T I C
+Guess a letter
+```
+
+## Notes
+
+- The word list is loaded from `data/hangman.json` if available, or uses a built-in default list. [\"apple\",\"banana\",\"cherry\"]
+- Game stats are tracked per player.
+- Only one game session per player at a time.
+- Play via DM for best experience.
+
+## Data Files
+
+- `data/hangman.json`: List of words for Hangman.  
+  Example:
+  ```
+  [
+    "apple",
+    "banana",
+    "cherry"
+  ]
+  ```
+
+## Credits
+
+- Written for Meshtastic mesh-bot by ZR1RF Johannes le Roux 2025
+
+# Quiz Game Module
+
+This module implements a multiplayer quiz game for the Meshtastic mesh-bot.
+
+## How to Play
+
+- **Start the Game:**  
+  The quizmaster starts the quiz session (usually with `/quiz start` or similar command).
+- **Join the Game:**  
+  Players join by sending `/quiz join` or by answering a question while a quiz is active.
+- **Answer Questions:**  
+  - Use `Q: <answer>` to answer the current question.  
+    - For multiple choice, answer with `A`, `B`, `C`, etc.
+    - For free-text, type the answer after `Q: `.
+  - Use `Q: ?` to request the next question.
+- **Leave the Game:**  
+  Players can leave at any time with `/quiz leave`.
+- **Stop the Game:**  
+  The quizmaster stops the quiz session (e.g., `/quiz stop`). Final scores and the top 3 players are announced.
+
+## Rules & Features
+
+- Only the quizmaster can start or stop the quiz.
+- Players can join or leave at any time while the quiz is active.
+- Questions are loaded from quiz_questions.json and can be multiple choice or free-text.
+- Players earn 1 point for each correct answer.
+- The first player to answer each question correctly is noted.
+- The top 3 players are displayed at the end of the quiz.
+- The quizmaster can broadcast messages to all players.
+
+## Example Commands
+
+- Start quiz:  
+  `/quiz start`
+- Join quiz:  
+  `/quiz join`
+- Answer a question:  
+  `Q: B`  
+  `Q: Paris`
+- Next question:  
+  `Q: ?`
+- Leave quiz:  
+  `/quiz leave`
+- Stop quiz:  
+  `/quiz stop`
+
+## Notes
+
+- Only one quiz can be active at a time.
+- Players can only answer each question once.
+- The quizmaster is defined by the `bbs_admin_list` variable.
+- Questions must be formatted correctly in the JSON file for the game to function.
+
+---
+
+**Written for Meshtastic mesh-bot by K7MHI Kelly Keeton 2025**
+
+Certainly! Here’s documentation for the **Survey Game Module** in the same format as your other game modules:
+
+---
+
+# Survey  Module "game"
+This module implements a survey system for the Meshtastic mesh-bot.
+
+## How to Play
+
+- **Start the Survey:**  
+  Users start a survey by specifying the survey name (e.g., `/survey start example`).  
+  The survey will prompt the user with the first question.
+
+- **Answer Questions:**  
+  - For multiple choice: reply with a letter (A, B, C, ...).
+  - For integer: reply with a number.
+  - For text: reply with your answer as text.
+  After each answer, the next question is shown automatically.
+
+- **End the Survey:**  
+  The survey ends automatically after the last question, or the user can send `end` to finish early.  
+  Responses are saved to a CSV file.
+
+## Rules & Features
+
+- Surveys are defined in JSON files in surveys (e.g., `example_survey.json`).
+- Each survey can have multiple choice, integer, or text questions.
+- User responses are saved to a CSV file named `<survey_name>_responses.csv` in the same directory.
+- Users can only answer each question once per survey session.
+- Survey results can be summarized and reported by the bot.
+
+## Example Commands
+
+- Start a survey:  
+  `/survey start example`
+- Answer a multiple choice question:  
+  `A`
+- Answer an integer question:  
+  `42`
+- Answer a text question:  
+  `My favorite color is blue.`
+- End the survey early:  
+  `end`
+- Get survey results (admin):  
+  `/survey results example`
+
+## Notes
+
+- Only surveys listed in the surveys directory with the `_survey.json` suffix are available.
+- Each user’s responses are tracked separately.
+- Results are summarized and can be displayed by the bot.
+
+---
+
+**Written for Meshtastic mesh-bot by K7MHI Kelly Keeton 2025**

modules/games/blackjack.py

@@ -2,12 +2,12 @@
 # Adapted for Meshtastic mesh-bot by K7MHI Kelly Keeton 2024
 
 from random import choices, shuffle
-from modules.log import *
+from modules.log import logger
+from modules.settings import jackTracker
 import time
 import pickle
 
 jack_starting_cash = 100  # Replace 100 with your desired starting cash value
-from modules.settings import jackTracker
 
 SUITS = ("♥️", "♦️", "♠️", "♣️")
 RANKS = (
@@ -297,7 +297,7 @@ def playBlackJack(nodeID, message, last_cmd=None):
                 #resend the hand
                 msg += show_some(p_cards, d_cards, p_hand)
                 return msg
-            elif message.lower() == "blackjack":
+            elif "blackjack" in message.lower():
                 return f"\nTo place a bet, enter the amount you wish to wager."
             else:
                 try:

modules/games/dopewar.py

@@ -4,7 +4,7 @@
 import random
 import time
 import pickle
-from modules.log import *
+from modules.log import logger
 
 # Global variables
 total_days = 7 # number of days or rotations the player has to play

modules/games/golfsim.py

@@ -4,7 +4,7 @@
 import random
 import time
 import pickle
-from modules.log import *
+from modules.log import logger
 
 # Clubs setup
 driver_distances = list(range(230, 280, 5))

modules/games/hamtest.py

@@ -9,7 +9,7 @@
 import json
 import random
 import os
-from modules.log import *
+from modules.log import logger
 
 class HamTest:
     def __init__(self):

modules/games/hangman.py

@@ -1,4 +1,7 @@
 # Written for Meshtastic mesh-bot by ZR1RF Johannes le Roux 2025
+from modules.log import logger, getPrettyTime
+import os
+import json
 import random
 
 class Hangman:
@@ -118,6 +121,25 @@ class Hangman:
 
     def __init__(self):
         self.game = {}
+        self.DEFAULT_WORDS = self.WORDS
+        
+
+        # Try to load hangman.json if it exists
+        hangman_json_path = os.path.join('data', 'hangman.json')
+        if os.path.exists(hangman_json_path):
+            try:
+                with open(hangman_json_path, 'r') as f:
+                    words = json.load(f)
+                # Ensure it's a list of strings
+                if isinstance(words, list) and all(isinstance(w, str) for w in words):
+                    self.WORDS = words
+                else:
+                    self.WORDS = self.DEFAULT_WORDS
+            except (FileNotFoundError, json.JSONDecodeError):
+                logger.warning("Failed to load hangman.json, using default words. example JSON: [\"apple\",\"banana\",\"cherry\"]")
+                self.WORDS = self.DEFAULT_WORDS
+        else:
+            self.WORDS = self.DEFAULT_WORDS
 
     def new_game(self, id):
         games = won = 0

modules/games/joke.py

@@ -3,7 +3,8 @@
 # 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 *
+from modules.log import logger, getPrettyTime
+from modules.settings import dad_jokes_emojiJokes, dad_jokes_enabled
 
 lameJokes = [
     "Why don't scientists trust atoms? Because they make up everything!",
@@ -46,15 +47,27 @@ lameJokes = [
     "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."]
+    "This is a test. A test of the Joke Brodcast System. If this had been an actual joke, you would have been amused.",
+    "Chuck Norris doesn't join mesh networks. Mesh networks join Chuck's topology.",
+    "Every time Chuck Norris sends a packet, it arrives before he hits 'send'",
+    "Chuck Norris doesn't need LoRa. His roundhouse kick has a 15km range with zero latency.",
+    "When Chuck Norris uses a node, the bandwidth doubles out of fear.",
+    "Chuck Norris once pinged a device. It replied with an apology and a firmware update.",
+    "Chuck Norris doesn't use AES encryption. His packets are so secure, they punch hackers in the bits.",
+    "The Meshtastic protocol has a hidden mode: “Chuck Norris mode.” It only activates when he blinks.",
+    "Chuck Norris doesn't need a GPS fix. Satellites triangulate themselves around him.",
+    "Chuck Norris's mesh node doesn't sleep. It meditates while transmitting at full power.",
+    "Chuck Norris doesn't broadcast. He declares.",
+    "Chuck Norris once bridged two mesh networks using a shoelace.",
+    "Chuck Norris's packets don't hop. They teleport out of respect.",
+    "Chuck Norris doesn't need a repeater. Client_Mute is set to 'Always'.",
+    "Chuck Norris's mesh messages are entangled. When he sends one, it's already received.",
+    "Chuck Norris doesn't mesh with others. Others mesh with Chuck.",
+    "Chuck Norris's node doesn't need a case. The PCB is armored with his beard hair.",
+    "Chuck Norris once typed “Hello World” and the world replied 'Hello Chuck.'",
+]
 
+# pylint: disable=C0103, W0612
 imtellingyourightnowiAmTellingYouRightNowThatMotherfErBackThereIsNotReal = ["🐦", "🦅", "🦆", "🦉", "🦜", "🐤", "🐥", "🐣", "🐔", "🐧", "🦚", "🦢", "🦩", "🦤", "🦃", "🐓"]
 
 def tableOfContents():
@@ -88,8 +101,8 @@ def tableOfContents():
         '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': '🧅',
+        'green apple': '🍏', 'pear': '🍐', 'peach': '🍑', 'cherries': '🍒', 'strawberry': '🍓', 'kiwi': '🥝', 'tomato': '🍅', 'coconut': '🥥', 'avocado': '🥑',
+        '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': '🥗',
@@ -103,19 +116,19 @@ def tableOfContents():
         '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': '💈',
+        'castle': '🏰', 'wedding': '💒', 'tokyo tower': '🗼', 'statue of liberty': '🗽', 'church': '⛪', 'mosque': '🕌',
+        'fountain': '⛲', 'tent': '⛺', 'foggy': '🌁', 'night with stars': '🌃', 'sunrise over mountains': '🌄', 'sunrise': '🌅',
+        'cityscape at dusk': '🌆', 'sunset': '🌇', 'cityscape': '🏙️', 'bridge at night': '🌉', 'hot springs': '♨️', 'carousel horse': '🎠', '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': '💾',
+        'atom': '⚛️', 'dna': '🧬', 'microscope': '🔬', 'telescope': '🔭', 'satellite': '🛰️', 'spaceship': '🛸', 'planet': '🪐', 'black hole': '🕳️', 'galaxy': '🌌',
+        'constellation': '🌠', 'lightning': '⚡', 'magnet': '🧲', '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': '💻',
+        'satellite dish': '📡', 'game controller': '🎮', 'joystick': '🕹️', 'vr headset': '🕶️', 'headphones': '🎧', 'speaker': '🔊', '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': '🦿',
@@ -124,21 +137,18 @@ def tableOfContents():
         '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': '📄',
+        'alpaca': '🦙', 'buffalo': '🐃', 'ox': '🐂', 'deer': '🦌', 'moose': '🦌', 'reindeer': '🦌', 'goat': '🐐', 'sheep': '🐑', 'ram': '🐏', 'lamb': '🐑', 'horse': '🐴', 
+        'rat': '🐀', 'hedgehog': '🦔', 'chicken': '🐔', 'rooster': '🐓', 'crocodile': '🐊', 'turtle': '🐢', 'lizard': '🦎', 'dragon': '🐉', 'sauropod': '🦕', 't-rex': '🦖', 'butterfly': '🦋', 
+        'mosquito': '🦟', 'microbe': '🦠', 'locomotive': '🚂', 'arm': '💪', 'leg': '🦵', 'sponge': '🧽',
+        'toothbrush': '🪥', 'roll of paper': '🧻', 'soap': '🧼', 'toilet paper': '🧻', 'shower': '🚿', 'bathtub': '🛁', 'razor': '🪒', 'lotion': '🧴',
+        'letter': '✉️', 'envelope': '✉️', 'mail': '📬', 'post': '📮', 'golf': '⛳️', 'golfing': '⛳️', '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': '⛄️'
+        'league': '🏆', 'season': '🏆', 'playoffs': '🏆', 'finals': '🏆', 'runner-up': '🥈', 'third place': '🥉', 'snowman': '☃️', 'snowmen': '⛄️'
     }
 
     return wordToEmojiMap
@@ -168,14 +178,16 @@ def sendWithEmoji(message):
         i += 1
     return ' '.join(words)
 
-def tell_joke(nodeID=0, vox=False):
+def tell_joke(nodeID=0, vox=False, test=False):
     dadjoke = Dadjoke()
+    if test:
+        return sendWithEmoji(dadjoke.joke)
     try:
-        if dad_jokes_emojiJokes or vox:
+        if dad_jokes_emojiJokes:
             renderedLaugh = sendWithEmoji(dadjoke.joke)
         else:
             renderedLaugh = dadjoke.joke
         return renderedLaugh
     except Exception as e:
         return random.choice(lameJokes)
-        
+

modules/games/lemonade.py

@@ -6,8 +6,8 @@ from random import randrange, uniform # random numbers
 from types import SimpleNamespace     # namespaces support
 import pickle                         # pickle file support
 import time                           # time functions
-from modules.log import *             # mesh-bot logging
-
+from modules.log import logger        # mesh-bot logging
+from modules.system import lemonadeTracker # player tracking
 import locale # culture specific locale
 import math   # math functions
 import re     # regular expressions
@@ -23,7 +23,6 @@ lemonadeLemons = [{'nodeID': 0, 'cost': 4.00, 'count': 8, 'min': 2.00, 'unit': 0
 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, '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.

modules/games/meshtrekker.py

@@ -12,7 +12,7 @@ Game Rules:
 """
 
 import pickle
-from modules.log import *
+from modules.log import logger, getPrettyTime
 from datetime import datetime, timedelta
 from geopy.distance import geodesic
 

modules/games/mmind.py

@@ -4,8 +4,9 @@
 import random
 import time
 import pickle
-from modules.log import *
-from modules.settings import mindTracker
+from modules.log import logger
+from modules.system import mindTracker
+
 def chooseDifficultyMMind(message):
     usrInput = message.lower()
     msg = ''

modules/games/quiz.py

@@ -11,7 +11,8 @@
 import json
 import os
 import random
-from modules.log import *
+from modules.log import logger
+from modules.settings import bbs_admin_list
 
 QUIZ_JSON = os.path.join(os.path.dirname(__file__), '../', '../', 'data', 'quiz_questions.json')
 QUIZMASTER_ID = bbs_admin_list

modules/games/tictactoe.py

@@ -1,13 +1,13 @@
 # Tic-Tac-Toe game for Meshtastic mesh-bot
 # Board positions chosen by numbers 1-9
 # 2025
-from modules.log import *
 import random
 import time
+import modules.settings as my_settings
 
-# to molly and jake, I miss you both so much.
+# to (max), molly and jake, I miss you both so much.
 
-if disable_emojis_in_games:
+if my_settings.disable_emojis_in_games:
     X = "X"
     O = "O"
 else:
@@ -65,7 +65,7 @@ class TicTacToe:
             row = ""
             for j in range(3):
                 pos = i * 3 + j
-                if disable_emojis_in_games:
+                if my_settings.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)} "
@@ -74,7 +74,6 @@ class TicTacToe:
                     row += " | "
             board_str += row
             if i < 2:
-                #board_str += "\n-+-+-\n"
                 board_str += "\n"
         
         return board_str + "\n"

modules/games/videopoker.py

@@ -3,12 +3,12 @@
 import random
 import time
 import pickle
-from modules.log import *
+from modules.log import logger, getPrettyTime
 
 vpStartingCash = 20
-from modules.settings import vpTracker
 # Define the Card class
 class CardVP:
+    global vpTracker
 
     card_values = {  # value of the ace is high until it needs to be low
         2: 2,
@@ -296,154 +296,159 @@ def loadHSVp():
         return 0
 
 def playVideoPoker(nodeID, message):
+    global vpTracker, vpStartingCash
     msg = ""
+    try:
+        # Initialize the player
+        if getLastCmdVp(nodeID) is None or getLastCmdVp(nodeID) == "":
+            # 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"You have {vpStartingCash} coins, \nWhats your bet?"
+        
+        # Gather the player's bet
+        if getLastCmdVp(nodeID) == "new" or getLastCmdVp(nodeID) == "gameOver":
+            # Initialize shuffled Deck and Player
+            player = PlayerVP()
+            deck = DeckVP()
+            deck.shuffle()
+            drawCount = 1
+            bet = 0
+            msg = ''
 
-    # Initialize the player
-    if getLastCmdVp(nodeID) is None or getLastCmdVp(nodeID=nodeID) == "":
-        # 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"You have {vpStartingCash} coins, \nWhats your bet?"
-    
-    # Gather the player's bet
-    if getLastCmdVp(nodeID) == "new" or getLastCmdVp(nodeID) == "gameOver":
-        # Initialize shuffled Deck and Player
-        player = PlayerVP()
-        deck = DeckVP()
-        deck.shuffle()
-        drawCount = 1
-        bet = 0
-        msg = ''
-
-        # load the player bankroll from tracker
-        for i in range(len(vpTracker)):
-            if vpTracker[i]['nodeID'] == nodeID:
-                player.bankroll = vpTracker[i]['cash']
-                vpTracker[i]['time'] = time.time()
-
-        # Detect if message is a bet
-        try:
-            bet = int(message)
-        except ValueError:
-            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 += 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.🪙"
-        elif bet > 5:
-            msg += "The 🎰 coin slot only fits 5 coins max."
-
-        # if msg contains an error, return it
-        if msg is not None and msg != '':
-            return msg
-        else:
-            # Take the bet
-            player.bet(str(message))
-            # Bet placed, start the game
-            setLastCmdVp(nodeID, "playing")
-
-            # save player and deck to tracker
+            # load the player bankroll from tracker
             for i in range(len(vpTracker)):
                 if vpTracker[i]['nodeID'] == nodeID:
-                    vpTracker[i]['player'] = player
-                    vpTracker[i]['deck'] = deck
-                    vpTracker[i]['cash'] = player.bankroll
+                    player.bankroll = vpTracker[i]['cash']
+                    vpTracker[i]['time'] = time.time()
 
-    # Play the game
-    if getLastCmdVp(nodeID) == "playing":
-        msg = ''
-    
-        player.draw_cards(deck)
-        msg += player.show_hand()
-        # give hint to player
-        msg += player.score_hand(resetHand=False)
-        
-        # save player and deck to tracker
-        for i in range(len(vpTracker)):
-            if vpTracker[i]['nodeID'] == nodeID:
-                vpTracker[i]['player'] = player
-                vpTracker[i]['deck'] = deck
-                vpTracker[i]['drawCount'] = drawCount
+            # Detect if message is a bet
+            try:
+                bet = int(message)
+            except ValueError:
+                msg += f"Please enter a valid bet, 1 to 5 coins. you have {player.bankroll} coins."
 
-        msg += f"\nDeal new card? \nex: 1,3,4 or (N)o,(A)ll (H)and"
-        setLastCmdVp(nodeID, "redraw")
-        return msg
-    
-    if getLastCmdVp(nodeID) == "redraw":
-        msg = ''
-        # load the player and deck from tracker
-        for i in range(len(vpTracker)):
-            if vpTracker[i]['nodeID'] == nodeID:
-                player = vpTracker[i]['player']
-                deck = vpTracker[i]['deck']
-                drawCount  = vpTracker[i]['drawCount']
+            # Check if bet is valid
+            if bet > player.bankroll:
+                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.🪙"
+            elif bet > 5:
+                msg += "The 🎰 coin slot only fits 5 coins max."
+
+            # if msg contains an error, return it
+            if msg is not None and msg != '':
+                return msg
+            else:
+                # Take the bet
+                player.bet(str(message))
+                # Bet placed, start the game
+                setLastCmdVp(nodeID, "playing")
 
-        # if player wants to redraw cards, and not done already
-        if message.lower().startswith("n"):
-            setLastCmdVp(nodeID, "endGame")
-        if message.lower().startswith("h"):
-            msg = player.show_hand()
-            return msg
-        else:
-            if drawCount <= 1:
-                msg = player.redraw(deck, message)
-                if msg.startswith("ex:"):
-                    # if returned error message, return it
-                    return msg
-                drawCount += 1
                 # save player and deck to tracker
                 for i in range(len(vpTracker)):
                     if vpTracker[i]['nodeID'] == nodeID:
                         vpTracker[i]['player'] = player
                         vpTracker[i]['deck'] = deck
-                        vpTracker[i]['drawCount'] = drawCount
-                if drawCount == 2:
-                    # this is the last draw will carry on to endGame for scoring
-                    msg = player.redraw(deck, message) + f"\n"
+                        vpTracker[i]['cash'] = player.bankroll
+
+        # Play the game
+        if getLastCmdVp(nodeID) == "playing":
+            msg = ''
+        
+            player.draw_cards(deck)
+            msg += player.show_hand()
+            # give hint to player
+            msg += player.score_hand(resetHand=False)
+            
+            # save player and deck to tracker
+            for i in range(len(vpTracker)):
+                if vpTracker[i]['nodeID'] == nodeID:
+                    vpTracker[i]['player'] = player
+                    vpTracker[i]['deck'] = deck
+                    vpTracker[i]['drawCount'] = drawCount
+
+            msg += f"\nDeal new card? \nex: 1,3,4 or (N)o,(A)ll (H)and"
+            setLastCmdVp(nodeID, "redraw")
+            return msg
+        
+        if getLastCmdVp(nodeID) == "redraw":
+            msg = ''
+            # load the player and deck from tracker
+            for i in range(len(vpTracker)):
+                if vpTracker[i]['nodeID'] == nodeID:
+                    player = vpTracker[i]['player']
+                    deck = vpTracker[i]['deck']
+                    drawCount  = vpTracker[i]['drawCount']
+
+            # if player wants to redraw cards, and not done already
+            if message.lower().startswith("n"):
+                setLastCmdVp(nodeID, "endGame")
+            if message.lower().startswith("h"):
+                msg = player.show_hand()
+                return msg
+            else:
+                if drawCount <= 1:
+                    msg = player.redraw(deck, message)
                     if msg.startswith("ex:"):
                         # if returned error message, return it
                         return msg
-                    # redraw done
-                    setLastCmdVp(nodeID, "endGame")
+                    drawCount += 1
+                    # save player and deck to tracker
+                    for i in range(len(vpTracker)):
+                        if vpTracker[i]['nodeID'] == nodeID:
+                            vpTracker[i]['player'] = player
+                            vpTracker[i]['deck'] = deck
+                            vpTracker[i]['drawCount'] = drawCount
+                    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("ex:"):
+                            # if returned error message, return it
+                            return msg
+                        # redraw done
+                        setLastCmdVp(nodeID, "endGame")
+                    else:
+                        # show redrawn hand
+                        return msg
                 else:
-                    # show redrawn hand
-                    return msg
-            else:
-                # redraw already done
-                setLastCmdVp(nodeID, "endGame")
-                
-    if getLastCmdVp(nodeID) == "endGame":
-        # load the player and deck from tracker
-        for i in range(len(vpTracker)):
-            if vpTracker[i]['nodeID'] == nodeID:
-                player = vpTracker[i]['player']
-                deck = vpTracker[i]['deck']
+                    # redraw already done
+                    setLastCmdVp(nodeID, "endGame")
+                    
+        if getLastCmdVp(nodeID) == "endGame":
+            # load the player and deck from tracker
+            for i in range(len(vpTracker)):
+                if vpTracker[i]['nodeID'] == nodeID:
+                    player = vpTracker[i]['player']
+                    deck = vpTracker[i]['deck']
 
-        msg += player.score_hand()
+            msg += player.score_hand()
 
-        if player.bankroll < 1:
-            player.bankroll = vpStartingCash
-            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'])
+            if player.bankroll < 1:
+                player.bankroll = vpStartingCash
+                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, or (L)eave Table."
+            msg += f"\nPlace your Bet, or (L)eave Table."
 
-        setLastCmdVp(nodeID, "gameOver")
-        # reset player and deck in tracker
-        for i in range(len(vpTracker)):
-            if vpTracker[i]['nodeID'] == nodeID:
-                vpTracker[i]['player'] = None
-                vpTracker[i]['deck'] = None
-                vpTracker[i]['drawCount'] = 0
-                # save bankroll
-                vpTracker[i]['cash'] = player.bankroll
+            setLastCmdVp(nodeID, "gameOver")
+            # reset player and deck in tracker
+            for i in range(len(vpTracker)):
+                if vpTracker[i]['nodeID'] == nodeID:
+                    vpTracker[i]['player'] = None
+                    vpTracker[i]['deck'] = None
+                    vpTracker[i]['drawCount'] = 0
+                    # save bankroll
+                    vpTracker[i]['cash'] = player.bankroll
 
-        return msg
+            return msg
+        # At the end of the try block, if nothing returned yet:
+        return msg if msg else 'No action taken.'
+    except Exception as e:
+        logger.warning(f"System: VideoPoker: Error {e}")
+        return 'No Game in progress'
 
- 

modules/games/wodt.py

@@ -0,0 +1,313 @@
+# python word of the day game module for meshing-around bot
+# 2025 K7MHI Kelly Keeton
+from modules.log import logger, getPrettyTime
+import random
+import json
+import os
+import time
+from itertools import product
+
+class WordOfTheDayGame:
+    def __init__(self):
+        self.bingo_board_size = 3 # 3x3 bingo board good for small demos
+
+        default_word_list = [
+            {'word': 'serendipity', 'meta': 'The occurrence of events by chance in a happy or beneficial way.'},
+            {'word': 'ephemeral', 'meta': 'Lasting for a very short time.'},
+            {'word': 'sonder', 'meta': 'The realization that each passerby has a life as vivid and complex as your own.'},
+            {'word': 'petrichor', 'meta': 'A pleasant smell that frequently accompanies the first rain after a long period of warm, dry weather.'},
+        ]
+        json_path = os.path.join('data', 'wotd.json')
+        if os.path.exists(json_path):
+            try:
+                with open(json_path, 'r') as f:
+                    self.word_list = json.load(f)
+            except FileNotFoundError:
+                logger.debug("System: WoTd: Failed to load data/wotd.json, using default word list.")
+                self.word_list = default_word_list
+            except json.JSONDecodeError:
+                logger.warning("System: WoTd: JSON decode error in data/wotd.json, example format: [{\"word\": \"example\", \"definition\": \"An example definition.\"}]")
+                self.word_list = default_word_list
+        else:
+            logger.debug("System: WoTd: data/wotd.json not found, using default word list.")
+            self.word_list = default_word_list
+
+        # Load bingo card words from JSON if available
+        default_bingo_card = [
+            "dog", "cat", "fish", "bird", "hamster", "rabbit", "turtle", "lizard", "snake", "frog",
+            "horse", "cow", "pig", "sheep", "goat", "chicken", "duck", "turkey", "peacock", "parrot",
+            "elephant", "lion", "tiger", "bear", "wolf", "fox", "deer", "moose", "zebra", "giraffe",
+            "monkey", "ape", "chimpanzee", "gorilla", "orangutan", "kangaroo", "koala", "panda",
+            "whale", "dolphin", "shark", "octopus", "crab", "lobster", "jellyfish", "seahorse",
+            "ant", "bee", "butterfly", "dragonfly", "spider", "ladybug"
+        ]
+        bingo_json_path = os.path.join('data', 'bingo.json')
+        if os.path.exists(bingo_json_path):
+            try:
+                with open(bingo_json_path, 'r') as f:
+                    bingoCard = json.load(f)
+            except (FileNotFoundError, json.JSONDecodeError):
+                logger.debug("System: WoTd: Failed to load data/bingo.json, using default bingo card. example format: [\"word1\", \"word2\", ...]")
+                bingoCard = default_bingo_card
+        else:
+            logger.debug("System: WoTd: data/bingo.json not found, using default bingo card.")
+            bingoCard = default_bingo_card
+
+        # Create a set for faster lookup
+        self.bingoCardSet = set(bingoCard)
+
+        self.leet_dict = {
+            'a': ['4', '@'],
+            'b': ['8'],
+            'e': ['3'],
+            'i': ['1', '!', '|'],
+            'l': ['1', '|', '7'],
+            'o': ['0'],
+            's': ['5', '$'],
+            't': ['7', '+'],
+            'g': ['9', '6'],
+        }
+        # Initialize the word of the day
+        self.word_of_the_day_entry = random.choice(self.word_list)
+        logger.debug(f"System: WoTd: Initialized with word of the day '{self.word_of_the_day_entry['word']}'.")
+        # Initialize bingo card
+        self.generate_bingo_card(self.bingo_board_size)
+        logger.debug("System: BINGO: " + ". ".join(" | ".join(row) for row in self.bingo_card))
+
+    def get_emoji_type(self, emoji, randomReturn=False):
+        smileys = "😀😁😂🤣😃😄😅😆😉😊😋😎😍😘🥰😗😙😚🙂🤗🤩🤔🤨😐😑😶🙄😏😣😥😮🤐😯😪😫😴😌😛😜😝🤤😒😓😔😕🙃🤑😲☹️🙁😖😞😟😤😢😭😦😧😨😩🤯😬😰😱🥵🥶😳🤪😵😡😠🤬😷🤒🤕🤢🤮🤧😇🥳🥺🤠"
+        animals = "🐶🐱🐭🐹🐰🦊🐻🐼🐨🐯🦁🐮🐷🐽🐸🐵🙈🙉🙊🐒🐔🐧🐦🐤🐣🐥🦆🦅🦉🦇🐺🐗🐴🦄🐝🐛🦋🐌🐞🐜🦟🦗🕷️🕸️🐢🐍🦎🦂🦀🦞🦐🦑🐙🦑🐠🐟🐡🐬🦈🐳🐋🐊🐅🐆🦓🦍🦧🐘🦛🦏🐪🐫🦒🦘🐃🐂🐄🐎🐖🐏🐑🦙🐐🦌🐕🐩🦮🐕‍🦺🐈🐓🦃🦚🦜🦢🦩🕊️🐇🦝🦨🦡🦦🦥🐁🐀🐿️🦔"
+        fruit = "🍎🍊🍌🍉🍇🍓🍒🍑🥭🍍🥥🥝🍅🥑🍆🥔🥕🌽🌶️🥒🥬🥦🧄🧅🍄🥜🌰"
+        categories = {'smileys': smileys, 'animals': animals, 'fruit': fruit}
+        if randomReturn:
+            cat = random.choice(list(categories))
+            return random.choice(categories[cat])
+        for cat, chars in categories.items():
+            if emoji in chars:
+                return cat
+        return False
+
+    def reset_word_of_the_day(self):
+        logger.debug("System: WoTd: Resetting Word of the Day.")
+        self.word_of_the_day_entry = random.choice(self.word_list)
+
+    def generate_leet_variants(self, word):
+        chars = []
+        for c in word.lower():
+            if c in self.leet_dict:
+                chars.append([c] + self.leet_dict[c])
+            else:
+                chars.append([c])
+        variants = set()
+        for combo in product(*chars):
+            variant = ''.join(combo)
+            variants.add(variant)
+            if len(variants) > 128:
+                break
+        return variants
+
+    def did_it_happen(self, string_of_text=''):
+        """
+        Check if the current word of the day (or its leet variants) appears in the text.
+        Also check for a bingo win.
+        Returns:
+            (wotd_found, old_entry, new_entry, bingo_win, bingo_message)
+        """
+        text = string_of_text.lower()
+        words_in_text = set(text.split())
+        word = self.word_of_the_day_entry['word'].lower()
+        variants = self.generate_leet_variants(word)
+        wotd_found = False
+        old_entry = None
+        new_entry = None
+    
+        for variant in variants:
+            if variant in words_in_text:
+                old_entry = self.word_of_the_day_entry
+                self.reset_word_of_the_day()
+                new_entry = self.word_of_the_day_entry
+                wotd_found = True
+                break
+    
+        bingo_win, bingo_message = self.b_i_n_g_o(string_of_text)
+        return wotd_found, old_entry, new_entry, bingo_win, bingo_message
+    
+    def generate_bingo_card(self, size=None):
+        """
+        Generate a random bingo card of given size (size x size) from the bingoCardSet.
+        Returns a 2D list representing the bingo card.
+        """
+        if size is None:
+            size = self.bingo_board_size
+        words = random.sample(list(self.bingoCardSet), size * size)
+        card = [words[i*size:(i+1)*size] for i in range(size)]
+        self.bingo_card = card
+        self.bingo_card_matches = [[False]*size for _ in range(size)]
+        return card
+
+    def b_i_n_g_o(self, string_of_text=''):
+        """
+        Check if any words in the text match the bingo card.
+        If a row, column, or diagonal is fully matched, return True and the winning line.
+        Otherwise, return False and None.
+        """
+        if not hasattr(self, 'bingo_card'):
+            logger.debug("System: WoTd: Generating new bingo card.")
+            self.generate_bingo_card(self.bingo_board_size)
+
+        words_in_text = set(string_of_text.lower().split())
+        size = len(self.bingo_card)
+        # Mark matches
+        for i in range(size):
+            for j in range(size):
+                if self.bingo_card[i][j].lower() in words_in_text:
+                    self.bingo_card_matches[i][j] = True
+
+        # Check rows
+        for i in range(size):
+            if all(self.bingo_card_matches[i]):
+                winning_row = self.bingo_card[i]
+                logger.debug("System: BINGO achieved, generating new bingo card.")
+                self.generate_bingo_card(size)  # Reset board after win
+                return True, f"BINGO! Row {i+1}: {winning_row}"
+
+        # Check columns
+        for j in range(size):
+            if all(self.bingo_card_matches[i][j] for i in range(size)):
+                col = [self.bingo_card[i][j] for i in range(size)]
+                logger.debug("System: BINGO achieved, generating new bingo card.")
+                self.generate_bingo_card(size)  # Reset board after win
+                return True, f"BINGO! Column {j+1}: {col}"
+
+        # Check diagonals
+        if all(self.bingo_card_matches[i][i] for i in range(size)):
+            diag = [self.bingo_card[i][i] for i in range(size)]
+            logger.debug("System: BINGO achieved, generating new bingo card.")
+            self.generate_bingo_card(size)  # Reset board after win
+            return True, f"BINGO! Diagonal: {diag}"
+        if all(self.bingo_card_matches[i][size-1-i] for i in range(size)):
+            diag = [self.bingo_card[i][size-1-i] for i in range(size)]
+            logger.debug("System: BINGO achieved, generating new bingo card.")
+            self.generate_bingo_card(size)  # Reset board after win
+            return True, f"BINGO! Diagonal: {diag}"
+
+        return False, None
+    
+    def extract_emojis(self, text):
+        emojis = []
+        for char in text:
+            cp = ord(char)
+            # Common emoji Unicode ranges
+            if (
+                0x1F600 <= cp <= 0x1F64F or  # Emoticons
+                0x1F300 <= cp <= 0x1F5FF or  # Symbols & pictographs
+                0x1F680 <= cp <= 0x1F6FF or  # Transport & map symbols
+                0x1F1E6 <= cp <= 0x1F1FF or  # Regional indicator symbols
+                0x2600  <= cp <= 0x26FF  or  # Misc symbols
+                0x2700  <= cp <= 0x27BF  or  # Dingbats
+                0x1F900 <= cp <= 0x1F9FF or  # Supplemental symbols & pictographs
+                0x1FA70 <= cp <= 0x1FAFF or  # Symbols & pictographs extended-A
+                0x2B50  == cp or             # Star
+                0x2B55  == cp                # Heavy large circle
+            ):
+                emojis.append(char)
+        return emojis
+    
+    def emojiMiniGame(self, string_of_text='', nodeID=0, nodeInt=1, emojiSeen=False):
+        from modules.system import meshLeaderboard
+        """
+        Track emoji usage, Returns a string if the mini-game is won, else None.
+        If emojiSeen is False, only update mostMessages leaderboard and skip emoji logic.
+        """
+
+        # Only increment for text/chat messages
+        meshLeaderboard['nodeMessageCounts'][nodeID] = meshLeaderboard['nodeMessageCounts'].get(nodeID, 0) + 1
+    
+        # Update mostMessages leaderboard
+        if meshLeaderboard['nodeMessageCounts']:
+            max_node = max(meshLeaderboard['nodeMessageCounts'], key=meshLeaderboard['nodeMessageCounts'].get)
+            meshLeaderboard['mostMessages'] = {
+                'nodeID': max_node,
+                'value': meshLeaderboard['nodeMessageCounts'][max_node],
+                'timestamp': time.time()
+            }
+
+        
+        emoji = None  # Placeholder: extract emoji from string_of_text if needed
+        emojis = self.extract_emojis(string_of_text)
+        if not emojiSeen and not emojis:
+            return None
+        logger.debug(f"System: WoTd: Emoji mini-game processing for nodeID {nodeID} with emojis: {emojis}")
+        # --- 1. Update meshLeaderboard for emoji usage ---
+        if 'emojiCounts' not in meshLeaderboard:
+            meshLeaderboard['emojiCounts'] = {}
+        if 'emojiTypeCounts' not in meshLeaderboard:
+            meshLeaderboard['emojiTypeCounts'] = {}
+
+        meshLeaderboard['emojiCounts'].setdefault(nodeID, {})
+        for emoji in emojis:
+            meshLeaderboard['emojiCounts'][nodeID][emoji] = meshLeaderboard['emojiCounts'][nodeID].get(emoji, 0) + 1
+
+        # --- Update the leaderboard record for most emojis ---
+        # Flatten per-node emoji counts to total per node
+        emoji_totals = {nid: sum(emojicounts.values()) for nid, emojicounts in meshLeaderboard['emojiCounts'].items() if isinstance(emojicounts, dict)}
+        if emoji_totals:
+            max_node = max(emoji_totals, key=emoji_totals.get)
+            meshLeaderboard['mostEmojis'] = {
+                'nodeID': max_node,
+                'value': emoji_totals[max_node],
+                'timestamp': time.time()
+            }
+        
+        # --- 2. Track most used of a type (e.g., smileys, animals, etc.) ---
+        emoji_type = self.get_emoji_type(emoji)
+        meshLeaderboard['emojiTypeCounts'].setdefault(emoji_type, {})
+        meshLeaderboard['emojiTypeCounts'][emoji_type][emoji] = meshLeaderboard['emojiTypeCounts'][emoji_type].get(emoji, 0) + 1
+
+        # --- 3. Slot machine mini-game ---
+        if 'emojiSlotWindow' not in meshLeaderboard:
+            meshLeaderboard['emojiSlotWindow'] = []
+        meshLeaderboard['emojiSlotWindow'].append(emoji)
+        # Randomize jackpot length after each win
+        if not hasattr(self, 'slot_jackpot_length'):
+            self.slot_jackpot_length = random.choice([3,4,5])  # JackPot length can be 3, 4, or 5
+        if len(meshLeaderboard['emojiSlotWindow']) > self.slot_jackpot_length:
+            meshLeaderboard['emojiSlotWindow'].pop(0)
+
+        # --- 3a. Detect spam of 3 identical emojis in a row ---
+        if len(meshLeaderboard['emojiSlotWindow']) >= 5:
+            last_three = meshLeaderboard['emojiSlotWindow'][-3:]
+            if len(set(last_three)) == 1:
+                # Option: Randomly add an emoji to break the spam
+                random_emoji = self.get_emoji_type('', randomReturn=True)
+                meshLeaderboard['emojiSlotWindow'].append(random_emoji)
+                logger.debug(f"System: WoTd: Detected emoji spam, added random emoji '{random_emoji}' to slot window.")
+                # Optionally, you can still scramble or pop as well if you want
+                random.shuffle(meshLeaderboard['emojiSlotWindow'])
+                meshLeaderboard['emojiSlotWindow'].pop()
+
+        # # Debug: Show slot window status before jackpot check
+        # logger.debug(
+        #     f"Emoji Slot Window: {meshLeaderboard['emojiSlotWindow']} | "
+        #     f"Jackpot Length: {self.slot_jackpot_length} | "
+        #     f"Unique: {set(meshLeaderboard['emojiSlotWindow'])} | "
+        #     f"Needed: {self.slot_jackpot_length - len(meshLeaderboard['emojiSlotWindow'])}"
+        # )
+
+        # Jackpot: all emojis in window are the same
+        if (
+            len(meshLeaderboard['emojiSlotWindow']) == self.slot_jackpot_length and
+            len(set(meshLeaderboard['emojiSlotWindow'])) == 1
+        ):
+            winner_msg = f"🎰 JACKPOT! {emoji * self.slot_jackpot_length}"
+            meshLeaderboard['emojiSlotWindow'] = []
+            self.slot_jackpot_length = random.choice([3, 4, 5])  # Randomize jackpot length after win
+            return winner_msg
+
+        return None
+
+# Example usage:
+# theWordOfTheDay = WordOfTheDayGame()
+# happened, entry = theWordOfTheDay.did_it_happen("I love serendipity!")
+# if happened:
+#     print(f"Found the word of the day: {entry['word']} - {entry['meta']}")

modules/globalalert.py

@@ -2,27 +2,28 @@
 # K7MHI Kelly Keeton 2024
 
 import json # pip install json
-from geopy.geocoders import Nominatim # pip install geopy
-import maidenhead as mh # pip install maidenhead
+#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 *
+#import xml.dom.minidom 
+from modules.log import logger
+from modules.settings import urlTimeoutSeconds, NO_ALERTS, myRegionalKeysDE
 
-trap_list_location_eu = ("ukalert", "ukwx", "ukflood")
-trap_list_location_de = ("dealert", "dewx", "deflood")
+trap_list_location_eu = ("ukalert",)
+trap_list_location_de = ("dealert",)
 
 def get_govUK_alerts(lat, lon):
     try:
         # get UK.gov alerts
         url = 'https://www.gov.uk/alerts'
-        response = requests.get(url)
+        response = requests.get(url, timeout=urlTimeoutSeconds)
         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
+        return 
     
     if alert:
         return "🚨" + alert.get_text(strip=True)
@@ -35,7 +36,7 @@ def get_nina_alerts():
         alerts = []
         for regionalKey in myRegionalKeysDE:
             url = ("https://nina.api.proxy.bund.dev/api31/dashboard/" + regionalKey + ".json")
-            response = requests.get(url)
+            response = requests.get(url, timeout=urlTimeoutSeconds)
             data = response.json()
 
             for item in data:
@@ -47,13 +48,13 @@ def get_nina_alerts():
         return NO_ALERTS
 
 def get_wxUKgov():
-    # get UK weather warnings
+    # get UK weather warnings, these look icky
     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)
+        response = requests.get(url, timeout=urlTimeoutSeconds)
         soup = bs.BeautifulSoup(response.content, 'xml')
         
         items = soup.find_all('item')
@@ -71,7 +72,62 @@ def get_wxUKgov():
     
     
 def get_floodUKgov():
-    # get UK flood warnings
+    # get UK flood warnings, there is so much I need a locals help
     url = 'https://environment.data.gov.uk/flood-widgets/rss/feed-England.xml'
     
     return NO_ALERTS
+
+def get_crimeUKgov(lat, lon):
+    """
+    Fetches recent street crime data from UK Police API for given lat/lon.
+    Returns a summary string or NO_ALERTS. -- pay for use?
+    """
+    date = datetime.datetime.now().strftime("%Y-%m")
+    url = f'https://data.police.uk/api/crimes-street/all-crime?date={date}&lat={lat}&lng={lon}'
+    try:
+        response = requests.get(url, timeout=urlTimeoutSeconds)
+        if not response.ok or not response.text.strip():
+            return NO_ALERTS
+        crimes = response.json()
+        if not crimes:
+            return NO_ALERTS
+        # Summarize the first few crimes
+        summaries = []
+        for crime in crimes[:3]:
+            category = crime.get("category", "Unknown")
+            outcome = crime.get("outcome_status", {}).get("category", "No outcome")
+            location = crime.get("location", {}).get("street", {}).get("name", "Unknown location")
+            summaries.append(f"{category.title()} at {location} ({outcome})")
+        return "\n".join(summaries)
+    except Exception as e:
+        logger.warning(f"Error fetching UK crime data: {e}")
+        return NO_ALERTS
+
+def get_crime_stopsUKgov(lat, lon):
+    """
+    Fetches recent stop-and-search data from UK Police API for given lat/lon.
+    Returns a summary string or NO_ALERTS. -- pay for use?
+    """
+    date = datetime.datetime.now().strftime("%Y-%m")
+    url = f'https://data.police.uk/api/stops-street?date={date}&lat={lat}&lng={lon}'
+    try:
+        response = requests.get(url, timeout=urlTimeoutSeconds)
+        if not response.ok or not response.text.strip():
+            return NO_ALERTS
+        stops = response.json()
+        if not stops:
+            return NO_ALERTS
+        # Summarize the first few stops
+        summaries = []
+        for stop in stops[:3]:  # Limit to first 3 stops for brevity
+            summary = (
+                f"Date: {stop.get('datetime', 'N/A')}, "
+                f"Outcome: {stop.get('outcome', 'N/A')}, "
+                f"Ethnicity: {stop.get('self_defined_ethnicity', 'N/A')}, "
+                f"Gender: {stop.get('gender', 'N/A')}, "
+                f"Location: {stop.get('location', {}).get('street', {}).get('name', 'N/A')}"
+            )
+            summaries.append(summary)
+        return "\n".join(summaries)
+    except Exception as e:
+        return NO_ALERTS

modules/gpio.py

@@ -7,7 +7,7 @@
 # https://pythonhosted.org/RPIO/
 import RPIO
 
-from modules.log import *
+from modules.log import logger, getPrettyTime
 trap_list_gpio = ("gpio", "pin", "relay", "switch", "pwm")
 
 # set up input channel without pull-up

modules/inventory.md

@@ -0,0 +1,423 @@
+# Inventory & Point of Sale System
+
+## Overview
+
+The inventory module provides a simple point-of-sale (POS) system for mesh networks, enabling inventory management, sales tracking, and cart-based transactions. This system is ideal for:
+
+- Emergency supply management
+- Event merchandise sales
+- Community supply tracking
+- Remote location inventory
+- Asset management
+- Field operations logistics
+- Tool lending in makerspaces or ham swaps
+- Tracking and lending shared items like Legos or kits
+
+> **Tool Lending & Shared Item Tracking:**  
+> The system supports lending out tools or kits (e.g., in a makerspace or ham swap) using the `itemloan` and `itemreturn` commands. You can also track bulk or set-based items like Legos, manage their locations, and log checkouts and returns for community sharing or events.
+
+## Features
+
+### 🏪 Simple POS System
+- **Item Management**: Add, remove, and update inventory items
+- **Cart System**: Build orders before completing transactions
+- **Transaction Logging**: Full audit trail of all sales and returns
+- **Price Tracking**: Track price changes over time
+- **Location Tracking**: Optional warehouse/location field for items
+
+### 💰 Financial Features
+- **Penny Rounding**: USA cash sales support
+  - Cash sales round down to nearest nickel
+  - Taxed sales round up to nearest nickel
+- **Daily Statistics**: Track sales performance
+- **Hot Item Detection**: Identify best-selling products
+- **Revenue Tracking**: Daily sales totals
+
+### 📊 Reporting
+- **Inventory Value**: Total inventory worth
+- **Sales Reports**: Daily transaction summaries
+- **Best Sellers**: Most popular items
+
+**Cart System:**
+- `cartadd <name> <qty>` - Add to cart
+- `cartremove <name>` - Remove from cart
+- `cartlist` / `cart` - View cart
+- `cartbuy` / `cartsell [notes]` - Complete transaction
+- `cartclear` - Empty cart
+
+**Item Management:**
+- `itemadd <name> <qty> [price] [loc]` - Add new item
+- `itemremove <name>` - Remove item
+- `itemreset name> <qty> [price] [loc]` - Update item
+- `itemsell <name> <qty> [notes]` - Quick sale
+- `itemloan <name> <note>` - Loan/checkout an item
+- `itemreturn <transaction_id>` - Reverse transaction
+- `itemlist` - View all inventory
+- `itemstats` - Daily statistics
+
+
+## Configuration
+
+Add to your `config.ini`:
+
+```ini
+[inventory]
+enabled = True
+inventory_db = data/inventory.db
+# Set to True to disable penny precision and round to nickels (USA cash sales)
+# When True: cash sales round down, taxed sales round up to nearest $0.05
+# When False (default): normal penny precision ($0.01)
+disable_penny = False
+```
+
+## Commands Reference
+
+### Item Management
+
+#### Add Item
+```
+itemadd <name> <price> <quantity> [location]
+```
+
+Adds a new item to inventory.
+
+**Examples:**
+```
+itemadd Radio 149.99 5 Shelf-A
+itemadd Battery 12.50 20 Warehouse
+itemadd Water 1.00 100
+```
+
+#### Remove Item
+```
+itemremove <name>
+```
+
+Removes an item from inventory (also removes from all carts).
+
+**Examples:**
+```
+itemremove Radio
+itemremove "First Aid Kit"
+```
+
+#### Update Item
+```
+itemreset <name> [price=X] [qty=Y]
+```
+
+Updates item price and/or quantity.
+
+**Examples:**
+```
+itemreset Radio price=139.99
+itemreset Battery qty=50
+itemreset Water price=0.95 qty=200
+```
+
+#### Quick Sale
+```
+itemsell <name> <quantity> [notes]
+```
+
+Sell directly without using cart (for quick transactions).
+
+**Examples:**
+```
+itemsell Battery 2
+itemsell Water 10 Emergency supply
+itemsell Radio 1 Field unit sale
+```
+
+#### Return Transaction
+```
+itemreturn <transaction_id>
+```
+
+Reverse a transaction and return items to inventory.
+
+**Examples:**
+```
+itemreturn 123
+itemreturn 45
+```
+
+#### List Inventory
+```
+itemlist
+```
+
+Shows all items with prices, quantities, and total inventory value.
+
+**Example Response:**
+```
+📦 Inventory:
+Radio: $149.99 x 5 @ Shelf-A = $749.95
+Battery: $12.50 x 20 @ Warehouse = $250.00
+Water: $1.00 x 100 = $100.00
+
+Total Value: $1,099.95
+```
+
+#### Statistics
+```
+itemstats
+```
+
+Shows today's sales performance.
+
+**Example Response:**
+```
+📊 Today's Stats:
+Sales: 15
+Revenue: $423.50
+Hot Item: Battery (8 sold)
+```
+
+### Cart System
+
+#### Add to Cart
+```
+cartadd <name> <quantity>
+```
+
+Add items to your shopping cart.
+
+**Examples:**
+```
+cartadd Radio 2
+cartadd Battery 4
+cartadd Water 12
+```
+
+#### Remove from Cart
+```
+cartremove <name>
+```
+
+Remove items from cart.
+
+**Examples:**
+```
+cartremove Radio
+cartremove Battery
+```
+
+#### View Cart
+```
+cart
+cartlist
+```
+
+Display your current cart contents and total.
+
+**Example Response:**
+```
+🛒 Your Cart:
+Radio: $149.99 x 2 = $299.98
+Battery: $12.50 x 4 = $50.00
+
+Total: $349.98
+```
+
+#### Complete Transaction
+```
+cartbuy [notes]
+cartsell [notes]
+```
+
+Process the cart as a transaction. Use `cartbuy` for purchases (adds to inventory) or `cartsell` for sales (removes from inventory).
+
+**Examples:**
+```
+cartsell Customer purchase
+cartbuy Restocking supplies
+cartsell Event merchandise
+```
+
+#### Clear Cart
+```
+cartclear
+```
+
+Empty your shopping cart without completing a transaction.
+
+## Use Cases
+
+### 1. Event Merchandise Sales
+
+Perfect for festivals, hamfests, or community events:
+
+```
+# Setup inventory
+itemadd Tshirt 20.00 50 Booth-A
+itemadd Hat 15.00 30 Booth-A
+itemadd Sticker 5.00 100 Booth-B
+
+# Customer transaction
+cartadd Tshirt 2
+cartadd Hat 1
+cartsell Festival sale
+
+# Check daily performance
+itemstats
+```
+
+### 2. Emergency Supply Tracking
+
+Track supplies during disaster response:
+
+```
+# Add emergency supplies
+itemadd Water 0.00 500 Warehouse-1
+itemadd MRE 0.00 200 Warehouse-1
+itemadd Blanket 0.00 100 Warehouse-2
+
+# Distribute supplies
+itemsell Water 50 Red Cross distribution
+itemsell MRE 20 Family shelter
+
+# Check remaining inventory
+itemlist
+```
+
+### 3. Field Equipment Management
+
+Manage tools and equipment in remote locations:
+
+```
+# Track equipment
+itemadd Generator 500.00 3 Base-Camp
+itemadd Radio 200.00 10 Equipment-Room
+itemadd Battery 15.00 50 Supply-Closet
+
+# Equipment checkout
+itemsell Generator 1 Field deployment
+itemsell Radio 5 Survey team
+
+# Monitor inventory
+itemlist
+itemstats
+```
+
+### 4. Community Supply Exchange
+
+Facilitate supply exchanges within a community:
+
+```
+# Add community items
+itemadd Seeds 2.00 100 Community-Garden
+itemadd Firewood 10.00 20 Storage-Shed
+
+# Member transactions
+cartadd Seeds 5
+cartadd Firewood 2
+cartsell Member-123 purchase
+```
+
+## Penny Rounding (USA Mode)
+
+When `disable_penny = True` is set in the configuration, the system implements penny rounding (disabling penny precision). This follows USA practice where pennies are not commonly used in cash transactions.
+
+### Cash Sales (Round Down)
+- $10.47 → $10.45
+- $10.48 → $10.45
+- $10.49 → $10.45
+
+### Taxed Sales (Round Up)
+- $10.47 → $10.50
+- $10.48 → $10.50
+- $10.49 → $10.50
+
+This follows common USA practice where pennies are not used in cash transactions.
+
+## Database Schema
+
+The system uses SQLite with four tables:
+
+### items
+```sql
+CREATE TABLE items (
+    item_id INTEGER PRIMARY KEY AUTOINCREMENT,
+    item_name TEXT UNIQUE NOT NULL,
+    item_price REAL NOT NULL,
+    item_quantity INTEGER NOT NULL DEFAULT 0,
+    location TEXT,
+    created_date TEXT,
+    updated_date TEXT
+)
+```
+
+### transactions
+```sql
+CREATE TABLE transactions (
+    transaction_id INTEGER PRIMARY KEY AUTOINCREMENT,
+    transaction_type TEXT NOT NULL,
+    transaction_date TEXT NOT NULL,
+    transaction_time TEXT NOT NULL,
+    user_name TEXT,
+    total_amount REAL NOT NULL,
+    notes TEXT
+)
+```
+
+### transaction_items
+```sql
+CREATE TABLE transaction_items (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    transaction_id INTEGER NOT NULL,
+    item_id INTEGER NOT NULL,
+    quantity INTEGER NOT NULL,
+    price_at_sale REAL NOT NULL,
+    FOREIGN KEY (transaction_id) REFERENCES transactions(transaction_id),
+    FOREIGN KEY (item_id) REFERENCES items(item_id)
+)
+```
+
+### carts
+```sql
+CREATE TABLE carts (
+    cart_id INTEGER PRIMARY KEY AUTOINCREMENT,
+    user_id TEXT NOT NULL,
+    item_id INTEGER NOT NULL,
+    quantity INTEGER NOT NULL,
+    added_date TEXT,
+    FOREIGN KEY (item_id) REFERENCES items(item_id)
+)
+```
+
+## Security Considerations
+
+- Users on the `bbs_ban_list` cannot use inventory commands
+- Each user has their own cart (identified by node ID)
+- Transactions are logged with user information for accountability
+- All database operations use parameterized queries to prevent SQL injection
+
+## Tips and Best Practices
+
+1. **Regular Inventory Checks**: Use `itemlist` regularly to monitor stock levels
+2. **Descriptive Notes**: Add notes to transactions for better tracking
+3. **Location Tags**: Use consistent location naming for better organization
+4. **Daily Reviews**: Check `itemstats` at the end of each day
+5. **Transaction IDs**: Keep track of transaction IDs for potential returns
+6. **Quantity Updates**: Use `itemreset` to adjust inventory after physical counts
+7. **Cart Cleanup**: Use `cartclear` if you change your mind before completing a sale
+
+## Troubleshooting
+
+### Item Already Exists
+If you get "Item already exists" when using `itemadd`, use `itemreset` instead to update the existing item.
+
+### Insufficient Quantity
+If you see "Insufficient quantity" error, check available stock with `itemlist` before attempting the sale.
+
+### Transaction Not Found
+If `itemreturn` fails, verify the transaction ID exists. Use recent transaction logs to find valid IDs.
+
+### Cart Not Showing Items
+Each user has their own cart. Make sure you're using your own node to view your cart.
+
+
+## Support
+
+For issues or feature requests, please file an issue on the GitHub repository.

modules/inventory.py

@@ -0,0 +1,747 @@
+# Inventory and Point of Sale module for the bot
+# K7MHI Kelly Keeton 2024
+# Enhanced POS system with cart management and inventory tracking
+
+import sqlite3
+from modules.log import logger
+from modules.settings import inventory_db, disable_penny, bbs_ban_list
+import time
+from decimal import Decimal, ROUND_HALF_UP, ROUND_DOWN
+
+trap_list_inventory = ("item", "itemlist", "itemloan", "itemsell", "itemreturn", "itemadd", "itemremove", 
+                       "itemreset", "itemstats", "cart", "cartadd", "cartremove", "cartlist",
+                       "cartbuy", "cartsell", "cartclear")
+
+def initialize_inventory_database():
+    """Initialize the inventory database with all necessary tables"""
+    try:
+        conn = sqlite3.connect(inventory_db)
+        c = conn.cursor()
+        
+        # Items table - stores inventory items
+        logger.debug("System: Inventory: Initializing database...")
+        c.execute('''CREATE TABLE IF NOT EXISTS items
+                     (item_id INTEGER PRIMARY KEY AUTOINCREMENT,
+                      item_name TEXT UNIQUE NOT NULL,
+                      item_price REAL NOT NULL,
+                      item_quantity INTEGER NOT NULL DEFAULT 0,
+                      location TEXT,
+                      created_date TEXT,
+                      updated_date TEXT)''')
+        
+        # Transactions table - stores sales/purchases
+        c.execute('''CREATE TABLE IF NOT EXISTS transactions
+                     (transaction_id INTEGER PRIMARY KEY AUTOINCREMENT,
+                      transaction_type TEXT NOT NULL,
+                      transaction_date TEXT NOT NULL,
+                      transaction_time TEXT NOT NULL,
+                      user_name TEXT,
+                      total_amount REAL NOT NULL,
+                      notes TEXT)''')
+        
+        # Transaction items table - stores items in each transaction
+        c.execute('''CREATE TABLE IF NOT EXISTS transaction_items
+                     (id INTEGER PRIMARY KEY AUTOINCREMENT,
+                      transaction_id INTEGER NOT NULL,
+                      item_id INTEGER NOT NULL,
+                      quantity INTEGER NOT NULL,
+                      price_at_sale REAL NOT NULL,
+                      FOREIGN KEY (transaction_id) REFERENCES transactions(transaction_id),
+                      FOREIGN KEY (item_id) REFERENCES items(item_id))''')
+        
+        # Carts table - stores temporary shopping carts
+        c.execute('''CREATE TABLE IF NOT EXISTS carts
+                     (cart_id INTEGER PRIMARY KEY AUTOINCREMENT,
+                      user_id TEXT NOT NULL,
+                      item_id INTEGER NOT NULL,
+                      quantity INTEGER NOT NULL,
+                      added_date TEXT,
+                      FOREIGN KEY (item_id) REFERENCES items(item_id))''')
+        
+        conn.commit()
+        conn.close()
+        logger.info("Inventory: Database initialized successfully")
+        return True
+    except Exception as e:
+        logger.error(f"Inventory: Failed to initialize database: {e}")
+        return False
+
+def round_price(amount, is_taxed_sale=False):
+    """Round price based on penny rounding settings"""
+    if not disable_penny:
+        return float(Decimal(str(amount)).quantize(Decimal('0.01'), rounding=ROUND_HALF_UP))
+    
+    # Penny rounding logic
+    decimal_amount = Decimal(str(amount))
+    if is_taxed_sale:
+        # Round up for taxed sales
+        return float(decimal_amount.quantize(Decimal('0.05'), rounding=ROUND_HALF_UP))
+    else:
+        # Round down for cash sales
+        return float(decimal_amount.quantize(Decimal('0.05'), rounding=ROUND_DOWN))
+
+def add_item(name, price, quantity=0, location=""):
+    """Add a new item to inventory"""
+    conn = sqlite3.connect(inventory_db)
+    c = conn.cursor()
+    current_date = time.strftime("%Y-%m-%d")
+    
+    try:
+        # Check if item already exists
+        c.execute("SELECT item_id FROM items WHERE item_name = ?", (name,))
+        existing = c.fetchone()
+        if existing:
+            conn.close()
+            return f"Item '{name}' already exists. Use itemreset to update."
+        
+        c.execute("""INSERT INTO items (item_name, item_price, item_quantity, location, created_date, updated_date)
+                     VALUES (?, ?, ?, ?, ?, ?)""",
+                  (name, price, quantity, location, current_date, current_date))
+        conn.commit()
+        conn.close()
+        return f"✅ Item added: {name} - ${price:.2f} - Qty: {quantity}"
+    except sqlite3.OperationalError as e:
+        if "no such table" in str(e):
+            initialize_inventory_database()
+            return add_item(name, price, quantity, location)
+        else:
+            conn.close()
+            logger.error(f"Inventory: Error adding item: {e}")
+            return "Error adding item."
+    except Exception as e:
+        conn.close()
+        logger.error(f"Inventory: Error adding item: {e}")
+        return "Error adding item."
+
+def remove_item(name):
+    """Remove an item from inventory"""
+    conn = sqlite3.connect(inventory_db)
+    c = conn.cursor()
+    
+    try:
+        c.execute("DELETE FROM items WHERE item_name = ?", (name,))
+        if c.rowcount == 0:
+            conn.close()
+            return f"Item '{name}' not found."
+        conn.commit()
+        conn.close()
+        return f"🗑️ Item removed: {name}"
+    except Exception as e:
+        conn.close()
+        logger.error(f"Inventory: Error removing item: {e}")
+        return "Error removing item."
+
+def reset_item(name, price=None, quantity=None):
+    """Update item price or quantity"""
+    conn = sqlite3.connect(inventory_db)
+    c = conn.cursor()
+    current_date = time.strftime("%Y-%m-%d")
+    
+    try:
+        # Check if item exists
+        c.execute("SELECT item_price, item_quantity FROM items WHERE item_name = ?", (name,))
+        item = c.fetchone()
+        if not item:
+            conn.close()
+            return f"Item '{name}' not found."
+        
+        updates = []
+        params = []
+        
+        if price is not None:
+            updates.append("item_price = ?")
+            params.append(price)
+        
+        if quantity is not None:
+            updates.append("item_quantity = ?")
+            params.append(quantity)
+        
+        if not updates:
+            conn.close()
+            return "No updates specified."
+        
+        updates.append("updated_date = ?")
+        params.append(current_date)
+        params.append(name)
+        
+        query = f"UPDATE items SET {', '.join(updates)} WHERE item_name = ?"
+        c.execute(query, params)
+        conn.commit()
+        conn.close()
+        
+        update_msg = []
+        if price is not None:
+            update_msg.append(f"Price: ${price:.2f}")
+        if quantity is not None:
+            update_msg.append(f"Qty: {quantity}")
+        
+        return f"🔄 Item updated: {name} - {' - '.join(update_msg)}"
+    except Exception as e:
+        conn.close()
+        logger.error(f"Inventory: Error resetting item: {e}")
+        return "Error updating item."
+
+def sell_item(name, quantity, user_name="", notes=""):
+    """Sell an item (remove from inventory and record transaction)"""
+    conn = sqlite3.connect(inventory_db)
+    c = conn.cursor()
+    current_date = time.strftime("%Y-%m-%d")
+    current_time = time.strftime("%H:%M:%S")
+    
+    try:
+        # Get item details
+        c.execute("SELECT item_id, item_price, item_quantity FROM items WHERE item_name = ?", (name,))
+        item = c.fetchone()
+        if not item:
+            conn.close()
+            return f"Item '{name}' not found."
+        
+        item_id, price, current_qty = item
+        
+        if current_qty < quantity:
+            conn.close()
+            return f"Insufficient quantity. Available: {current_qty}"
+        
+        # Calculate total with rounding
+        total = round_price(price * quantity, is_taxed_sale=True)
+        
+        # Create transaction
+        c.execute("""INSERT INTO transactions (transaction_type, transaction_date, transaction_time, 
+                     user_name, total_amount, notes)
+                     VALUES (?, ?, ?, ?, ?, ?)""",
+                  ("SALE", current_date, current_time, user_name, total, notes))
+        transaction_id = c.lastrowid
+        
+        # Add transaction item
+        c.execute("""INSERT INTO transaction_items (transaction_id, item_id, quantity, price_at_sale)
+                     VALUES (?, ?, ?, ?)""",
+                  (transaction_id, item_id, quantity, price))
+        
+        # Update inventory
+        c.execute("UPDATE items SET item_quantity = item_quantity - ?, updated_date = ? WHERE item_id = ?",
+                  (quantity, current_date, item_id))
+        
+        conn.commit()
+        conn.close()
+        return f"💰 Sale: {quantity}x {name} - Total: ${total:.2f}"
+    except Exception as e:
+        conn.close()
+        logger.error(f"Inventory: Error selling item: {e}")
+        return "Error processing sale."
+
+def return_item(transaction_id):
+    """Return items from a transaction (reverse the sale or loan)"""
+    conn = sqlite3.connect(inventory_db)
+    c = conn.cursor()
+    current_date = time.strftime("%Y-%m-%d")
+    
+    try:
+        # Get transaction details
+        c.execute("SELECT transaction_type FROM transactions WHERE transaction_id = ?", (transaction_id,))
+        transaction = c.fetchone()
+        if not transaction:
+            conn.close()
+            return f"Transaction {transaction_id} not found."
+        transaction_type = transaction[0]
+        
+        # Get items in transaction
+        c.execute("""SELECT ti.item_id, ti.quantity, i.item_name 
+                     FROM transaction_items ti
+                     JOIN items i ON ti.item_id = i.item_id
+                     WHERE ti.transaction_id = ?""", (transaction_id,))
+        items = c.fetchall()
+        
+        if not items:
+            conn.close()
+            return f"No items found for transaction {transaction_id}."
+        
+        # Return items to inventory
+        for item_id, quantity, item_name in items:
+            c.execute("UPDATE items SET item_quantity = item_quantity + ?, updated_date = ? WHERE item_id = ?",
+                      (quantity, current_date, item_id))
+        
+        # Remove transaction and transaction_items
+        c.execute("DELETE FROM transactions WHERE transaction_id = ?", (transaction_id,))
+        c.execute("DELETE FROM transaction_items WHERE transaction_id = ?", (transaction_id,))
+        
+        conn.commit()
+        conn.close()
+        if transaction_type == "LOAN":
+            return f"↩️ Loan {transaction_id} returned. Item(s) back in inventory."
+        else:
+            return f"↩️ Transaction {transaction_id} reversed. Items returned to inventory."
+    except Exception as e:
+        conn.close()
+        logger.error(f"Inventory: Error returning item: {e}")
+        return "Error processing return."
+
+def loan_item(name, user_name="", note=""):
+    """Loan an item (checkout/loan to someone, record transaction)"""
+    conn = sqlite3.connect(inventory_db)
+    c = conn.cursor()
+    current_date = time.strftime("%Y-%m-%d")
+    current_time = time.strftime("%H:%M:%S")
+
+    try:
+        # Get item details
+        c.execute("SELECT item_id, item_price, item_quantity FROM items WHERE item_name = ?", (name,))
+        item = c.fetchone()
+        if not item:
+            conn.close()
+            return f"Item '{name}' not found."
+        item_id, price, current_qty = item
+
+        if current_qty < 1:
+            conn.close()
+            return f"Insufficient quantity. Available: {current_qty}"
+
+        # Create loan transaction (quantity always 1 for now)
+        c.execute("""INSERT INTO transactions (transaction_type, transaction_date, transaction_time, 
+                     user_name, total_amount, notes)
+                     VALUES (?, ?, ?, ?, ?, ?)""",
+                  ("LOAN", current_date, current_time, user_name, 0.0, note))
+        transaction_id = c.lastrowid
+
+        # Add transaction item
+        c.execute("""INSERT INTO transaction_items (transaction_id, item_id, quantity, price_at_sale)
+                     VALUES (?, ?, ?, ?)""",
+                  (transaction_id, item_id, 1, price))
+
+        # Update inventory
+        c.execute("UPDATE items SET item_quantity = item_quantity - 1, updated_date = ? WHERE item_id = ?",
+                  (current_date, item_id))
+
+        conn.commit()
+        conn.close()
+        return f"🔖 Loaned: {name} (note: {note}) [Transaction #{transaction_id}]"
+    except Exception as e:
+        conn.close()
+        logger.error(f"Inventory: Error loaning item: {e}")
+        return "Error processing loan."
+
+def get_loans_for_items():
+    """Return a dict of item_name -> list of loan notes for currently loaned items"""
+    conn = sqlite3.connect(inventory_db)
+    c = conn.cursor()
+    try:
+        # Find all active loans (not returned)
+        c.execute("""
+            SELECT i.item_name, t.notes
+            FROM transactions t
+            JOIN transaction_items ti ON t.transaction_id = ti.transaction_id
+            JOIN items i ON ti.item_id = i.item_id
+            WHERE t.transaction_type = 'LOAN'
+        """)
+        rows = c.fetchall()
+        conn.close()
+        loans = {}
+        for item_name, note in rows:
+            loans.setdefault(item_name, []).append(note)
+        return loans
+    except Exception as e:
+        conn.close()
+        logger.error(f"Inventory: Error fetching loans: {e}")
+        return {}
+
+def list_items():
+    """List all items in inventory, with loan info if any"""
+    conn = sqlite3.connect(inventory_db)
+    c = conn.cursor()
+    try:
+        c.execute("SELECT item_name, item_price, item_quantity, location FROM items ORDER BY item_name")
+        items = c.fetchall()
+        conn.close()
+
+        if not items:
+            return "No items in inventory."
+
+        # Get loan info
+        loans = get_loans_for_items()
+
+        result = "📦 Inventory:\n"
+        total_value = 0
+        for name, price, qty, location in items:
+            value = price * qty
+            total_value += value
+            loc_str = f" @ {location}" if location else ""
+            loan_str = ""
+            if name in loans:
+                for note in loans[name]:
+                    loan_str += f" [loan: {note}]"
+            result += f"{name}: ${price:.2f} x {qty}{loc_str} = ${value:.2f}{loan_str}\n"
+
+        result += f"\nTotal Value: ${total_value:.2f}"
+        return result.rstrip()
+    except Exception as e:
+        conn.close()
+        logger.error(f"Inventory: Error listing items: {e}")
+        return "Error listing items."
+
+def get_stats():
+    """Get sales statistics"""
+    conn = sqlite3.connect(inventory_db)
+    c = conn.cursor()
+    
+    try:
+        current_date = time.strftime("%Y-%m-%d")
+        
+        # Get today's sales
+        c.execute("""SELECT COUNT(*), SUM(total_amount) 
+                     FROM transactions 
+                     WHERE transaction_type = 'SALE' AND transaction_date = ?""",
+                  (current_date,))
+        today_stats = c.fetchone()
+        today_count = today_stats[0] or 0
+        today_total = today_stats[1] or 0
+        
+        # Get hot item (most sold today)
+        c.execute("""SELECT i.item_name, SUM(ti.quantity) as total_qty
+                     FROM transaction_items ti
+                     JOIN transactions t ON ti.transaction_id = t.transaction_id
+                     JOIN items i ON ti.item_id = i.item_id
+                     WHERE t.transaction_date = ? AND t.transaction_type = 'SALE'
+                     GROUP BY i.item_name
+                     ORDER BY total_qty DESC
+                     LIMIT 1""", (current_date,))
+        hot_item = c.fetchone()
+        
+        conn.close()
+        
+        result = f"📊 Today's Stats:\n"
+        result += f"Sales: {today_count}\n"
+        result += f"Revenue: ${today_total:.2f}\n"
+        if hot_item:
+            result += f"Hot Item: {hot_item[0]} ({hot_item[1]} sold)"
+        else:
+            result += "Hot Item: None"
+        
+        return result
+    except Exception as e:
+        conn.close()
+        logger.error(f"Inventory: Error getting stats: {e}")
+        return "Error getting stats."
+
+def add_to_cart(user_id, item_name, quantity):
+    """Add item to user's cart"""
+    conn = sqlite3.connect(inventory_db)
+    c = conn.cursor()
+    current_date = time.strftime("%Y-%m-%d")
+    
+    try:
+        # Get item details
+        c.execute("SELECT item_id, item_quantity FROM items WHERE item_name = ?", (item_name,))
+        item = c.fetchone()
+        if not item:
+            conn.close()
+            return f"Item '{item_name}' not found."
+        
+        item_id, available_qty = item
+        
+        # Check if item already in cart
+        c.execute("SELECT quantity FROM carts WHERE user_id = ? AND item_id = ?", (user_id, item_id))
+        existing = c.fetchone()
+        
+        if existing:
+            new_qty = existing[0] + quantity
+            if new_qty > available_qty:
+                conn.close()
+                return f"Insufficient quantity. Available: {available_qty}"
+            c.execute("UPDATE carts SET quantity = ? WHERE user_id = ? AND item_id = ?",
+                      (new_qty, user_id, item_id))
+        else:
+            if quantity > available_qty:
+                conn.close()
+                return f"Insufficient quantity. Available: {available_qty}"
+            c.execute("INSERT INTO carts (user_id, item_id, quantity, added_date) VALUES (?, ?, ?, ?)",
+                      (user_id, item_id, quantity, current_date))
+        
+        conn.commit()
+        conn.close()
+        return f"🛒 Added to cart: {quantity}x {item_name}"
+    except Exception as e:
+        conn.close()
+        logger.error(f"Inventory: Error adding to cart: {e}")
+        return "Error adding to cart."
+
+def remove_from_cart(user_id, item_name):
+    """Remove item from user's cart"""
+    conn = sqlite3.connect(inventory_db)
+    c = conn.cursor()
+    
+    try:
+        c.execute("""DELETE FROM carts 
+                     WHERE user_id = ? AND item_id = (SELECT item_id FROM items WHERE item_name = ?)""",
+                  (user_id, item_name))
+        if c.rowcount == 0:
+            conn.close()
+            return f"Item '{item_name}' not in cart."
+        
+        conn.commit()
+        conn.close()
+        return f"🗑️ Removed from cart: {item_name}"
+    except Exception as e:
+        conn.close()
+        logger.error(f"Inventory: Error removing from cart: {e}")
+        return "Error removing from cart."
+
+def list_cart(user_id):
+    """List items in user's cart"""
+    conn = sqlite3.connect(inventory_db)
+    c = conn.cursor()
+    
+    try:
+        c.execute("""SELECT i.item_name, i.item_price, c.quantity
+                     FROM carts c
+                     JOIN items i ON c.item_id = i.item_id
+                     WHERE c.user_id = ?""", (user_id,))
+        items = c.fetchall()
+        conn.close()
+        
+        if not items:
+            return "🛒 Cart is empty."
+        
+        result = "🛒 Your Cart:\n"
+        total = 0
+        for name, price, qty in items:
+            subtotal = price * qty
+            total += subtotal
+            result += f"{name}: ${price:.2f} x {qty} = ${subtotal:.2f}\n"
+        
+        total = round_price(total, is_taxed_sale=True)
+        result += f"\nTotal: ${total:.2f}"
+        return result
+    except Exception as e:
+        conn.close()
+        logger.error(f"Inventory: Error listing cart: {e}")
+        return "Error listing cart."
+
+def checkout_cart(user_id, user_name="", transaction_type="SALE", notes=""):
+    """Process cart as a transaction"""
+    conn = sqlite3.connect(inventory_db)
+    c = conn.cursor()
+    current_date = time.strftime("%Y-%m-%d")
+    current_time = time.strftime("%H:%M:%S")
+    
+    try:
+        # Get cart items
+        c.execute("""SELECT i.item_id, i.item_name, i.item_price, c.quantity, i.item_quantity
+                     FROM carts c
+                     JOIN items i ON c.item_id = i.item_id
+                     WHERE c.user_id = ?""", (user_id,))
+        cart_items = c.fetchall()
+        
+        if not cart_items:
+            conn.close()
+            return "Cart is empty."
+        
+        # Verify all items have sufficient quantity
+        for item_id, name, price, cart_qty, stock_qty in cart_items:
+            if stock_qty < cart_qty:
+                conn.close()
+                return f"Insufficient quantity for '{name}'. Available: {stock_qty}"
+        
+        # Calculate total
+        total = sum(price * qty for _, _, price, qty, _ in cart_items)
+        total = round_price(total, is_taxed_sale=(transaction_type == "SALE"))
+        
+        # Create transaction
+        c.execute("""INSERT INTO transactions (transaction_type, transaction_date, transaction_time,
+                     user_name, total_amount, notes)
+                     VALUES (?, ?, ?, ?, ?, ?)""",
+                  (transaction_type, current_date, current_time, user_name, total, notes))
+        transaction_id = c.lastrowid
+        
+        # Process each item
+        for item_id, name, price, quantity, _ in cart_items:
+            # Add to transaction items
+            c.execute("""INSERT INTO transaction_items (transaction_id, item_id, quantity, price_at_sale)
+                         VALUES (?, ?, ?, ?)""",
+                      (transaction_id, item_id, quantity, price))
+            
+            # Update inventory (subtract for SALE, add for BUY)
+            if transaction_type == "SALE":
+                c.execute("UPDATE items SET item_quantity = item_quantity - ?, updated_date = ? WHERE item_id = ?",
+                          (quantity, current_date, item_id))
+            else:  # BUY
+                c.execute("UPDATE items SET item_quantity = item_quantity + ?, updated_date = ? WHERE item_id = ?",
+                          (quantity, current_date, item_id))
+        
+        # Clear cart
+        c.execute("DELETE FROM carts WHERE user_id = ?", (user_id,))
+        
+        conn.commit()
+        conn.close()
+        
+        emoji = "💰" if transaction_type == "SALE" else "📦"
+        return f"{emoji} Transaction #{transaction_id} completed: ${total:.2f}"
+    except Exception as e:
+        conn.close()
+        logger.error(f"Inventory: Error processing cart: {e}")
+        return "Error processing cart."
+
+def clear_cart(user_id):
+    """Clear user's cart"""
+    conn = sqlite3.connect(inventory_db)
+    c = conn.cursor()
+    
+    try:
+        c.execute("DELETE FROM carts WHERE user_id = ?", (user_id,))
+        conn.commit()
+        conn.close()
+        return "🗑️ Cart cleared."
+    except Exception as e:
+        conn.close()
+        logger.error(f"Inventory: Error clearing cart: {e}")
+        return "Error clearing cart."
+
+def process_inventory_command(nodeID, message, name="none"):
+    """Process inventory and POS commands"""
+    # Check ban list
+    if str(nodeID) in bbs_ban_list:
+        logger.warning("System: Inventory attempt from the ban list")
+        return "Unable to process command"
+    
+    message_lower = message.lower()
+    parts = message.split()
+    
+    try:
+        # Help command
+        if "?" in message_lower:
+            return get_inventory_help()
+        
+        # Item management commands
+        if message_lower.startswith("itemadd "):
+            # itemadd <name> <qty> [price] [location]
+            if len(parts) < 3:
+                return "Usage: itemadd <name> <qty> [price] [location]"
+            item_name = parts[1]
+            try:
+                quantity = int(parts[2])
+            except ValueError:
+                return "Invalid quantity."
+            price = 0.0
+            location = ""
+            if len(parts) > 3:
+                try:
+                    price = float(parts[3])
+                    location = " ".join(parts[4:]) if len(parts) > 4 else ""
+                except ValueError:
+                    # If price is omitted, treat parts[3] as location
+                    price = 0.0
+                    location = " ".join(parts[3:])
+            return add_item(item_name, price, quantity, location)
+        
+        elif message_lower.startswith("itemremove "):
+            item_name = " ".join(parts[1:])
+            return remove_item(item_name)
+        
+        elif message_lower.startswith("itemreset "):
+            # itemreset name [price=X] [quantity=Y]
+            if len(parts) < 2:
+                return "Usage: itemreset <name> [price=X] [quantity=Y]"
+            item_name = parts[1]
+            price = None
+            quantity = None
+            for part in parts[2:]:
+                if part.startswith("price="):
+                    try:
+                        price = float(part.split("=")[1])
+                    except ValueError:
+                        return "Invalid price value."
+                elif part.startswith("quantity=") or part.startswith("qty="):
+                    try:
+                        quantity = int(part.split("=")[1])
+                    except ValueError:
+                        return "Invalid quantity value."
+            return reset_item(item_name, price, quantity)
+        
+        elif message_lower.startswith("itemsell "):
+            # itemsell name quantity [notes]
+            if len(parts) < 3:
+                return "Usage: itemsell <name> <quantity> [notes]"
+            item_name = parts[1]
+            try:
+                quantity = int(parts[2])
+                notes = " ".join(parts[3:]) if len(parts) > 3 else ""
+                return sell_item(item_name, quantity, name, notes)
+            except ValueError:
+                return "Invalid quantity."
+        
+        elif message_lower.startswith("itemreturn "):
+            # itemreturn transaction_id
+            if len(parts) < 2:
+                return "Usage: itemreturn <transaction_id>"
+            try:
+                transaction_id = int(parts[1])
+                return return_item(transaction_id)
+            except ValueError:
+                return "Invalid transaction ID."
+        
+        elif message_lower.startswith("itemloan "):
+            # itemloan <name> <note>
+            if len(parts) < 3:
+                return "Usage: itemloan <name> <note>"
+            item_name = parts[1]
+            note = " ".join(parts[2:])
+            return loan_item(item_name, name, note)
+        
+        elif message_lower == "itemlist":
+            return list_items()
+        
+        elif message_lower == "itemstats":
+            return get_stats()
+        
+        # Cart commands
+        elif message_lower.startswith("cartadd "):
+            # cartadd name quantity
+            if len(parts) < 3:
+                return "Usage: cartadd <name> <quantity>"
+            item_name = parts[1]
+            try:
+                quantity = int(parts[2])
+                return add_to_cart(str(nodeID), item_name, quantity)
+            except ValueError:
+                return "Invalid quantity."
+        
+        elif message_lower.startswith("cartremove "):
+            item_name = " ".join(parts[1:])
+            return remove_from_cart(str(nodeID), item_name)
+        
+        elif message_lower == "cartlist" or message_lower == "cart":
+            return list_cart(str(nodeID))
+        
+        elif message_lower.startswith("cartbuy") or message_lower.startswith("cartsell"):
+            transaction_type = "BUY" if "buy" in message_lower else "SALE"
+            notes = " ".join(parts[1:]) if len(parts) > 1 else ""
+            return checkout_cart(str(nodeID), name, transaction_type, notes)
+        
+        elif message_lower == "cartclear":
+            return clear_cart(str(nodeID))
+        
+        else:
+            return "Invalid command. Send 'item?' for help."
+    
+    except Exception as e:
+        logger.error(f"Inventory: Error processing command: {e}")
+        return "Error processing command."
+
+def get_inventory_help():
+    """Return help text for inventory commands"""
+    return (
+        "📦 Inventory Commands:\n"
+        "  itemadd <name> <qty> [price] [loc]\n"
+        "  itemremove <name>\n"
+        "  itemreset name> <qty> [price] [loc]\n"
+        "  itemsell <name> <qty> [notes]\n"
+        "  itemloan <name> <note>\n"
+        "  itemreturn <transaction_id>\n"
+        "  itemlist\n"
+        "  itemstats\n"
+        "\n"
+        "🛒 Cart Commands:\n"
+        "  cartadd <name> <qty>\n"
+        "  cartremove <name>\n"
+        "  cartlist\n"
+        "  cartbuy/cartsell [notes]\n"
+        "  cartclear\n"
+    )

modules/llm.md

@@ -0,0 +1,88 @@
+# How do I use this thing?
+This is not a full turnkey setup yet?
+
+
+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.
+
+
+# Ollama local
+```bash
+# bash
+curl -fsSL https://ollama.com/install.sh | sh
+# docker
+docker run -d -p 3000:8080 --add-host=host.docker.internal:host-gateway -e OLLAMA_API_BASE_URL=http://host.docker.internal:11434 open-webui/open-webui
+```
+
+## Update /etc/systemd/system/ollama.service
+https://github.com/ollama/ollama/issues/703
+```ini
+#service file addition not config.ini
+# [Service]
+Environment="OLLAMA_HOST=0.0.0.0:11434"
+```
+## validation
+http://IP::11434
+`Ollama is running`
+
+## Docs
+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? 
+
+---
+
+# OpenWebUI (docker)
+```bash
+## ollama in docker
+docker run -d -p 3000:8080 --gpus all -v open-webui:/app/backend/data --name open-webui ghcr.io/open-webui/open-webui:cuda
+
+## external ollama
+docker run -d -p 3000:8080 -e OLLAMA_BASE_URL=https://IP:11434 -v open-webui:/app/backend/data --name open-webui --restart always ghcr.io/open-webui/open-webui:main
+```
+wait for engine to build, update the config.ini for the bot
+
+```ini
+# Use OpenWebUI instead of direct Ollama API (enables advanced RAG features)
+useOpenWebUI = False
+# OpenWebUI server URL (e.g., http://localhost:3000)
+openWebUIURL = http://localhost:3000
+# OpenWebUI API key/token (required when useOpenWebUI is True)
+openWebUIAPIKey = sk-xxxx (see below for help)
+```
+
+## Validation
+http://IP:3000
+make a new admin user.
+validate you have models imported or that the system is working for query.
+make a new user for the bot
+
+## API Key
+- upper right settings for the user
+- settings -> account
+- get/create the API key for the user
+
+## Troubleshooting
+- make sure the OpenWebUI works from the bot node and loads (try lynx etc)
+- make sure the model in config.ini is also loaded in OpenWebUI and you can use it
+- make sure **OpenWebUI** can reach **Ollama IP** it should auto import the models
+- I find using IP and not common use names like localhost which may not work well with docker etc..
+
+- Check OpenWebUI and Ollama are working
+  - Go to Admin Settings within Open WebUI.
+  - Connections tab
+  - Ollama connection and click on the Manage (wrench icon)
+  - download models directly from the Ollama library
+  - **Once the model is downloaded or imported, it will become available for use within Open WebUI, allowing you to interact with it through the chat interface**
+
+## Docs
+[OpenWebUI Quick Start](https://docs.openwebui.com/getting-started/quick-start/)
+[OpenWebUI API](https://docs.openwebui.com/getting-started/api-endpoints)
+[OpenWebUI Ollama](https://docs.openwebui.com/getting-started/quick-start/starting-with-ollama/)
+[Blog OpenWebUI on Pi](https://pimylifeup.com/raspberry-pi-open-webui/)
+
+https://docs.openwebui.com/tutorials/tips/rag-tutorial#tutorial-configuring-rag-with-open-webui-documentation
+https://docs.openwebui.com/features/plugin/
+
+
+
+
+
+---

modules/llm.py

@@ -2,29 +2,29 @@
 # LLM Module for meshing-around
 # This module is used to interact with LLM API to generate responses to user input
 # K7MHI Kelly Keeton 2024
-from modules.log import *
+from modules.log import logger
+from modules.settings import (llmModel, ollamaHostName, rawLLMQuery, 
+                              llmUseWikiContext, useOpenWebUI, openWebUIURL, openWebUIAPIKey, cmdBang, urlTimeoutSeconds, use_kiwix_server)
 
 # 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
+from datetime import datetime
+if llmUseWikiContext or use_kiwix_server:
+    from modules.wiki import get_wikipedia_summary, get_kiwix_summary
 
 # LLM System Variables
 ollamaAPI = ollamaHostName + "/api/generate"
+openWebUIChatAPI = openWebUIURL + "/api/chat/completions"
+openWebUIOllamaProxy = openWebUIURL + "/ollama/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!
+requestTruncation = True # if True, the LLM "will" truncate the response
+DEBUG_LLM = False # enable debug logging for LLM queries
 
 # 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
 antiFloodLLM = []
 llmChat_history = {}
 trap_list_llm = ("ask:", "askai")
@@ -50,24 +50,6 @@ meshBotAI = """
 
     """
 
-if llmContext_fromGoogle:
-    meshBotAI = meshBotAI + """
-    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}
-
-    """
-else:
-    meshBotAI = meshBotAI + """
-    CONTEXT
-    The following is the location of the user
-    {location_name}
-
-    """
-
 if llmEnableHistory:
     meshBotAI = meshBotAI + """
     HISTORY
@@ -99,22 +81,6 @@ def llmTool_math_calculator(expression):
     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 = [
 
     {
@@ -139,54 +105,176 @@ llmFunctions = [
             "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 = []
+def get_wiki_context(input):
+    """
+    Get context from Wikipedia/Kiwix for RAG enhancement
+    :param input: The user query
+    :return: Wikipedia summary or empty string if not available
+    """
     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']
+        # Extract potential search terms from the input
+        # Try to identify key topics/entities for Wikipedia search
+        search_terms = extract_search_terms(input)
+        
+        wiki_context = []
+        for term in search_terms[:2]:  # Limit to 2 searches to avoid excessive API calls
+            if use_kiwix_server:
+                summary = get_kiwix_summary(term, truncate=False)
+            else:
+                summary = get_wikipedia_summary(term, truncate=False)
+
+            if summary and "error" not in summary.lower() or "html://" not in summary or "ambiguous" not in summary.lower():
+                wiki_context.append(f"Wikipedia context for '{term}': {summary}")
+        
+        return '\n'.join(wiki_context) if wiki_context else ''
     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
+        logger.debug(f"System: LLM Query: Wiki context gathering failed: {e}")
+        return ''
+    
+def llm_extract_topic(input):
+    """
+    Use LLM to extract the main topic as a single word or short phrase.
+    Always uses raw mode and supports both Ollama and OpenWebUI.
+    :param input: The user query
+    :return: List with one topic string, or empty list on failure
+    """
+    prompt = (
+        "Summarize the following query into a single word or short phrase that best represents the main topic, "
+        "for use as a Wikipedia search term. Only return the word or phrase, nothing else:\n"
+        f"{input}"
+    )
+    try:
+        if useOpenWebUI and openWebUIAPIKey:
+            result = send_openwebui_query(prompt, max_tokens=10)
+        else:
+            llmQuery = {"model": llmModel, "prompt": prompt, "stream": False, "max_tokens": 10}
+            result = send_ollama_query(llmQuery)
+        topic = result.strip().split('\n')[0]
+        topic = topic.strip(' "\'.,!?;:')
+        if topic:
+            return [topic]
+    except Exception as e:
+        logger.debug(f"LLM topic extraction failed: {e}")
+    return []
+
+def extract_search_terms(input):
+    """
+    Extract potential search terms from user input.
+    Enhanced: Try LLM-based topic extraction first, fallback to heuristic.
+    :param input: The user query
+    :return: List of potential search terms
+    """
+    # Remove common command prefixes
+    for trap in trap_list_llm:
+        if input.lower().startswith(trap):
+            input = input[len(trap):].strip()
+            break
+
+    # Try LLM-based extraction first
+    terms = llm_extract_topic(input)
+    if terms:
+        return terms
+
+    # Fallback: Simple heuristic (existing code)
+    words = input.split()
+    search_terms = []
+    temp_phrase = []
+    for word in words:
+        clean_word = word.strip('.,!?;:')
+        if clean_word and clean_word[0].isupper() and len(clean_word) > 2:
+            temp_phrase.append(clean_word)
+        elif temp_phrase:
+            search_terms.append(' '.join(temp_phrase))
+            temp_phrase = []
+    if temp_phrase:
+        search_terms.append(' '.join(temp_phrase))
+    if not search_terms:
+        search_terms = [input.strip()]
+    if DEBUG_LLM:
+        logger.debug(f"Extracted search terms: {search_terms}")
+    return search_terms[:3]  # Limit to 3 terms
+
+def send_openwebui_query(prompt, model=None, max_tokens=450, context=''):
+    """
+    Send query to OpenWebUI API for chat completion
+    :param prompt: The user prompt
+    :param model: Model name (optional, defaults to llmModel)
+    :param max_tokens: Max tokens for response
+    :param context: Additional context to include
+    :return: Response text or error message
+    """
+    if model is None:
+        model = llmModel
+
+    headers = {
+        'Authorization': f'Bearer {openWebUIAPIKey}',
+        'Content-Type': 'application/json'
+    }
+
+    messages = []
+    if context:
+        messages.append({
+            "role": "system",
+            "content": f"Use the following context to help answer questions:\n{context}"
+        })
+
+    messages.append({
+        "role": "user",
+        "content": prompt
+    })
+
+    data = {
+        "model": model,
+        "messages": messages,
+        "max_tokens": max_tokens,
+        "stream": False
+    }
+
+    # Debug logging
+    if DEBUG_LLM:
+        logger.debug(f"OpenWebUI payload: {json.dumps(data)}")
+        logger.debug(f"OpenWebUI endpoint: {openWebUIChatAPI}")
+
+    try:
+        result = requests.post(openWebUIChatAPI, headers=headers, json=data, timeout=urlTimeoutSeconds * 5)
+        if DEBUG_LLM:
+            logger.debug(f"OpenWebUI response status: {result.status_code}")
+            logger.debug(f"OpenWebUI response text: {result.text}")
+        if result.status_code == 200:
+            result_json = result.json()
+            # OpenWebUI returns OpenAI-compatible format
+            if 'choices' in result_json and len(result_json['choices']) > 0:
+                response = result_json['choices'][0]['message']['content']
+                return response.strip()
+            else:
+                logger.warning(f"System: OpenWebUI API returned unexpected format")
+                return "⛔️ Response Error"
+        else:
+            logger.warning(f"System: OpenWebUI API returned status code {result.status_code}")
+            return f"⛔️ Request Error"
+    except requests.exceptions.RequestException as e:
+        logger.warning(f"System: OpenWebUI API request failed: {e}")
+        return f"⛔️ Request Error"
 
 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
+    try:
+        result = requests.post(ollamaAPI, data=json.dumps(llmQuery), timeout= urlTimeoutSeconds * 5)
+        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:
+            logger.warning(f"System: LLM Query: Ollama API returned status code {result.status_code}")
+            return f"⛔️ Request Error"
+        return result
+    except requests.exceptions.RequestException as e:
+        logger.warning(f"System: LLM Query: Ollama API request failed: {e}")
+        return f"⛔️ Request Error"
 
 def send_ollama_tooling_query(prompt, functions, model=None, max_tokens=450):
     """
@@ -212,24 +300,28 @@ def send_ollama_tooling_query(prompt, functions, model=None, max_tokens=450):
     else:
         raise Exception(f"HTTP Error: {result.status_code} - {result.text}")
 
-def llm_query(input, nodeID=0, location_name=None):
+def llm_query(input, nodeID=0, location_name=None, init=False):
     global antiFloodLLM, llmChat_history
-    googleResults = []
+    wikiContext = ''
 
     # 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:
+    if init 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:
+    elif init:
         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")
+        logger.debug(f"System: Using SYSTEM model framework, ideally for gemma2, deepseek-r1, etc")
 
     if not location_name:
         location_name = "no location provided "
+
+    # Remove command bang if present
+    if cmdBang and input.startswith('!'):
+        input = input.strip('!').strip()
     
-    # remove askai: and ask: from the input
+    # Remove any trap words from the start of the input
     for trap in trap_list_llm:
         if input.lower().startswith(trap):
             input = input[len(trap):].strip()
@@ -244,34 +336,84 @@ def llm_query(input, nodeID=0, location_name=None):
     else:
         antiFloodLLM.append(nodeID)
 
-    if llmContext_fromGoogle and not rawLLMQuery:
-        googleResults = get_google_context(input, googleSearchResults)
+    # Get Wikipedia/Kiwix context if enabled (RAG)
+    if llmUseWikiContext and input != meshbotAIinit:
+        # get_wiki_context returns a string, but we want to count the items before joining
+        search_terms = extract_search_terms(input)
+        wiki_context_list = []
+        for term in search_terms[:2]:
+            if not use_kiwix_server:
+                summary = get_wiki_context(term)
+            else:
+                summary = get_wiki_context(term)
+            if summary and "error" not in summary.lower():
+                wiki_context_list.append(f"Wikipedia context for '{term}': {summary}")
+        wikiContext = '\n'.join(wiki_context_list) if wiki_context_list else ''
+        if wikiContext:
+            logger.debug(f"System: using Wikipedia/Kiwix context for LLM query got {len(wiki_context_list)} results")
 
     history = llmChat_history.get(nodeID, ["", ""])
-
-    if googleResults:
-        logger.debug(f"System: Google-Enhanced LLM Query: {input} From:{nodeID}")
-    else:
-        logger.debug(f"System: LLM Query: {input} From:{nodeID}")
     
     response = ""
     result = ""
     location_name += f" at the current time of {datetime.now().strftime('%Y-%m-%d %H:%M:%S %Z')}"
 
     try:
-        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)
+        # Use OpenWebUI if enabled
+        if useOpenWebUI and openWebUIAPIKey:
+            logger.debug(f"System: LLM Query: Using OpenWebUI API for LLM query {input} From:{nodeID}")
             
-        llmQuery = {"model": llmModel, "prompt": modelPrompt, "stream": False, "max_tokens": tokens}
-        # Query the model via Ollama web API
-        result = send_ollama_query(llmQuery)
+            # Combine all context sources
+            combined_context = []
+            if wikiContext:
+                combined_context.append(wikiContext)
+            
+            context_str = '\n\n'.join(combined_context)
+            
+            # For OpenWebUI, we send a cleaner prompt
+            if rawLLMQuery:
+                result = send_openwebui_query(input, context=context_str, max_tokens=tokens)
+            else:
+                # Use the template for non-raw queries
+                modelPrompt = meshBotAI.format(
+                    input=input, 
+                    context=context_str if combined_context else 'no other context provided',
+                    location_name=location_name, 
+                    llmModel=llmModel, 
+                    history=history
+                )
+                result = send_openwebui_query(modelPrompt, max_tokens=tokens)
+        else:
+            logger.debug(f"System: LLM Query: Using Ollama API for LLM query {input} From:{nodeID}")
+            # Use standard Ollama API
+            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
+                
+                # Add wiki context to raw queries if available
+                if wikiContext:
+                    modelPrompt = f"Context:\n{wikiContext}\n\nQuestion: {input}"
+            else:
+                # Build the query from the template
+                all_context = []
+                if wikiContext:
+                    all_context.append(wikiContext)
+                
+                context_text = '\n'.join(all_context) if all_context else 'no other context provided'
+                modelPrompt = meshBotAI.format(
+                    input=input, 
+                    context=context_text,
+                    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:
@@ -283,13 +425,17 @@ def llm_query(input, nodeID=0, location_name=None):
     response = result.strip().replace('\n', ' ')
     
     if rawLLMQuery and requestTruncation and len(response) > 450:
-        #retryy loop to truncate the response
+        # retry 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)
+        truncate_prompt_full = truncatePrompt + response
+        if useOpenWebUI and openWebUIAPIKey:
+            truncateResult = send_openwebui_query(truncate_prompt_full, max_tokens=tokens)
+        else:
+            truncateQuery = {"model": llmModel, "prompt": truncate_prompt_full, "stream": False, "max_tokens": tokens}
+            truncateResult = send_ollama_query(truncateQuery)
 
         # cleanup for message output
-        response = result.strip().replace('\n', ' ')
+        response = truncateResult.strip().replace('\n', ' ')
 
     # done with the query, remove the user from the anti flood list
     antiFloodLLM.remove(nodeID)

modules/locationdata.py

@@ -6,12 +6,16 @@ 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 *
+import xml.dom.minidom # used for parsing XML
+import xml.parsers.expat # used for parsing XML
+from datetime import datetime
+from modules.log import logger
+import modules.settings as my_settings
 import math
+import csv
+import os
 
-
-trap_list_location = ("whereami", "wx", "wxa", "wxalert", "rlist", "ea", "ealert", "riverflow", "valert", "earthquake", "howfar")
+trap_list_location = ("whereami", "wx", "wxa", "wxalert", "rlist", "ea", "ealert", "riverflow", "valert", "earthquake", "howfar", "map",)
 
 def where_am_i(lat=0, lon=0, short=False, zip=False):
     whereIam = ""
@@ -20,7 +24,7 @@ def where_am_i(lat=0, lon=0, short=False, zip=False):
     
     if int(float(lat)) == 0 and int(float(lon)) == 0:
         logger.error("Location: No GPS data, try sending location")
-        return NO_DATA_NOGPS
+        return my_settings.NO_DATA_NOGPS
     
     # initialize Nominatim API
     geolocator = Nominatim(user_agent="mesh-bot")
@@ -40,7 +44,7 @@ def where_am_i(lat=0, lon=0, short=False, zip=False):
             whereIam = location.raw['address'].get('postcode', '')
             return whereIam
         
-        if float(lat) == latitudeValue and float(lon) == longitudeValue:
+        if float(lat) == my_settings.latitudeValue and float(lon) == my_settings.longitudeValue:
             # redacted address when no GPS and using default location
             location = geolocator.reverse(str(lat) + ", " + str(lon))
             address = location.raw['address']
@@ -69,7 +73,7 @@ def where_am_i(lat=0, lon=0, short=False, zip=False):
         return whereIam
     except Exception as e:
         logger.debug("Location:Error fetching location data with whereami, likely network error")
-        return ERROR_FETCHING_DATA
+        return my_settings.ERROR_FETCHING_DATA
     
 def getRepeaterBook(lat=0, lon=0):
     grid = mh.to_maiden(float(lat), float(lon))
@@ -87,7 +91,7 @@ def getRepeaterBook(lat=0, lon=0):
     try:
         msg = ''
         user_agent = {'User-agent': 'Mozilla/5.0'}
-        response = requests.get(repeater_url, headers=user_agent, timeout=urlTimeoutSeconds)
+        response = requests.get(repeater_url, headers=user_agent, timeout=my_settings.urlTimeoutSeconds)
         if response.status_code!=200:
             logger.error(f"Location:Error fetching repeater data from {repeater_url} with status code {response.status_code}")
         soup = bs.BeautifulSoup(response.text, 'html.parser')
@@ -126,13 +130,13 @@ def getArtSciRepeaters(lat=0, lon=0):
     #grid = mh.to_maiden(float(lat), float(lon))
     repeaters = []
     zipCode = where_am_i(lat, lon, zip=True)
-    if zipCode == NO_DATA_NOGPS or zipCode == ERROR_FETCHING_DATA:
+    if zipCode == my_settings.NO_DATA_NOGPS or zipCode == my_settings.ERROR_FETCHING_DATA:
         return zipCode
 
     if zipCode.isnumeric():
         try:
             artsci_url = f"http://www.artscipub.com/mobile/showstate.asp?zip={zipCode}"
-            response = requests.get(artsci_url)
+            response = requests.get(artsci_url, timeout=my_settings.urlTimeoutSeconds)
             if response.status_code!=200:
                 logger.error(f"Location:Error fetching data from {artsci_url} with status code {response.status_code}")
             soup = bs.BeautifulSoup(response.text, 'html.parser')
@@ -171,19 +175,20 @@ def getArtSciRepeaters(lat=0, lon=0):
     return msg
 
 def get_NOAAtide(lat=0, lon=0):
+    # get tide data from NOAA for lat/lon
     station_id = ""
     location = lat,lon
     if float(lat) == 0 and float(lon) == 0:
-        logger.error("Location:No GPS data, try sending location for tide")
-        return NO_DATA_NOGPS
+        lat = my_settings.latitudeValue
+        lon = my_settings.longitudeValue
     station_lookup_url = "https://api.tidesandcurrents.noaa.gov/mdapi/prod/webapi/tidepredstations.json?lat=" + str(lat) + "&lon=" + str(lon) + "&radius=50"
     try:
-        station_data = requests.get(station_lookup_url, timeout=urlTimeoutSeconds)
+        station_data = requests.get(station_lookup_url, timeout=my_settings.urlTimeoutSeconds)
         if station_data.ok:
             station_json = station_data.json()
         else:
             logger.error("Location:Error fetching tide station table from NOAA")
-            return ERROR_FETCHING_DATA
+            return my_settings.ERROR_FETCHING_DATA
         
         if station_json['stationList'] == [] or station_json['stationList'] is None:
             logger.error("Location:No tide station found")
@@ -193,26 +198,26 @@ def get_NOAAtide(lat=0, lon=0):
 
     except (requests.exceptions.RequestException, json.JSONDecodeError):
         logger.error("Location:Error fetching tide station table from NOAA")
-        return ERROR_FETCHING_DATA
+        return my_settings.ERROR_FETCHING_DATA
     
     station_url = "https://api.tidesandcurrents.noaa.gov/api/prod/datagetter?date=today&time_zone=lst_ldt&datum=MLLW&product=predictions&interval=hilo&format=json&station=" + station_id
 
-    if use_metric:
+    if my_settings.use_metric:
         station_url += "&units=metric"
     else:
         station_url += "&units=english"
 
     try:
-        tide_data = requests.get(station_url, timeout=urlTimeoutSeconds)
+        tide_data = requests.get(station_url, timeout=my_settings.urlTimeoutSeconds)
         if tide_data.ok:
             tide_json = tide_data.json()
         else:
             logger.error("Location:Error fetching tide data from NOAA")
-            return ERROR_FETCHING_DATA
+            return my_settings.ERROR_FETCHING_DATA
 
     except (requests.exceptions.RequestException, json.JSONDecodeError):
         logger.error("Location:Error fetching tide data from NOAA")
-        return ERROR_FETCHING_DATA
+        return my_settings.ERROR_FETCHING_DATA
 
     tide_data = tide_json['predictions']
 
@@ -222,7 +227,7 @@ def get_NOAAtide(lat=0, lon=0):
     tide_table = "Tide Data for " + tide_date + "\n"
     for tide in tide_data:
         tide_time = tide['t'].split(" ")[1]
-        if not zuluTime:
+        if not my_settings.zuluTime:
             # convert to 12 hour clock
             if int(tide_time.split(":")[0]) > 12:
                 tide_time = str(int(tide_time.split(":")[0]) - 12) + ":" + tide_time.split(":")[1] + " PM"
@@ -234,15 +239,17 @@ def get_NOAAtide(lat=0, lon=0):
     tide_table = tide_table[:-1]
     return tide_table
     
-def get_NOAAweather(lat=0, lon=0, unit=0):
+def get_NOAAweather(lat=0, lon=0, unit=0, report_days=None):
     # get weather report from NOAA for forecast detailed
     weather = ""
     location = lat,lon
     if float(lat) == 0 and float(lon) == 0:
-        return NO_DATA_NOGPS
-    
+        lat = my_settings.latitudeValue
+        lon = my_settings.longitudeValue
+    if report_days is None:
+        report_days = my_settings.forecastDuration
     # get weather data from NOAA units for metric unit = 1 is metric
-    if use_metric:
+    if my_settings.use_metric:
         unit = 1
         logger.debug("Location: new API metric units not implemented yet")
         
@@ -250,29 +257,29 @@ def get_NOAAweather(lat=0, lon=0, unit=0):
     weather_api = "https://api.weather.gov/points/" + str(lat) + "," + str(lon)
     # extract the "forecast": property from the JSON response
     try:
-        weather_data = requests.get(weather_api, timeout=urlTimeoutSeconds)
+        weather_data = requests.get(weather_api, timeout=my_settings.urlTimeoutSeconds)
         if not weather_data.ok:
             logger.warning("Location:Error fetching weather data from NOAA for location")
-            return ERROR_FETCHING_DATA
-    except (requests.exceptions.RequestException):
-        logger.warning("Location:Error fetching weather data from NOAA for location")
-        return ERROR_FETCHING_DATA
+            return my_settings.ERROR_FETCHING_DATA
+    except Exception:
+        logger.warning(f"Location:Error fetching weather data error: {Exception}")
+        return my_settings.ERROR_FETCHING_DATA
     # get the forecast URL from the JSON response
     weather_json = weather_data.json()
     forecast_url = weather_json['properties']['forecast']
     try:
-        forecast_data = requests.get(forecast_url, timeout=urlTimeoutSeconds)
+        forecast_data = requests.get(forecast_url, timeout=my_settings.urlTimeoutSeconds)
         if not forecast_data.ok:
             logger.warning("Location:Error fetching weather forecast from NOAA")
-            return ERROR_FETCHING_DATA
-    except (requests.exceptions.RequestException):
-        logger.warning("Location:Error fetching weather forecast from NOAA")
-        return ERROR_FETCHING_DATA
+            return my_settings.ERROR_FETCHING_DATA
+    except Exception:
+        logger.warning(f"Location:Error fetching weather data error: {Exception}")
+        return my_settings.ERROR_FETCHING_DATA
     
     # from periods, get the detailedForecast from number of days in NOAAforecastDuration
     forecast_json = forecast_data.json()
     forecast = forecast_json['properties']['periods']
-    for day in forecast[:forecastDuration]:
+    for day in forecast[:report_days]:
         # abreviate the forecast
 
         weather += abbreviate_noaa(day['name']) + ": " + abbreviate_noaa(day['detailedForecast']) + "\n"
@@ -282,7 +289,7 @@ def get_NOAAweather(lat=0, lon=0, unit=0):
     # get any alerts and return the count
     alerts = getWeatherAlertsNOAA(lat, lon)
 
-    if alerts == ERROR_FETCHING_DATA or alerts == NO_DATA_NOGPS or alerts == NO_ALERTS:
+    if alerts == my_settings.ERROR_FETCHING_DATA or alerts == my_settings.NO_DATA_NOGPS or alerts == my_settings.NO_ALERTS:
         alert = ""
         alert_num = 0
     else:
@@ -322,6 +329,7 @@ def abbreviate_noaa(data=""):
         "between four and five inches possible": "4-5in",
         "between five and six inches possible": "5-6in",
         "between six and eight inches possible": "6-8in",
+        "gusts as high as": "gusts to",
     }
     # Single words (no spaces)
     word_replacements = {
@@ -367,6 +375,7 @@ def abbreviate_noaa(data=""):
         "temperature": "temp:",
         "amounts": "amts:",
         "afternoon": "Aftn",
+        "around": "~",
         "evening": "Eve",
     }
 
@@ -388,38 +397,37 @@ def getWeatherAlertsNOAA(lat=0, lon=0, useDefaultLatLon=False):
     # get weather alerts from NOAA limited to ALERT_COUNT with the total number of alerts found
     alerts = ""
     location = lat,lon
+    if useDefaultLatLon:
+        lat = my_settings.latitudeValue
+        lon = my_settings.longitudeValue
     if float(lat) == 0 and float(lon) == 0 and not useDefaultLatLon:
-        return NO_DATA_NOGPS
-    else:
-        if useDefaultLatLon:
-            lat = latitudeValue
-            lon = longitudeValue
+        return my_settings.NO_DATA_NOGPS
 
     alert_url = "https://api.weather.gov/alerts/active.atom?point=" + str(lat) + "," + str(lon)
     #alert_url = "https://api.weather.gov/alerts/active.atom?area=WA"
     #logger.debug("Location:Fetching weather alerts from NOAA for " + str(lat) + ", " + str(lon))
     
     try:
-        alert_data = requests.get(alert_url, timeout=urlTimeoutSeconds)
+        alert_data = requests.get(alert_url, timeout=my_settings.urlTimeoutSeconds)
         if not alert_data.ok:
             logger.warning("Location:Error fetching weather alerts from NOAA")
-            return ERROR_FETCHING_DATA
-    except (requests.exceptions.RequestException):
-        logger.warning("Location:Error fetching weather alerts from NOAA")
-        return ERROR_FETCHING_DATA
+            return my_settings.ERROR_FETCHING_DATA
+    except Exception:
+        logger.warning(f"Location:Error fetching weather data error: {Exception}")
+        return my_settings.ERROR_FETCHING_DATA
     
     alerts = ""
     alertxml = xml.dom.minidom.parseString(alert_data.text)
     for i in alertxml.getElementsByTagName("entry"):
         title = i.getElementsByTagName("title")[0].childNodes[0].nodeValue
         area_desc = i.getElementsByTagName("cap:areaDesc")[0].childNodes[0].nodeValue
-        if enableExtraLocationWx:
+        if my_settings.enableExtraLocationWx:
             alerts += f"{title}. {area_desc.replace(' ', '')}\n"
         else:
             alerts += f"{title}\n"
 
     if alerts == "" or alerts == None:
-        return NO_ALERTS
+        return my_settings.NO_ALERTS
 
     # trim off last newline
     if alerts[-1] == "\n":
@@ -432,23 +440,23 @@ def getWeatherAlertsNOAA(lat=0, lon=0, useDefaultLatLon=False):
     alerts = abbreviate_noaa(alerts)
 
     # return the first ALERT_COUNT alerts
-    data = "\n".join(alerts.split("\n")[:numWxAlerts]), alert_num
+    data = "\n".join(alerts.split("\n")[:my_settings.numWxAlerts]), alert_num
     return data
 
 wxAlertCacheNOAA = ""
 def alertBrodcastNOAA():
     # get the latest weather alerts and broadcast them if there are any
     global wxAlertCacheNOAA
-    currentAlert = getWeatherAlertsNOAA(latitudeValue, longitudeValue)
+    currentAlert = getWeatherAlertsNOAA(my_settings.latitudeValue, my_settings.longitudeValue)
     # check if any reason to discard the alerts
-    if currentAlert == ERROR_FETCHING_DATA or currentAlert == NO_DATA_NOGPS:
+    if currentAlert == my_settings.ERROR_FETCHING_DATA or currentAlert == my_settings.NO_DATA_NOGPS:
         return False
-    elif currentAlert == NO_ALERTS:
+    elif currentAlert == my_settings.NO_ALERTS:
         wxAlertCacheNOAA = ""
         return False
-    if ignoreEASenable:
+    if my_settings.ignoreEASenable:
         # check if the alert is in the ignoreEAS list
-        for word in ignoreEASwords:
+        for word in my_settings.ignoreEASwords:
             if word.lower() in currentAlert[0].lower():
                 logger.debug(f"Location:Ignoring NOAA Alert: {currentAlert[0]} containing {word}")
                 return False
@@ -466,21 +474,21 @@ def getActiveWeatherAlertsDetailNOAA(lat=0, lon=0):
     alerts = ""
     location = lat,lon
     if float(lat) == 0 and float(lon) == 0:
-        logger.warning("Location:No GPS data, try sending location for weather alerts")
-        return NO_DATA_NOGPS
+        lat = my_settings.latitudeValue
+        lon = my_settings.longitudeValue
 
     alert_url = "https://api.weather.gov/alerts/active.atom?point=" + str(lat) + "," + str(lon)
     #alert_url = "https://api.weather.gov/alerts/active.atom?area=WA"
     #logger.debug("Location:Fetching weather alerts detailed from NOAA for " + str(lat) + ", " + str(lon))
     
     try:
-        alert_data = requests.get(alert_url, timeout=urlTimeoutSeconds)
+        alert_data = requests.get(alert_url, timeout=my_settings.urlTimeoutSeconds)
         if not alert_data.ok:
             logger.warning("Location:Error fetching weather alerts from NOAA")
-            return ERROR_FETCHING_DATA
-    except (requests.exceptions.RequestException):
-        logger.warning("Location:Error fetching weather alerts from NOAA")
-        return ERROR_FETCHING_DATA
+            return my_settings.ERROR_FETCHING_DATA
+    except Exception:
+        logger.warning(f"Location:Error fetching weather data error: {Exception}")
+        return my_settings.ERROR_FETCHING_DATA
     
     alerts = ""
     alertxml = xml.dom.minidom.parseString(alert_data.text)
@@ -500,10 +508,10 @@ def getActiveWeatherAlertsDetailNOAA(lat=0, lon=0):
     alerts = abbreviate_noaa(alerts)
 
     # trim the alerts to the first ALERT_COUNT
-    alerts = alerts.split("\n***\n")[:numWxAlerts]
+    alerts = alerts.split("\n***\n")[:my_settings.numWxAlerts]
     
     if alerts == "" or alerts == ['']:
-        return NO_ALERTS
+        return my_settings.NO_ALERTS
 
     # trim off last newline
     if alerts[-1] == "\n":
@@ -525,13 +533,13 @@ def getIpawsAlert(lat=0, lon=0, shortAlerts = False):
 
     # get the alerts from FEMA
     try:
-        alert_data = requests.get(alert_url, timeout=urlTimeoutSeconds)
+        alert_data = requests.get(alert_url, timeout=my_settings.urlTimeoutSeconds)
         if not alert_data.ok:
-            logger.warning("System: iPAWS fetching IPAWS alerts from FEMA")
-            return ERROR_FETCHING_DATA
-    except (requests.exceptions.RequestException):
-        logger.warning("System: iPAWS fetching IPAWS alerts from FEMA")
-        return ERROR_FETCHING_DATA
+            logger.warning(f"System: iPAWS fetching IPAWS alerts from FEMA (HTTP {alert_data.status_code})")
+            return my_settings.ERROR_FETCHING_DATA
+    except Exception as e:
+        logger.warning(f"System: iPAWS fetching IPAWS alerts from FEMA failed: {e}")
+        return my_settings.ERROR_FETCHING_DATA
     
     # main feed bulletins
     alertxml = xml.dom.minidom.parseString(alert_data.text)
@@ -553,13 +561,13 @@ def getIpawsAlert(lat=0, lon=0, shortAlerts = False):
             continue
 
         # check if it matches your list
-        if stateFips not in myStateFIPSList:
-            #logger.debug(f"Skipping FEMA record link {link} with stateFIPS code of: {stateFips} because it doesn't match our StateFIPSList {myStateFIPSList}")
+        if stateFips not in my_settings.myStateFIPSList:
+            #logger.debug(f"Skipping FEMA record link {link} with stateFIPS code of: {stateFips} because it doesn't match our StateFIPSList {my_settings.myStateFIPSList}")
             continue  # skip to next entry
 
         try:
             # get the linked alert data from FEMA
-            linked_data = requests.get(link, timeout=urlTimeoutSeconds)
+            linked_data = requests.get(link, timeout=my_settings.urlTimeoutSeconds)
             if not linked_data.ok or not linked_data.text.strip():
                 # if the linked data is not ok, skip this alert
                 #logger.warning(f"System: iPAWS Error fetching linked alert data from {link}")
@@ -611,15 +619,14 @@ def getIpawsAlert(lat=0, lon=0, shortAlerts = False):
                 continue
 
              # check if the alert is for the SAME location, if wanted keep alert
-            if (sameVal in mySAMEList) or (geocode_value in mySAMEList) or mySAMEList == ['']:
-                # ignore the FEMA test alerts
-                if ignoreFEMAenable:
-                    ignore_alert = False
-                    for word in ignoreFEMAwords:
-                        if word.lower() in headline.lower():
-                            logger.debug(f"System: Filtering FEMA Alert by WORD: {headline} containing {word} at {areaDesc}")
-                            ignore_alert = True
-                            break
+            if (sameVal in my_settings.mySAMEList) or (geocode_value in my_settings.mySAMEList) or my_settings.mySAMEList == ['']:
+                ignore_alert = False
+                if my_settings.ignoreFEMAenable:
+                    ignore_alert = any(
+                        word.lower() in headline.lower()
+                        for word in my_settings.ignoreFEMAwords)
+                    if ignore_alert:
+                        logger.debug(f"System: Filtering FEMA Alert by WORD: {headline} containing one of {my_settings.ignoreFEMAwords} at {areaDesc}")
                 if ignore_alert:
                     continue
 
@@ -639,16 +646,16 @@ def getIpawsAlert(lat=0, lon=0, shortAlerts = False):
 
     # return the numWxAlerts of alerts
     if len(alerts) > 0:
-        for alertItem in alerts[:numWxAlerts]:
+        for alertItem in alerts[:my_settings.numWxAlerts]:
             if shortAlerts:
                 alert += abbreviate_noaa(f"🚨FEMA Alert: {alertItem['headline']}")
             else:
                 alert += abbreviate_noaa(f"🚨FEMA Alert: {alertItem['headline']}\n{alertItem['description']}")
             # add a newline if not the last alert    
-            if alertItem != alerts[:numWxAlerts][-1]:
+            if alertItem != alerts[:my_settings.numWxAlerts][-1]:
                 alert += "\n"
     else:
-        alert = NO_ALERTS
+        alert = my_settings.NO_ALERTS
 
     return alert
 
@@ -661,22 +668,22 @@ def get_flood_noaa(lat=0, lon=0, uid=None):
     headers = {'accept': 'application/json'}
     if not uid:
         logger.warning(f"Location:No flood gauge data found for UID {uid}")
-        return ERROR_FETCHING_DATA
+        return my_settings.ERROR_FETCHING_DATA
     try:
-        response = requests.get(api_url + str(uid), headers=headers, timeout=urlTimeoutSeconds)
+        response = requests.get(api_url + str(uid), headers=headers, timeout=my_settings.urlTimeoutSeconds)
         if not response.ok:
             logger.warning(f"Location:Error fetching flood gauge data from NOAA for {uid} (HTTP {response.status_code})")
-            return ERROR_FETCHING_DATA
+            return my_settings.ERROR_FETCHING_DATA
         data = response.json()
         if not data or 'status' not in data:
             logger.warning(f"Location:No flood gauge data found for UID {uid}")
             return "No flood gauge data found"
     except requests.exceptions.RequestException as e:
         logger.warning(f"Location:Error fetching flood gauge data from: {api_url}{uid} ({e})")
-        return ERROR_FETCHING_DATA
+        return my_settings.ERROR_FETCHING_DATA
     except Exception as e:
         logger.warning(f"Location:Unexpected error: {e}")
-        return ERROR_FETCHING_DATA
+        return my_settings.ERROR_FETCHING_DATA
 
     # extract values from JSON safely
     try:
@@ -692,35 +699,35 @@ def get_flood_noaa(lat=0, lon=0, uid=None):
         return flood_data
     except Exception as e:
         logger.debug(f"Location:Error extracting flood gauge data from NOAA for {uid}: {e}")
-        return ERROR_FETCHING_DATA
+        return my_settings.ERROR_FETCHING_DATA
 
 def get_volcano_usgs(lat=0, lon=0):
     alerts = ''
     if lat == 0 and lon == 0:
-        lat = latitudeValue
-        lon = longitudeValue
+        lat = my_settings.latitudeValue
+        lon = my_settings.longitudeValue
     # get the latest volcano alert from USGS from CAP feed
     usgs_volcano_url = "https://volcanoes.usgs.gov/hans-public/api/volcano/getCapElevated"
     try:
-        volcano_data = requests.get(usgs_volcano_url, timeout=urlTimeoutSeconds)
+        volcano_data = requests.get(usgs_volcano_url, timeout=my_settings.urlTimeoutSeconds)
         if not volcano_data.ok:
             logger.warning("System: Issue with fetching volcano alerts from USGS")
-            return ERROR_FETCHING_DATA
+            return my_settings.ERROR_FETCHING_DATA
     except (requests.exceptions.RequestException):
         logger.warning("System: Issue with fetching volcano alerts from USGS")
-        return ERROR_FETCHING_DATA
+        return my_settings.ERROR_FETCHING_DATA
     volcano_json = volcano_data.json()
     # extract alerts from main feed
     if volcano_json and isinstance(volcano_json, list):
         for alert in volcano_json:
             # check ignore list
-            if ignoreUSGSEnable:
-                for word in ignoreUSGSwords:
+            if my_settings.ignoreUSGSEnable:
+                for word in my_settings.ignoreUSGSwords:
                     if word.lower() in alert['volcano_name_appended'].lower():
                         logger.debug(f"System: Ignoring USGS Alert: {alert['volcano_name_appended']} containing {word}")
                         continue
             # check if the alert lat long is within the range of bot latitudeValue and longitudeValue
-            if (alert['latitude'] >= latitudeValue - 10 and alert['latitude'] <= latitudeValue + 10) and (alert['longitude'] >= longitudeValue - 10 and alert['longitude'] <= longitudeValue + 10):
+            if (alert['latitude'] >= my_settings.latitudeValue - 10 and alert['latitude'] <= my_settings.latitudeValue + 10) and (alert['longitude'] >= my_settings.longitudeValue - 10 and alert['longitude'] <= my_settings.longitudeValue + 10):
                 volcano_name = alert['volcano_name_appended']
                 alert_level = alert['alert_level']
                 color_code = alert['color_code']
@@ -733,9 +740,9 @@ def get_volcano_usgs(lat=0, lon=0):
                 continue
     else:
         logger.debug("Location:Error fetching volcano data from USGS")
-        return NO_ALERTS
+        return my_settings.NO_ALERTS
     if alerts == "":
-        return NO_ALERTS
+        return my_settings.NO_ALERTS
     # trim off last newline
     if alerts[-1] == "\n":
         alerts = alerts[:-1]
@@ -744,28 +751,31 @@ def get_volcano_usgs(lat=0, lon=0):
     return alerts
 
 def get_nws_marine(zone, days=3):
-    # forcast from NWS coastal products
+    # forecast from NWS coastal products
     try:
-        marine_pz_data = requests.get(zone, timeout=urlTimeoutSeconds)
+        marine_pz_data = requests.get(zone, timeout=my_settings.urlTimeoutSeconds)
         if not marine_pz_data.ok:
-            logger.warning("Location:Error fetching NWS Marine PZ data")
-            return ERROR_FETCHING_DATA
-    except (requests.exceptions.RequestException):
-        logger.warning("Location:Error fetching NWS Marine PZ data")
-        return ERROR_FETCHING_DATA
-    
+            logger.warning(f"Location:Error fetching NWS Marine data (HTTP {marine_pz_data.status_code})")
+            return my_settings.ERROR_FETCHING_DATA
+    except requests.exceptions.RequestException as e:
+        logger.warning(f"Location:Error fetching NWS Marine data: {e}")
+        return my_settings.ERROR_FETCHING_DATA
+
     marine_pz_data = marine_pz_data.text
-    #validate data
-    todayDate = today.strftime("%Y%m%d")
-    if marine_pz_data.startswith("Expires:"):
-        expires = marine_pz_data.split(";;")[0].split(":")[1]
-        expires_date = expires[:8]
-        if expires_date < todayDate:
-            logger.debug("Location: NWS Marine PZ data expired")
-            return ERROR_FETCHING_DATA
+    todayDate = datetime.now().strftime("%Y%m%d")
+    if marine_pz_data and marine_pz_data.startswith("Expires:"):
+        try:
+            expires = marine_pz_data.split(";;")[0].split(":")[1]
+            expires_date = expires[:8]
+            if expires_date < todayDate:
+                logger.debug("Location: NWS Marine PZ data expired")
+                return my_settings.ERROR_FETCHING_DATA
+        except Exception as e:
+            logger.debug(f"Location: NWS Marine PZ data parse error: {e}")
+            return my_settings.ERROR_FETCHING_DATA
     else:
-        logger.debug("Location: NWS Marine PZ data not valid")
-        return ERROR_FETCHING_DATA
+        logger.debug("Location: NWS Marine PZ data not valid or empty")
+        return my_settings.ERROR_FETCHING_DATA
     
     # process the marine forecast data
     marine_pzz_lines = marine_pz_data.split("\n")
@@ -787,7 +797,7 @@ def get_nws_marine(zone, days=3):
         day_blocks.append(current_block.strip())
 
     # Only keep up to pzDays blocks
-    for block in day_blocks[:days]:
+    for block in day_blocks[:my_settings.coastalForecastDays]:
         marine_pz_report += block + "\n"
 
     # remove last newline
@@ -801,13 +811,13 @@ def get_nws_marine(zone, days=3):
     # abbreviate the report
     marine_pz_report = abbreviate_noaa(marine_pz_report)
     if marine_pz_report == "":
-        return NO_DATA_NOGPS
+        return my_settings.NO_DATA_NOGPS
     return marine_pz_report
 
 def checkUSGSEarthQuake(lat=0, lon=0):
     if lat == 0 and lon == 0:
-        lat = latitudeValue
-        lon = longitudeValue
+        lat = my_settings.latitudeValue
+        lon = my_settings.longitudeValue
     radius = 100 # km
     magnitude = 1.5
     history = 7 # days
@@ -817,20 +827,20 @@ def checkUSGSEarthQuake(lat=0, lon=0):
     quake_count = 0
     # fetch the earthquake data from USGS
     try:
-        quake_data = requests.get(USGSquake_url, timeout=urlTimeoutSeconds)
+        quake_data = requests.get(USGSquake_url, timeout=my_settings.urlTimeoutSeconds)
         if not quake_data.ok:
             logger.warning("Location:Error fetching earthquake data from USGS")
-            return NO_ALERTS
+            return my_settings.NO_ALERTS
         if not quake_data.text.strip():
-            return NO_ALERTS
+            return my_settings.NO_ALERTS
         try:
             quake_xml = xml.dom.minidom.parseString(quake_data.text)
         except Exception as e:
             logger.warning(f"Location: USGS earthquake API returned invalid XML: {e}")
-            return NO_ALERTS
+            return my_settings.NO_ALERTS
     except (requests.exceptions.RequestException):
         logger.warning("Location:Error fetching earthquake data from USGS")
-        return NO_ALERTS
+        return my_settings.NO_ALERTS
 
     quake_xml = xml.dom.minidom.parseString(quake_data.text)
     quake_count = len(quake_xml.getElementsByTagName("event"))
@@ -846,7 +856,7 @@ def checkUSGSEarthQuake(lat=0, lon=0):
             description_text = event.getElementsByTagName("description")[0].getElementsByTagName("text")[0].childNodes[0].nodeValue
     largest_mag = round(largest_mag, 1)
     if quake_count == 0:
-        return NO_ALERTS
+        return my_settings.NO_ALERTS
     else:
         return f"{quake_count} 🫨quakes in last {history} days within {radius} km. Largest: {largest_mag}M\n{description_text}"
 
@@ -860,7 +870,7 @@ def distance(lat=0,lon=0,nodeID=0, reset=False):
     r = 6371 # Radius of earth in kilometers # haversine formula
     
     if lat == 0 and lon == 0:
-        return NO_DATA_NOGPS
+        return my_settings.NO_DATA_NOGPS
     if nodeID == 0:
         return "No NodeID provided"
     
@@ -892,7 +902,7 @@ def distance(lat=0,lon=0,nodeID=0, reset=False):
         c = 2 * math.asin(math.sqrt(a))
 
         distance_km = c * r
-        if use_metric:
+        if my_settings.use_metric:
             msg += f"{distance_km:.2f} km"
         else:
             distance_miles = distance_km * 0.621371
@@ -910,7 +920,7 @@ def distance(lat=0,lon=0,nodeID=0, reset=False):
         time_diff = datetime.now() - last_point['time']
         if time_diff.total_seconds() > 60:
             hours = time_diff.total_seconds() / 3600
-            if use_metric:
+            if my_settings.use_metric:
                 speed = distance_km / hours
                 speed_str = f"{speed:.2f} km/h"
             else:
@@ -934,7 +944,7 @@ def distance(lat=0,lon=0,nodeID=0, reset=False):
             total_distance_km += c * r
         # add the distance from last point to current point
         total_distance_km += distance_km
-        if use_metric:
+        if my_settings.use_metric:
             msg += f", Total: {total_distance_km:.2f} km"
         else:
             total_distance_miles = total_distance_km * 0.621371
@@ -967,7 +977,7 @@ def distance(lat=0,lon=0,nodeID=0, reset=False):
             area = area * (6378137 ** 2) / 2.0
             area = abs(area) / 1e6 # convert to square kilometers
 
-            if use_metric:
+            if my_settings.use_metric:
                 msg += f", Area: {area:.2f} sq.km (approx)"
             else:
                 area_miles = area * 0.386102
@@ -999,7 +1009,7 @@ def distance(lat=0,lon=0,nodeID=0, reset=False):
 def get_openskynetwork(lat=0, lon=0):
     # get the latest aircraft data from OpenSky Network in the area
     if lat == 0 and lon == 0:
-        return NO_ALERTS
+        return my_settings.NO_ALERTS
     # setup a bounding box of 50km around the lat/lon
     box_size = 0.45 # approx 50km
     # return limits for aircraft search
@@ -1012,18 +1022,19 @@ def get_openskynetwork(lat=0, lon=0):
     # fetch the aircraft data from OpenSky Network
     opensky_url = f"https://opensky-network.org/api/states/all?lamin={lamin}&lomin={lomin}&lamax={lamax}&lomax={lomax}"
     try:
-        aircraft_data = requests.get(opensky_url, timeout=urlTimeoutSeconds)
+        aircraft_data = requests.get(opensky_url, timeout=my_settings.urlTimeoutSeconds)
         if not aircraft_data.ok:
             logger.warning("Location:Error fetching aircraft data from OpenSky Network")
-            return ERROR_FETCHING_DATA
+            return my_settings.ERROR_FETCHING_DATA
     except (requests.exceptions.RequestException):
         logger.warning("Location:Error fetching aircraft data from OpenSky Network")
-        return ERROR_FETCHING_DATA
+        return my_settings.ERROR_FETCHING_DATA
     aircraft_json = aircraft_data.json()
     if 'states' not in aircraft_json or not aircraft_json['states']:
-        return NO_ALERTS
+        return my_settings.NO_ALERTS
     aircraft_list = aircraft_json['states']
     aircraft_report = ""
+    logger.debug(f"Location: OpenSky Network: Found {len(aircraft_list)} possible aircraft in area")
     for aircraft in aircraft_list:
         if len(aircraft_report.split("\n")) >= search_limit:
             break
@@ -1048,4 +1059,90 @@ def get_openskynetwork(lat=0, lon=0):
     if aircraft_report.endswith("\n"):
         aircraft_report = aircraft_report[:-1]
     aircraft_report = abbreviate_noaa(aircraft_report)
-    return aircraft_report if aircraft_report else NO_ALERTS
+    return aircraft_report if aircraft_report else my_settings.NO_ALERTS
+
+def log_locationData_toMap(userID, location, message):
+    """
+    Logs location data to a CSV file for meshing purposes.
+    Returns True if successful, False otherwise.
+    """
+    lat, lon = location
+    if lat is None or lon is None or lat == 0.0 or lon == 0.0:
+        return False
+
+    # Set default directory to ../data/
+    default_dir = os.path.join(os.path.dirname(__file__), "..", "data")
+    os.makedirs(default_dir, exist_ok=True)
+    map_filepath = os.path.join(default_dir, "map_data.csv")
+
+    # Check if the file exists to determine if we need to write headers
+    write_header = not os.path.isfile(map_filepath) or os.path.getsize(map_filepath) == 0
+
+    try:
+        with open(map_filepath, mode='a', newline='') as csvfile:
+            fieldnames = ['userID', 'Latitude', 'Longitude', 'Description']
+            writer = csv.DictWriter(csvfile, fieldnames=fieldnames)
+
+            # Write headers only if the file did not exist before or is empty
+            if write_header:
+                writer.writeheader()
+
+            writer.writerow({
+                'userID': userID,
+                'Latitude': lat,
+                'Longitude': lon,
+                'Description': message if message else ""
+            })
+
+        logger.debug(f"Logged location for {userID} to {map_filepath}")
+        return True
+    except Exception as e:
+        logger.error(f"Failed to log location for {userID}: {e}")
+        return False
+
+def mapHandler(userID, deviceID, channel_number, message, snr, rssi, hop):
+    from modules.system import get_node_location
+    command = message[len("map"):].strip()
+    location = get_node_location(userID, deviceID)
+    lat = location[0]
+    lon = location[1]
+    """
+    Handles 'map' commands from meshbot.
+    Usage:
+      map <description text>  - Log current location with description
+    """
+    command = str(command)  # Ensure command is always a string
+
+    if command.strip().lower() == "?":
+        return (
+            "Usage:\n"
+            "  🗺️map <description text>  - Log your current location with a description\n"
+            "Example:\n"
+            "  🗺️map Found a new mesh node near the park"
+        )
+
+    description = command.strip()
+    # if no description provided, set to default
+    if not description:
+        description = "Logged:"
+    # Sanitize description for CSV injection
+    if description and description[0] in ('=', '+', '-', '@'):
+        description = "'" + description
+
+    # if there is SNR and RSSI info, append to description
+    if snr is not None and rssi is not None:
+        description += f" SNR:{snr}dB RSSI:{rssi}dBm"
+    
+    # if there is hop info, append to description
+    if hop is not None:
+        description += f" Meta:{hop}"
+
+    # location should be a tuple: (lat, lon)
+    if not location or len(location) != 2:
+        return "🚫Location data is missing or invalid."
+
+    success = log_locationData_toMap(userID, location, description)
+    if success:
+        return f"📍Location logged "
+    else:
+        return "🚫Failed to log location. Please try again."

modules/log.py

@@ -1,13 +1,11 @@
 import logging
 from logging.handlers import TimedRotatingFileHandler
-import re
-from datetime import datetime, timedelta
-from modules.settings import *
+import modules.settings as my_settings
 # if LOGGING_LEVEL is not set in settings.py, default to DEBUG
-if not LOGGING_LEVEL:
-    LOGGING_LEVEL = "DEBUG"
+if not my_settings.LOGGING_LEVEL:
+    my_settings.LOGGING_LEVEL = "DEBUG"
 
-LOGGING_LEVEL = getattr(logging, LOGGING_LEVEL)
+LOGGING_LEVEL = getattr(logging, my_settings.LOGGING_LEVEL)
 
 class CustomFormatter(logging.Formatter):
     grey = '\x1b[38;21m'
@@ -38,11 +36,17 @@ class CustomFormatter(logging.Formatter):
         return formatter.format(record)
     
 class plainFormatter(logging.Formatter):
-    ansi_escape = re.compile(r'\x1b\[([0-9]+)(;[0-9]+)*m')
+    ansi_codes = [
+        '\x1b[38;21m', '\x1b[38;5;231m', '\x1b[38;5;39m', '\x1b[38;5;226m',
+        '\x1b[38;5;196m', '\x1b[38;5;46m', '\x1b[38;5;129m', '\x1b[31;1m',
+        '\x1b[37;1m', '\x1b[0m'
+    ]
 
     def format(self, record):
         message = super().format(record)
-        return self.ansi_escape.sub('', message)
+        for code in self.ansi_codes:
+            message = message.replace(code, '')
+        return message
 
 # Create logger
 logger = logging.getLogger("MeshBot System Logger")
@@ -56,7 +60,6 @@ msgLogger.propagate = False
 # Define format for logs
 logFormat = '%(asctime)s | %(levelname)8s | %(message)s'
 msgLogFormat = '%(asctime)s | %(message)s'
-today = datetime.now()
 
 # Create stdout handler for logging to the console
 stdout_handler = logging.StreamHandler()
@@ -67,16 +70,16 @@ stdout_handler.setFormatter(CustomFormatter(logFormat))
 # Add handlers to the logger
 logger.addHandler(stdout_handler)
 
-if syslog_to_file:
+if my_settings.syslog_to_file:
     # Create file handler for logging to a file
-    file_handler_sys = TimedRotatingFileHandler('logs/meshbot.log', when='midnight', backupCount=log_backup_count, encoding='utf-8')
+    file_handler_sys = TimedRotatingFileHandler('logs/meshbot.log', when='midnight', backupCount=my_settings.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:
+if my_settings.log_messages_to_file:
     # Create file handler for logging to a file
-    file_handler = TimedRotatingFileHandler('logs/messages.log', when='midnight', backupCount=log_backup_count, encoding='utf-8')
+    file_handler = TimedRotatingFileHandler('logs/messages.log', when='midnight', backupCount=my_settings.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)

modules/qrz.py

@@ -1,18 +1,29 @@
 # Module to respomnd to new nodes we havent seen before with a hello message
 # K7MHI Kelly Keeton 2024
 
+import os
 import sqlite3
-from modules.log import *
+from modules.log import logger
+from modules.settings import qrz_db
 
 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()
+    try:
+        # If the database file doesn't exist, it will be created by sqlite3.connect
+        if not os.path.exists(qrz_db):
+            logger.info(f"QRZ database file '{qrz_db}' not found. Creating new database.")
+        conn = sqlite3.connect(qrz_db)
+        c = conn.cursor()
+        # Create the table if it doesn't exist
+        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()
+        return True
+    except sqlite3.Error as e:
+        logger.error(f"Error initializing QRZ database: {e}")
+        return False
+    finally:
+        if 'conn' in locals():
+            conn.close()
 
 def never_seen_before(nodeID):
     # check if we have seen this node before and sent a hello message

modules/radio.py

@@ -3,14 +3,107 @@
 # 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
+# 2025 Kelly Keeton K7MHI
+
+# WSJT-X and JS8Call UDP Monitoring
+# Based on WSJT-X UDP protocol specification
+# Reference: https://github.com/ckuhtz/ham/blob/main/mcast/recv_decode.py
+
 
-from modules.log import *
 import asyncio
+import socket
+import struct
+import json
+from modules.log import logger
+
+from modules.settings import (
+    radio_detection_enabled,
+    rigControlServerAddress,
+    signalDetectionThreshold,
+    signalHoldTime,
+    signalCooldown,
+    signalCycleLimit,
+    voxDetectionEnabled,
+    useLocalVoxModel,
+    localVoxModelPath,
+    voxLanguage,
+    voxInputDevice,
+    voxTrapList,
+    voxOnTrapList,
+    voxEnableCmd,
+    ERROR_FETCHING_DATA
+)
+
+# module global variables
+
 
 # verbose debug logging for trap words function
 debugVoxTmsg = False
 
+# --- WSJT-X and JS8Call Settings Initialization ---
+wsjtxMsgQueue = []  # Queue for WSJT-X detected messages
+js8callMsgQueue = []  # Queue for JS8Call detected messages
+wsjtx_enabled = False
+js8call_enabled = False
+wsjtx_udp_port = 2237
+js8call_udp_port = 2442
+watched_callsigns = []
+wsjtx_udp_address = '127.0.0.1'
+js8call_tcp_address = '127.0.0.1'
+js8call_tcp_port = 2442
+# WSJT-X UDP Protocol Message Types
+WSJTX_HEARTBEAT = 0
+WSJTX_STATUS = 1
+WSJTX_DECODE = 2
+WSJTX_CLEAR = 3
+WSJTX_REPLY = 4
+WSJTX_QSO_LOGGED = 5
+WSJTX_CLOSE = 6
+WSJTX_REPLAY = 7
+WSJTX_HALT_TX = 8
+WSJTX_FREE_TEXT = 9
+WSJTX_WSPR_DECODE = 10
+WSJTX_LOCATION = 11
+WSJTX_LOGGED_ADIF = 12
+
+
+try:
+    from modules.settings import (
+        wsjtx_detection_enabled,
+        wsjtx_udp_server_address,
+        wsjtx_watched_callsigns,
+        js8call_detection_enabled,
+        js8call_server_address,
+        js8call_watched_callsigns
+    )
+    wsjtx_enabled = wsjtx_detection_enabled
+    js8call_enabled = js8call_detection_enabled
+
+    # Use a local list to collect callsigns before assigning to watched_callsigns
+    callsigns = []
+
+    if wsjtx_enabled:
+        if ':' in wsjtx_udp_server_address:
+            wsjtx_udp_address, port_str = wsjtx_udp_server_address.split(':')
+            wsjtx_udp_port = int(port_str)
+        if wsjtx_watched_callsigns:
+            callsigns.extend([cs.strip() for cs in wsjtx_watched_callsigns.split(',') if cs.strip()])
+
+    if js8call_enabled:
+        if ':' in js8call_server_address:
+            js8call_tcp_address, port_str = js8call_server_address.split(':')
+            js8call_tcp_port = int(port_str)
+        if js8call_watched_callsigns:
+            callsigns.extend([cs.strip() for cs in js8call_watched_callsigns.split(',') if cs.strip()])
+
+    # Clean up and deduplicate callsigns, uppercase for matching
+    watched_callsigns = list({cs.upper() for cs in callsigns})
+
+except ImportError:
+    logger.debug("RadioMon: WSJT-X/JS8Call settings not configured")
+except Exception as e:
+    logger.warning(f"RadioMon: Error loading WSJT-X/JS8Call settings: {e}")
+
 
 if radio_detection_enabled:
     # used by hamlib detection
@@ -100,6 +193,9 @@ def get_freq_common_name(freq):
 
 def get_hamlib(msg="f"):
     # get data from rigctld server
+    if "socket" not in globals():
+        logger.warning("RadioMon: 'socket' module not imported. Hamlib disabled.")
+        return ERROR_FETCHING_DATA
     try:
         rigControlSocket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
         rigControlSocket.settimeout(2)
@@ -243,4 +339,265 @@ async def voxMonitor():
     except Exception as e:
         logger.error(f"RadioMon: Error in VOX monitor: {e}")
 
+def decode_wsjtx_packet(data):
+    """Decode WSJT-X UDP packet according to the protocol specification"""
+    try:
+        # WSJT-X uses Qt's QDataStream format (big-endian)
+        magic = struct.unpack('>I', data[0:4])[0]
+        if magic != 0xADBCCBDA:
+            return None
+        
+        schema_version = struct.unpack('>I', data[4:8])[0]
+        msg_type = struct.unpack('>I', data[8:12])[0]
+        
+        offset = 12
+        
+        # Helper to read Qt QString (4-byte length + UTF-8 data)
+        def read_qstring(data, offset):
+            if offset + 4 > len(data):
+                return "", offset
+            length = struct.unpack('>I', data[offset:offset+4])[0]
+            offset += 4
+            if length == 0xFFFFFFFF:  # Null string
+                return "", offset
+            if offset + length > len(data):
+                return "", offset
+            text = data[offset:offset+length].decode('utf-8', errors='ignore')
+            return text, offset + length
+        
+        # Decode DECODE message (type 2)
+        if msg_type == WSJTX_DECODE:
+            # Read fields according to WSJT-X protocol
+            wsjtx_id, offset = read_qstring(data, offset)
+            
+            # Read other decode fields: new, time, snr, delta_time, delta_frequency, mode, message
+            if offset + 1 > len(data):
+                return None
+            new = struct.unpack('>?', data[offset:offset+1])[0]
+            offset += 1
+            
+            if offset + 4 > len(data):
+                return None
+            time_val = struct.unpack('>I', data[offset:offset+4])[0]
+            offset += 4
+            
+            if offset + 4 > len(data):
+                return None
+            snr = struct.unpack('>i', data[offset:offset+4])[0]
+            offset += 4
+            
+            if offset + 8 > len(data):
+                return None
+            delta_time = struct.unpack('>d', data[offset:offset+8])[0]
+            offset += 8
+            
+            if offset + 4 > len(data):
+                return None
+            delta_frequency = struct.unpack('>I', data[offset:offset+4])[0]
+            offset += 4
+            
+            mode, offset = read_qstring(data, offset)
+            message, offset = read_qstring(data, offset)
+            
+            return {
+                'type': 'decode',
+                'id': wsjtx_id,
+                'new': new,
+                'time': time_val,
+                'snr': snr,
+                'delta_time': delta_time,
+                'delta_frequency': delta_frequency,
+                'mode': mode,
+                'message': message
+            }
+        
+        # Decode QSO_LOGGED message (type 5)
+        elif msg_type == WSJTX_QSO_LOGGED:
+            wsjtx_id, offset = read_qstring(data, offset)
+            
+            # Read QSO logged fields
+            if offset + 8 > len(data):
+                return None
+            date_off = struct.unpack('>Q', data[offset:offset+8])[0]
+            offset += 8
+            
+            if offset + 8 > len(data):
+                return None
+            time_off = struct.unpack('>Q', data[offset:offset+8])[0]
+            offset += 8
+            
+            dx_call, offset = read_qstring(data, offset)
+            dx_grid, offset = read_qstring(data, offset)
+            
+            return {
+                'type': 'qso_logged',
+                'id': wsjtx_id,
+                'dx_call': dx_call,
+                'dx_grid': dx_grid
+            }
+            
+        return None
+        
+    except Exception as e:
+        logger.debug(f"RadioMon: Error decoding WSJT-X packet: {e}")
+        return None
+
+def check_callsign_match(message, callsigns):
+    """Check if any watched callsign appears in the message
+    
+    Uses word boundary matching to avoid false positives like matching
+    'K7' when looking for 'K7MHI'. Callsigns are expected to be
+    separated by spaces or be at the start/end of the message.
+    """
+    if not callsigns:
+        return True  # If no filter, accept all
+    
+    message_upper = message.upper()
+    # Split message into words for exact matching
+    words = message_upper.split()
+    
+    for callsign in callsigns:
+        callsign_upper = callsign.upper()
+        # Pre-compute patterns for portable/mobile suffixes
+        callsign_with_slash = callsign_upper + '/'
+        callsign_with_dash = callsign_upper + '-'
+        slash_callsign = '/' + callsign_upper
+        dash_callsign = '-' + callsign_upper
+        
+        # Check if callsign appears as a complete word
+        if callsign_upper in words:
+            return True
+        
+        # Check for callsigns in compound forms like "K7MHI/P" or "K7MHI-7"
+        for word in words:
+            if (word.startswith(callsign_with_slash) or 
+                word.startswith(callsign_with_dash) or
+                word.endswith(slash_callsign) or 
+                word.endswith(dash_callsign)):
+                return True
+    
+    return False
+
+async def wsjtxMonitor():
+    """Monitor WSJT-X UDP broadcasts for decode messages"""
+    if not wsjtx_enabled:
+        logger.warning("RadioMon: WSJT-X monitoring called but not enabled")
+        return
+    
+    try:
+        sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+        sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
+        sock.bind((wsjtx_udp_address, wsjtx_udp_port))
+        sock.setblocking(False)
+        
+        logger.info(f"RadioMon: WSJT-X UDP listener started on {wsjtx_udp_address}:{wsjtx_udp_port}")
+        if watched_callsigns:
+            logger.info(f"RadioMon: Watching for callsigns: {', '.join(watched_callsigns)}")
+        
+        while True:
+            try:
+                data, addr = sock.recvfrom(4096)
+                decoded = decode_wsjtx_packet(data)
+                
+                if decoded and decoded['type'] == 'decode':
+                    message = decoded['message']
+                    mode = decoded['mode']
+                    snr = decoded['snr']
+                    
+                    # Check if message contains watched callsigns
+                    if check_callsign_match(message, watched_callsigns):
+                        msg_text = f"WSJT-X {mode}: {message} (SNR: {snr:+d}dB)"
+                        logger.info(f"RadioMon: {msg_text}")
+                        wsjtxMsgQueue.append(msg_text)
+                        
+            except BlockingIOError:
+                # No data available
+                await asyncio.sleep(0.1)
+            except Exception as e:
+                logger.debug(f"RadioMon: Error in WSJT-X monitor loop: {e}")
+                await asyncio.sleep(1)
+                
+    except Exception as e:
+        logger.error(f"RadioMon: Error starting WSJT-X monitor: {e}")
+
+async def js8callMonitor():
+    """Monitor JS8Call TCP API for messages"""
+    if not js8call_enabled:
+        logger.warning("RadioMon: JS8Call monitoring called but not enabled")
+        return
+    
+    try:
+        logger.info(f"RadioMon: JS8Call TCP listener connecting to {js8call_tcp_address}:{js8call_tcp_port}")
+        if watched_callsigns:
+            logger.info(f"RadioMon: Watching for callsigns: {', '.join(watched_callsigns)}")
+        
+        while True:
+            try:
+                # Connect to JS8Call TCP API
+                sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+                sock.settimeout(5)
+                sock.connect((js8call_tcp_address, js8call_tcp_port))
+                sock.setblocking(False)
+                
+                logger.info("RadioMon: Connected to JS8Call API")
+                
+                buffer = ""
+                while True:
+                    try:
+                        data = sock.recv(4096)
+                        if not data:
+                            logger.warning("RadioMon: JS8Call connection closed")
+                            break
+                        
+                        buffer += data.decode('utf-8', errors='ignore')
+                        
+                        # Process complete JSON messages (newline delimited)
+                        while '\n' in buffer:
+                            line, buffer = buffer.split('\n', 1)
+                            if not line.strip():
+                                continue
+                                
+                            try:
+                                msg = json.loads(line)
+                                msg_type = msg.get('type', '')
+                                
+                                # Handle RX.DIRECTED and RX.ACTIVITY messages
+                                if msg_type in ['RX.DIRECTED', 'RX.ACTIVITY']:
+                                    params = msg.get('params', {})
+                                    text = params.get('TEXT', '')
+                                    from_call = params.get('FROM', '')
+                                    snr = params.get('SNR', 0)
+                                    
+                                    if text and check_callsign_match(text, watched_callsigns):
+                                        msg_text = f"JS8Call from {from_call}: {text} (SNR: {snr:+d}dB)"
+                                        logger.info(f"RadioMon: {msg_text}")
+                                        js8callMsgQueue.append(msg_text)
+                                        
+                            except json.JSONDecodeError:
+                                logger.debug(f"RadioMon: Invalid JSON from JS8Call: {line[:100]}")
+                            except Exception as e:
+                                logger.debug(f"RadioMon: Error processing JS8Call message: {e}")
+                                
+                    except BlockingIOError:
+                        await asyncio.sleep(0.1)
+                    except socket.timeout:
+                        await asyncio.sleep(0.1)
+                    except Exception as e:
+                        logger.debug(f"RadioMon: Error in JS8Call receive loop: {e}")
+                        break
+                        
+                sock.close()
+                logger.warning("RadioMon: JS8Call connection lost, reconnecting in 5s...")
+                await asyncio.sleep(5)
+                
+            except socket.timeout:
+                logger.warning("RadioMon: JS8Call connection timeout, retrying in 5s...")
+                await asyncio.sleep(5)
+            except Exception as e:
+                logger.warning(f"RadioMon: Error connecting to JS8Call: {e}")
+                await asyncio.sleep(10)
+                
+    except Exception as e:
+        logger.error(f"RadioMon: Error starting JS8Call monitor: {e}")
+
 # end of file

modules/rss.py

@@ -1,9 +1,14 @@
 # rss feed module for meshing-around 2025
-from modules.log import *
+from modules.log import logger
+from modules.settings import rssFeedURL, rssFeedNames, rssMaxItems, rssTruncate, urlTimeoutSeconds, ERROR_FETCHING_DATA
 import urllib.request
 import xml.etree.ElementTree as ET
 import html
 from html.parser import HTMLParser
+import bs4 as bs
+
+# Common User-Agent for all RSS requests
+COMMON_USER_AGENT = 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/58.0.3029.110 Safari/537.3'
 
 class MLStripper(HTMLParser):
     def __init__(self):
@@ -16,9 +21,12 @@ class MLStripper(HTMLParser):
         return ''.join(self.fed)
 
 def strip_tags(html_text):
-    s = MLStripper()
-    s.feed(html_text)
-    return s.get_data()
+    # use BeautifulSoup to strip HTML tags
+    if not html_text:
+        return ""
+    soup = bs.BeautifulSoup(html_text, "html.parser")
+    text = soup.get_text(separator=" ", strip=True)
+    return ' '.join(text.split())
 
 RSS_FEED_URLS = rssFeedURL
 RSS_FEED_NAMES = rssFeedNames
@@ -48,48 +56,83 @@ def get_rss_feed(msg):
     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."
 
+    # Fetch and parse the RSS feed
     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'}
+        agent = {'User-Agent': COMMON_USER_AGENT}
         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
+
+        # Find all <item> (RSS) and <entry> (Atom) elements, regardless of namespace
+        items = []
+        for elem in root.iter():
+            if elem.tag.endswith('item') or elem.tag.endswith('entry'):
+                items.append(elem)
         items = items[:RSS_RETURN_COUNT]
+
         if not items:
-            return "No RSS feed entries found."
+            logger.debug(f"No RSS or Atom feed entries found in feed xml_data: {xml_data[:500]}...")
+            return "No RSS or Atom feed entries found."
+
         formatted_entries = []
+        seen_first3 = set()  # Track first 3 words (lowercased) to avoid duplicates
         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')
+            # Helper to try multiple tag names
+            def find_any(item, tags):
+                for tag in tags:
+                    val = item.findtext(tag)
+                    if val:
+                        return val
+                return None
+
+            title = find_any(item, [
+                'title',
+                '{http://purl.org/rss/1.0/}title',
+                '{http://www.w3.org/2005/Atom}title'
+            ])
+
+            # Atom links are often attributes, not text
+            link = find_any(item, [
+                'link',
+                '{http://purl.org/rss/1.0/}link',
+                '{http://www.w3.org/2005/Atom}link'
+            ])
+            if not link:
+                link_elem = item.find('{http://www.w3.org/2005/Atom}link')
+                if link_elem is not None and 'href' in link_elem.attrib:
+                    link = link_elem.attrib['href']
+
+            description = find_any(item, [
+                'description',
+                '{http://purl.org/rss/1.0/}description',
+                '{http://purl.org/rss/1.0/modules/content/}encoded',
+                '{http://www.w3.org/2005/Atom}summary',
+                '{http://www.w3.org/2005/Atom}content'
+            ])
+            pub_date = find_any(item, [
+                'pubDate',
+                '{http://purl.org/dc/elements/1.1/}date',
+                '{http://www.w3.org/2005/Atom}updated'
+            ])
 
             # Unescape HTML entities and strip tags
-            description = html.unescape(description)
+            description = html.unescape(description) if description else ""
             description = strip_tags(description)
             if len(description) > RSS_TRIM_LENGTH:
                 description = description[:RSS_TRIM_LENGTH - 3] + "..."
 
+            # Duplicate check: use first 3 words of description (or title if description is empty)
+            text_for_dupe = description if description else (title or "")
+            first3 = " ".join(text_for_dupe.lower().split()[:3])
+            if first3 in seen_first3:
+                continue
+            seen_first3.add(first3)
+
             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

@@ -1,104 +1,191 @@
 # modules/scheduler.py 2025 meshing-around
+# Scheduler module for mesh_bot
+import asyncio
 import schedule
+from datetime import datetime
 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(
+async def run_scheduler_loop(interval=1):
+    logger.debug(f"System: Scheduler loop started Tasks: {len(schedule.jobs)}, Details:{extract_schedule_fields(schedule.get_jobs())}")
+    try:
+        last_logged_minute = -1
+        while True:
+            try:
+                # Log scheduled jobs every 20 minutes
+                now = datetime.now()
+                if now.minute % 20 == 0 and now.minute != last_logged_minute:
+                    logger.debug(f"System: Scheduled Tasks {len(schedule.jobs)}, Details:{extract_schedule_fields(schedule.get_jobs())}")
+                    last_logged_minute = now.minute
+                schedule.run_pending()
+            except Exception as e:
+                logger.error(f"System: Scheduler loop exception: {e}")
+            await asyncio.sleep(interval)
+    except asyncio.CancelledError:
+        logger.debug("System: Scheduler loop cancelled, shutting down.")
+
+def safe_int(val, default=0, type=""):
+    try:
+        return int(val)
+    except (ValueError, TypeError):
+        logger.debug(f"System: Scheduler config {type} error '{val}' to int, using default {default}")
+        return default
+
+def extract_schedule_fields(jobs):
+    """
+    Extracts 'Every ... (last run: [...], next run: ...)' from schedule.get_jobs() output without regex.
+    """
+    jobs_str = str(jobs)
+    results = []
+    # Split by '), ' to separate jobs, then add ')' back except last
+    parts = jobs_str.split('), ')
+    for i, part in enumerate(parts):
+        if not part.endswith(')'):
+            part += ')'
+        # Find the start of 'Every'
+        start = part.find('Every')
+        if start != -1:
+            # Find the start of 'do <lambda>()'
+            do_idx = part.find('do ')
+            if do_idx != -1:
+                summary = part[start:do_idx].strip()
+                # Find the (last run: ... next run: ...) part
+                paren_idx = part.find('(', do_idx)
+                if paren_idx != -1:
+                    summary += ' ' + part[paren_idx:].strip()
+                    while '<function ' in summary:
+                        f_start = summary.find('<function ')
+                        f_end = summary.find('>', f_start)
+                        if f_end == -1:
+                            break
+                        func_str = summary[f_start+10:f_end]
+                        func_name = func_str.split(' ')[0]
+                        summary = summary[:f_start] + func_name + summary[f_end+1:]
+                    results.append(summary)
+    return results
+
+def setup_scheduler(
     schedulerMotd, MOTD, schedulerMessage, schedulerChannel, schedulerInterface,
-    schedulerValue, schedulerTime, schedulerInterval, logger, BroadcastScheduler
-):
+    schedulerValue, schedulerTime, schedulerInterval):
+    try:
+        # Methods imported from mesh_bot for scheduling tasks
+        from mesh_bot import (
+            tell_joke,
+            welcome_message,
+            handle_wxc,
+            handle_moon,
+            handle_sun,
+            handle_riverFlow,
+            handle_tide,
+            handle_satpass,
+            handleNews,
+            handle_mwx,
+            sysinfo,
+        )
+        from modules.rss import get_rss_feed
+    except ImportError as e:
+        logger.warning(f"Some mesh_bot schedule features are unavailable by option disable in config.ini: {e} comment out the use of these methods in your custom_scheduler.py")
+    
+    # Setup the scheduler based on configuration
     schedulerValue = schedulerValue.lower().strip()
     schedulerTime = schedulerTime.strip()
     schedulerInterval = schedulerInterval.strip()
-    schedulerChannel = int(schedulerChannel)
-    schedulerInterface = int(schedulerInterface)
-    # Setup the scheduler based on configuration
+    schedulerChannel = safe_int(schedulerChannel, 0, type="channel")
+    schedulerInterface = safe_int(schedulerInterface, 1, type="interface")
+    schedulerIntervalInt = safe_int(schedulerInterval, 5, type="interval")
+
     try:
-        if schedulerMotd:
-            scheduler_message = MOTD
-        else:
-            scheduler_message = schedulerMessage
+        scheduler_message = MOTD if schedulerMotd else schedulerMessage
+
+        def send_sched_msg():
+            send_message(scheduler_message, schedulerChannel, 0, schedulerInterface)
 
         # 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))
+        basicOptions = ['day', 'mon', 'tue', 'wed', 'thu', 'fri', 'sat', 'sun', 'hour', 'min']
+        if any(option in schedulerValue for option in basicOptions):
+            if schedulerValue == 'day':
+                if schedulerTime:
+                    # Specific time each day
+                    schedule.every().day.at(schedulerTime).do(send_sched_msg)
                 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()
+                    # Every N days
+                    schedule.every(schedulerIntervalInt).days.do(send_sched_msg)
+            elif 'mon' in schedulerValue and schedulerTime:
+                schedule.every().monday.at(schedulerTime).do(send_sched_msg)
+            elif 'tue' in schedulerValue and schedulerTime:
+                schedule.every().tuesday.at(schedulerTime).do(send_sched_msg)
+            elif 'wed' in schedulerValue and schedulerTime:
+                schedule.every().wednesday.at(schedulerTime).do(send_sched_msg)
+            elif 'thu' in schedulerValue and schedulerTime:
+                schedule.every().thursday.at(schedulerTime).do(send_sched_msg)
+            elif 'fri' in schedulerValue and schedulerTime:
+                schedule.every().friday.at(schedulerTime).do(send_sched_msg)
+            elif 'sat' in schedulerValue and schedulerTime:
+                schedule.every().saturday.at(schedulerTime).do(send_sched_msg)
+            elif 'sun' in schedulerValue and schedulerTime:
+                schedule.every().sunday.at(schedulerTime).do(send_sched_msg)
+            elif 'hour' in schedulerValue:
+                schedule.every(schedulerIntervalInt).hours.do(send_sched_msg)
+            elif 'min' in schedulerValue:
+                schedule.every(schedulerIntervalInt).minutes.do(send_sched_msg)
+            logger.debug(f"System: Starting the basic scheduler to send '{scheduler_message}' on schedule '{schedulerValue}' every {schedulerIntervalInt} interval at time '{schedulerTime}' on Device:{schedulerInterface} Channel:{schedulerChannel}")
+        elif 'joke' in schedulerValue:
+            schedule.every(schedulerIntervalInt).minutes.do(
+                lambda: send_message(tell_joke(), schedulerChannel, 0, schedulerInterface)
+            )
+            logger.debug(f"System: Starting the joke scheduler to send a joke every {schedulerIntervalInt} minutes on Device:{schedulerInterface} Channel:{schedulerChannel}")
+        elif 'link' in schedulerValue:
+            schedule.every(schedulerIntervalInt).hours.do(
+                lambda: send_message("bbslink MeshBot looking for peers", schedulerChannel, 0, schedulerInterface)
+            )
+            logger.debug(f"System: Starting the link scheduler to send link messages every {schedulerIntervalInt} hours on Device:{schedulerInterface} Channel:{schedulerChannel}")
+        elif 'weather' in schedulerValue:
+            schedule.every().day.at(schedulerTime).do(
+                lambda: send_message(handle_wxc(0, schedulerInterface, 'wx', days=1), schedulerChannel, 0, schedulerInterface)
+            )
+            logger.debug(f"System: Starting the weather scheduler to send weather updates every {schedulerIntervalInt} hours on Device:{schedulerInterface} Channel:{schedulerChannel}")
+        elif 'news' in schedulerValue:
+            schedule.every(schedulerIntervalInt).hours.do(
+                lambda: send_message(handleNews(0, schedulerInterface, 'readnews', False), schedulerChannel, 0, schedulerInterface)
+            )
+            logger.debug(f"System: Starting the news scheduler to send news updates every {schedulerIntervalInt} hours on Device:{schedulerInterface} Channel:{schedulerChannel}")
+        elif 'readrss' in schedulerValue:
+            schedule.every(schedulerIntervalInt).hours.do(
+                lambda: send_message(get_rss_feed(''), schedulerChannel, 0, schedulerInterface)
+            )
+            logger.debug(f"System: Starting the RSS scheduler to send RSS feeds every {schedulerIntervalInt} hours on Device:{schedulerInterface} Channel:{schedulerChannel}")
+        elif 'mwx' in schedulerValue:
+            schedule.every().day.at(schedulerTime).do(
+                lambda: send_message(handle_mwx(0, schedulerInterface, 'mwx'), schedulerChannel, 0, schedulerInterface)
+            )
+            logger.debug(f"System: Starting the marine weather scheduler to send marine weather updates at {schedulerTime} on Device:{schedulerInterface} Channel:{schedulerChannel}")
+        elif 'sysinfo' in schedulerValue:
+            schedule.every(schedulerIntervalInt).hours.do(
+                lambda: send_message(sysinfo('', 0, schedulerInterface, False), schedulerChannel, 0, schedulerInterface)
+            )
+            logger.debug(f"System: Starting the sysinfo scheduler to send system information every {schedulerIntervalInt} hours on Device:{schedulerInterface} Channel:{schedulerChannel}")
+        elif 'tide' in schedulerValue:
+            schedule.every().day.at(schedulerTime).do(
+                lambda: send_message(handle_tide(0, schedulerInterface, schedulerChannel), schedulerChannel, 0, schedulerInterface)
+            )
+            logger.debug(f"System: Starting the tide scheduler to send tide information at {schedulerTime} on Device:{schedulerInterface} Channel:{schedulerChannel}")
+        elif 'solar' in schedulerValue:
+            schedule.every().day.at(schedulerTime).do(
+                lambda: send_message(handle_sun(0, schedulerInterface, schedulerChannel), schedulerChannel, 0, schedulerInterface)
+            )
+            logger.debug(f"System: Starting the scheduler to send solar information at {schedulerTime} on Device:{schedulerInterface} Channel:{schedulerChannel}")
+        elif 'custom' in schedulerValue:
+            try:
+                from modules.custom_scheduler import setup_custom_schedules # type: ignore
+                setup_custom_schedules(
+                    send_message, tell_joke, welcome_message, handle_wxc, MOTD,
+                    schedulerChannel, schedulerInterface)
+                logger.debug(f"System: Starting the custom_scheduler.py ")
+                schedule.every().monday.at("12:00").do(
+                    lambda: logger.info("System: Scheduled Broadcast Enabled Reminder")
+                )
+            except Exception as e:
+                logger.warning("Custom scheduler file not found or failed to import. cp etc/custom_scheduler.template modules/custom_scheduler.py")
     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))
+    return True

modules/settings.py

@@ -32,6 +32,8 @@ cmdHistory = [] # list to hold the command history for lheard and history comman
 msg_history = [] # list to hold the message history for the messages command
 max_bytes = 200 # Meshtastic has ~237 byte limit, use conservative 200 bytes for message content
 voxMsgQueue = [] # queue for VOX detected messages
+wsjtxMsgQueue = [] # queue for WSJT-X detected messages
+js8callMsgQueue = [] # queue for JS8Call detected messages
 # Game trackers
 surveyTracker = []           # Survey game tracker
 tictactoeTracker = []        # TicTacToe game tracker
@@ -46,6 +48,13 @@ dwPlayerTracker = []         # DopeWars player tracker
 jackTracker = []             # Jack game tracker
 mindTracker = []             # Mastermind (mmind) game tracker
 
+# Memory Management Constants
+MAX_MSG_HISTORY = 250
+MAX_CMD_HISTORY = 250
+MAX_SEEN_NODES = 1000
+CLEANUP_INTERVAL = 86400 # 24 hours in seconds
+GAMEDELAY = 3 * CLEANUP_INTERVAL # 3 days in seconds
+
 # Read the config file, if it does not exist, create basic config file
 config = configparser.ConfigParser() 
 config_file = "config.ini"
@@ -118,6 +127,10 @@ 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'))
 
+if 'inventory' not in config:
+    config['inventory'] = {'enabled': 'False', 'inventory_db': 'data/inventory.db', 'disable_penny': 'False'}
+    config.write(open(config_file, 'w'))
+
 # interface1 settings
 interface1_type = config['interface'].get('type', 'serial')
 port1 = config['interface'].get('port', '')
@@ -249,6 +262,10 @@ try:
     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
+    llmUseWikiContext = config['general'].getboolean('llmUseWikiContext', False) # default False
+    useOpenWebUI = config['general'].getboolean('useOpenWebUI', False) # default False
+    openWebUIURL = config['general'].get('openWebUIURL', 'http://localhost:3000') # default localhost:3000
+    openWebUIAPIKey = config['general'].get('openWebUIAPIKey', '') # default empty
     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
@@ -271,6 +288,7 @@ try:
     secure_interface = config['sentry'].getint('SentryInterface', 1) # default 1
     sentry_holdoff = config['sentry'].getint('SentryHoldoff', 9) # default 9
     sentryIgnoreList = config['sentry'].get('sentryIgnoreList', '').split(',')
+    sentryWatchList = config['sentry'].get('sentryWatchList', '').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
@@ -281,6 +299,9 @@ try:
     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
+    cmdShellSentryAlerts = config['sentry'].getboolean('cmdShellSentryAlerts', False) # default False
+    sentryAlertNear = config['sentry'].get('sentryAlertNear', 'sentry_alert_near.sh') # default sentry_alert_near.sh
+    sentryAlertFar = config['sentry'].get('sentryAlertFar', 'sentry_alert_far.sh') # default sentry_alert_far.sh
 
     # location
     location_enabled = config['location'].getboolean('enabled', True)
@@ -294,6 +315,7 @@ try:
     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
+    useTidePredict = config['location'].getboolean('useTidePredict', False) # default False use NOAA
     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
@@ -341,6 +363,11 @@ try:
     qrz_hello_string = config['qrz'].get('qrz_hello_string', 'MeshBot says Hello! DM for more info.')
     train_qrz = config['qrz'].getboolean('training', True)
     
+    # inventory and POS
+    inventory_enabled = config['inventory'].getboolean('enabled', False)
+    inventory_db = config['inventory'].get('inventory_db', 'data/inventory.db')
+    disable_penny = config['inventory'].getboolean('disable_penny', False)
+    
     # E-Mail Settings
     sysopEmails = config['smtp'].get('sysopEmails', '').split(',')
     enableSMTP = config['smtp'].getboolean('enableSMTP', False)
@@ -374,6 +401,7 @@ try:
 
     # radio monitoring
     radio_detection_enabled = config['radioMon'].getboolean('enabled', False)
+    dxspotter_enabled = config['radioMon'].getboolean('dxspotter_enabled', True) # default True
     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
@@ -390,6 +418,14 @@ try:
     voxOnTrapList = config['radioMon'].getboolean('voxOnTrapList', False) # default False
     voxTrapList = config['radioMon'].get('voxTrapList', 'chirpy').split(',') # default chirpy
     voxEnableCmd = config['radioMon'].getboolean('voxEnableCmd', True) # default True
+    
+    # WSJT-X and JS8Call monitoring
+    wsjtx_detection_enabled = config['radioMon'].getboolean('wsjtxDetectionEnabled', False) # default WSJT-X detection disabled
+    wsjtx_udp_server_address = config['radioMon'].get('wsjtxUdpServerAddress', '127.0.0.1:2237') # default localhost:2237
+    wsjtx_watched_callsigns = config['radioMon'].get('wsjtxWatchedCallsigns', '') # default empty (all callsigns)
+    js8call_detection_enabled = config['radioMon'].getboolean('js8callDetectionEnabled', False) # default JS8Call detection disabled
+    js8call_server_address = config['radioMon'].get('js8callServerAddress', '127.0.0.1:2442') # default localhost:2442
+    js8call_watched_callsigns = config['radioMon'].get('js8callWatchedCallsigns', '') # default empty (all callsigns)
 
     # file monitor
     file_monitor_enabled = config['fileMon'].getboolean('filemon_enabled', False)
@@ -420,6 +456,7 @@ try:
     default_survey = config['games'].get('defaultSurvey', 'example') # default example
     surveyRecordID = config['games'].getboolean('surveyRecordID', True)
     surveyRecordLocation = config['games'].getboolean('surveyRecordLocation', True)
+    wordOfTheDay = config['games'].getboolean('wordOfTheDay', True)
 
     # messaging settings
     responseDelay = config['messagingSettings'].getfloat('responseDelay', 0.7) # default 0.7
@@ -436,6 +473,6 @@ try:
     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...")
+    print("System: Check the config.ini against config.template file for missing sections or values.")
+    print("System: Exiting...")
     exit(1)

modules/smtp.py

@@ -3,7 +3,12 @@
 # https://avtech.com/articles/138/list-of-email-to-sms-addresses/
 # 2024 Kelly Keeton K7MHI
 
-from modules.log import *
+from modules.log import logger
+from modules.settings import (
+    SMTP_SERVER, SMTP_PORT, SMTP_AUTH, SMTP_USERNAME, SMTP_PASSWORD,
+    FROM_EMAIL, EMAIL_SUBJECT, enableImap, IMAP_SERVER, IMAP_PORT,
+    IMAP_USERNAME, IMAP_PASSWORD, IMAP_FOLDER, sysopEmails, bbs_ban_list
+)
 import pickle
 import time
 import smtplib

modules/space.py

@@ -7,7 +7,10 @@ import xml.dom.minidom
 from datetime import datetime
 import ephem # pip install pyephem
 from datetime import timezone
-from modules.log import *
+from modules.log import logger, getPrettyTime
+from modules.settings import (latitudeValue, longitudeValue, zuluTime,
+                              n2yoAPIKey, urlTimeoutSeconds, use_metric,
+                              ERROR_FETCHING_DATA, NO_DATA_NOGPS, NO_ALERTS)
 import math
 
 trap_list_solarconditions = ("sun", "moon", "solar", "hfcond", "satpass", "howtall")

modules/survey.py

@@ -10,8 +10,11 @@
 
 import json
 import os # For file operations
+import csv
+from datetime import datetime
 from collections import Counter
-from modules.log import *
+from modules.log import logger
+from modules.settings import surveyRecordLocation, surveyRecordID
 
 allowedSurveys = []  # List of allowed survey names
 
@@ -61,8 +64,9 @@ class SurveyModule:
                 'answers': [],
                 'location': location if surveyRecordLocation and location is not None else 'N/A'
             }
-            msg = f"'{survey_name}'📝survey\nSend answer' or 'end'\n"
+            msg = f"'{survey_name}'📝survey\n"
             msg += self.show_question(user_id)
+            msg += f"\nSend answer' or 'end'"
             return msg
         except Exception as e:
             logger.error(f"Error starting survey for user {user_id}: {e}")
@@ -95,18 +99,99 @@ class SurveyModule:
             return
         filename = os.path.join(self.response_dir, f'{survey_name}_responses.csv')
         try:
+            # Check if file exists and if it has a header
+            write_header = not os.path.isfile(filename) or os.path.getsize(filename) == 0
             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")
+                # Write header if needed
+                if write_header:
+                    header = ['timestamp', 'user_id', 'location'] + [f'Q{i+1}' for i in range(len(self.responses[user_id]['answers']))]
+                    f.write(','.join(header) + '\n')
+                # Always write: timestamp, userID, position, answers...
+                timestamp = datetime.now().strftime('%d%m%Y%H%M%S')
+                user_id_str = str(user_id)
+                location = self.responses[user_id].get('location', "N/A")
+                answers = list(map(str, self.responses[user_id]['answers']))
+                row = [timestamp, user_id_str, str(location)] + answers
                 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 format_survey_results(self, results):
+        if isinstance(results, dict) and "error" in results:
+            return results["error"]
+        if not results:
+            return "No results found."
+        msg = "📊Survey Results:\n"
+        for idx, q in enumerate(results):
+            msg += f"\nQ{idx+1}: {q['question']}\n"
+            if q['type'] == 'multiple_choice':
+                for opt, count in q['summary'].items():
+                    msg += f"  {opt}: {count}\n"
+            elif q['type'] == 'integer':
+                s = q['summary']
+                msg += f"  Count: {s['count']}, Avg: {s['average']:.2f}, Min: {s['min']}, Max: {s['max']}\n"
+            elif q['type'] == 'text':
+                msg += f"  Responses: {q['summary']['responses_count']}\n"
+        return msg
+
+    def get_survey_results(self, survey_name='example'):
+        if survey_name not in self.surveys:
+            return {"error": f"Survey '{survey_name}' not found."}
+        filename = os.path.join(self.response_dir, f'{survey_name}_responses.csv')
+        questions = self.surveys[survey_name]
+        results = []
+        try:
+            with open(filename, encoding='utf-8') as f:
+                reader = csv.reader(f)
+                lines = []
+                for row in reader:
+                    if not row or len(row) < 4:
+                        continue
+                    # If location field is split due to comma, join columns 2 and 3
+                    if row[2].startswith('[') and not row[2].endswith(']') and len(row) > 4:
+                        location = row[2] + ',' + row[3]
+                        answers = row[4:]
+                    else:
+                        location = row[2]
+                        answers = row[3:]
+                    lines.append(answers)
+
+            for q_idx, question in enumerate(questions):
+                qtype = question.get('type', 'multiple_choice')
+                answers = [row[q_idx] for row in lines if len(row) > q_idx]
+
+                summary = {}
+                if qtype == 'multiple_choice':
+                    counts = Counter(answers)
+                    summary = {chr(65+i): counts.get(chr(65+i), 0) for i in range(len(question.get('options', [])))}
+
+                elif qtype == 'integer':
+                    ints = [int(a) for a in answers if a.isdigit()]
+                    summary = {
+                        "count": len(ints),
+                        "average": sum(ints)/len(ints) if ints else 0,
+                        "min": min(ints) if ints else None,
+                        "max": max(ints) if ints else None
+                    }
+
+                elif qtype == 'text':
+                    summary = {"responses_count": len([a for a in answers if a.strip()])}
+
+
+                results.append({
+                    "question": question['question'],
+                    "type": qtype,
+                    "summary": summary
+                })
+
+            return results
+        except FileNotFoundError:
+            return {"error": f"No responses recorded yet for '{survey_name}'."}
+        except Exception as e:
+            logger.error(f"Error summarizing survey results: {e}")
+            return NO_ALERTS
+
     def answer(self, user_id, answer, location=None):
         try:
             """Record an answer and return the next question or end message."""
@@ -125,7 +210,8 @@ class SurveyModule:
                     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))
+                    # Valid answer record letter, not index
+                    self.responses[user_id]['answers'].append(answer_char)
                     self.responses[user_id]['current_question'] += 1
                     return f"Recorded..\n" + self.show_question(user_id)
                 else:

modules/system.py

@@ -7,11 +7,13 @@ import meshtastic.ble_interface
 import time
 import asyncio
 import random
+import base64
 # not ideal but needed?
 import contextlib # for suppressing output on watchdog
 import io # for suppressing output on watchdog
 # homebrew 'modules'
-from modules.log import *
+from modules.settings import *
+from modules.log import logger, getPrettyTime, CustomFormatter
 
 # Global Variables
 trap_list = ("cmd","cmd?","bannode",) # base commands
@@ -21,13 +23,6 @@ games_enabled = False
 multiPingList = [{'message_from_id': 0, 'count': 0, 'type': '', 'deviceID': 0, 'channel_number': 0, 'startCount': 0}]
 interface_retry_count = 3
 
-# Memory Management Constants
-MAX_MSG_HISTORY = 250
-MAX_CMD_HISTORY = 250
-MAX_SEEN_NODES = 1000
-CLEANUP_INTERVAL = 86400 # 24 hours in seconds
-GAMEDELAY = 3 * CLEANUP_INTERVAL # 3 days in seconds
-
 # Ping Configuration
 if ping_enabled:
     # ping, pinging, ack, testing, test, pong
@@ -130,6 +125,10 @@ if coastalEnabled:
     from modules.locationdata import * # from the spudgunman/meshing-around repo
     trap_list = trap_list + ("mwx","tide",)
     help_message = help_message + ", mwx, tide"
+if useTidePredict:
+    from modules import xtide
+    trap_list = trap_list + ("tide",)
+    help_message = help_message + ", tide"
         
 # BBS Configuration
 if bbs_enabled:
@@ -146,11 +145,16 @@ if dad_jokes_enabled:
     trap_list = trap_list + ("joke",)
     help_message = help_message + ", joke"
 
+if dxspotter_enabled:
+    from modules.dxspot import handledxcluster
+    trap_list = trap_list + ("dx",)
+    help_message = help_message + ", dx"
+
 # Wikipedia Search Configuration
-if wikipedia_enabled:
-    from modules.wiki import * # from the spudgunman/meshing-around repo
-    trap_list = trap_list + ("wiki:",)
-    help_message = help_message + ", wiki:"
+if wikipedia_enabled or use_kiwix_server:
+    from modules.wiki import get_wikipedia_summary, get_kiwix_summary, get_wikipedia_summary
+    trap_list = trap_list + ("wiki",)
+    help_message = help_message + ", wiki"
 
 # RSS Feed Configuration
 if rssEnable:
@@ -216,7 +220,7 @@ if quiz_enabled:
     from modules.games.quiz import * # from the spudgunman/meshing-around repo
     trap_list = trap_list + trap_list_quiz # items quiz, q:
     help_message = help_message + ", quiz"
-    games_enabled = True
+    # games not enabled for quiz
 
 if survey_enabled:
     from modules.survey import * # from the spudgunman/meshing-around repo
@@ -224,6 +228,11 @@ if survey_enabled:
     help_message = help_message + ", survey"
     games_enabled = True
 
+if wordOfTheDay:
+    from modules.games.wodt import WordOfTheDayGame # from the spudgunman/meshing-around repo
+    theWordOfTheDay = WordOfTheDayGame()
+    # this runs in background and wont enable other games
+
 # Games Configuration
 if games_enabled is True:
     help_message = help_message + ", games"
@@ -255,10 +264,6 @@ if games_enabled is True:
 else:
     gamesCmdList = ""
 
-# Scheduled Broadcast Configuration
-if scheduler_enabled:
-    import schedule # pip install schedule
-
 # Sentry Configuration
 if sentry_enabled:
     from math import sqrt
@@ -281,6 +286,12 @@ if checklist_enabled:
     trap_list = trap_list + trap_list_checklist # items checkin, checkout, checklist, purgein, purgeout
     help_message = help_message + ", checkin, checkout"
 
+# Inventory and POS Configuration
+if inventory_enabled:
+    from modules.inventory import * # from the spudgunman/meshing-around repo
+    trap_list = trap_list + trap_list_inventory # items item, itemlist, itemsell, etc.
+    help_message = help_message + ", item, cart"
+
 # Radio Monitor Configuration
 if radio_detection_enabled:
     from modules.radio import * # from the spudgunman/meshing-around repo
@@ -289,7 +300,7 @@ if voxDetectionEnabled:
     from modules.radio import * # from the spudgunman/meshing-around repo
 
 # File Monitor Configuration
-if file_monitor_enabled or read_news_enabled or bee_enabled:
+if file_monitor_enabled or read_news_enabled or bee_enabled or enable_runShellCmd or cmdShellSentryAlerts:
     from modules.filemon import * # from the spudgunman/meshing-around repo
     if read_news_enabled:
         trap_list = trap_list + trap_list_filemon # items readnews
@@ -315,6 +326,24 @@ if ble_count > 1:
     logger.critical(f"System: Multiple BLE interfaces detected. Only one BLE interface is allowed. Exiting")
     exit()
 
+def xor_hash(data: bytes) -> int:
+    """Compute an XOR hash from bytes."""
+    result = 0
+    for char in data:
+        result ^= char
+    return result
+
+def generate_hash(name: str, key: str) -> int:
+    """generate the channel number by hashing the channel name and psk"""
+    if key == "AQ==":
+        key = "1PG7OiApB1nwvP+rz05pAQ=="
+    replaced_key = key.replace("-", "+").replace("_", "/")
+    key_bytes = base64.b64decode(replaced_key.encode("utf-8"))
+    h_name = xor_hash(bytes(name, "utf-8"))
+    h_key = xor_hash(key_bytes)
+    result: int = h_name ^ h_key
+    return result
+
 # Initialize interfaces
 logger.debug(f"System: Initializing Interfaces")
 interface1 = interface2 = interface3 = interface4 = interface5 = interface6 = interface7 = interface8 = interface9 = None
@@ -365,6 +394,44 @@ for i in range(1, 10):
     else:
         globals()[f'myNodeNum{i}'] = 777
 
+# Fetch channel list from each device
+channel_list = []
+for i in range(1, 10):
+    if globals().get(f'interface{i}') and globals().get(f'interface{i}_enabled'):
+        try:
+            node = globals()[f'interface{i}'].getNode('^local')
+            channels = node.channels
+            channel_dict = {}
+            for channel in channels:
+                if hasattr(channel, 'role') and channel.role:
+                    channel_name = getattr(channel.settings, 'name', '').strip()
+                    channel_number = getattr(channel, 'index', 0)
+                    # Only add channels with a non-empty name
+                    if channel_name:
+                        channel_dict[channel_name] = channel_number
+            channel_list.append({
+                "interface_id": i,
+                "channels": channel_dict
+            })
+            logger.debug(f"System: Fetched Channel List from Device{i}")
+        except Exception as e:
+            logger.error(f"System: Error fetching channel list from Device{i}: {e}")
+
+# add channel hash to channel_list
+for device in channel_list:
+    interface_id = device["interface_id"]
+    interface = globals().get(f'interface{interface_id}')
+    for channel_name, channel_number in device["channels"].items():
+        psk_base64 = "AQ=="  # default PSK
+        channel_hash = generate_hash(channel_name, psk_base64)
+        # add hash to the channel entry in channel_list under key 'hash'
+        for entry in channel_list:
+            if entry["interface_id"] == interface_id:
+                entry["channels"][channel_name] = {
+                    "number": channel_number,
+                    "hash": channel_hash
+                }
+
 #### FUN-ctions ####
 
 def cleanup_memory():
@@ -454,26 +521,32 @@ def get_name_from_number(number, type='long', nodeInt=1):
             name =  str(decimal_to_hex(number))  # If name not found, use the ID as string
     return name
 
-
 def get_num_from_short_name(short_name, nodeInt=1):
+    # First, search the specified interface
     interface = globals()[f'interface{nodeInt}']
-    # Get the node number from the short name, converting all to lowercase for comparison (good practice?)
-    logger.debug(f"System: Getting Node Number from Short Name: {short_name} on Device: {nodeInt}")
+    logger.debug(f"System: Checking Node Number from Short Name: {short_name} on Device: {nodeInt}")
     for node in interface.nodes.values():
-        #logger.debug(f"System: Checking Node: {node['user']['shortName']} against {short_name} for number {node['num']}")
-        if short_name == node['user']['shortName']:
+        if short_name == node['user']['shortName'] or str(short_name).lower() == node['user']['shortName'].lower():
             return node['num']
-        elif str(short_name.lower()) == node['user']['shortName'].lower():
-            return node['num']
-        else:
-            for int in range(1, 10):
-                if globals().get(f'interface{int}_enabled') and int != nodeInt:
-                    other_interface = globals().get(f'interface{int}')
-                    for node in other_interface.nodes.values():
-                        if short_name == node['user']['shortName']:
-                            return node['num']
-                        elif str(short_name.lower()) == node['user']['shortName'].lower():
-                            return node['num']
+
+    # If not found, search all other enabled interfaces
+    for iface_num in range(1, 10):
+        if iface_num == nodeInt:
+            continue
+        if globals().get(f'interface{iface_num}_enabled'):
+            other_interface = globals().get(f'interface{iface_num}')
+            for node in other_interface.nodes.values():
+                if short_name == node['user']['shortName'] or str(short_name).lower() == node['user']['shortName'].lower():
+                    logger.debug(f"System: Found Device:{iface_num} Node:{node['user']['shortName']}")
+                    return node['num']
+
+    # !hex node IDs
+    if str(short_name).startswith("!"):
+        try:
+            return int(short_name[1:], 16)
+        except Exception:
+            pass
+
     return 0
     
 def get_node_list(nodeInt=1):
@@ -1046,105 +1119,135 @@ priorVolcanoAlert = ""
 priorEmergencyAlert = ""
 priorWxAlert = ""
 def handleAlertBroadcast(deviceID=1):
-    global priorVolcanoAlert, priorEmergencyAlert, priorWxAlert
-    alertUk = NO_ALERTS
-    alertDe = NO_ALERTS
-    alertFema = NO_ALERTS
-    wxAlert = NO_ALERTS
-    volcanoAlert = NO_ALERTS
-    alertWx = False
-    # only allow API call every 20 minutes
-    # the watchdog will call this function 3 times, seeing possible throttling on the API
-    clock = datetime.now()
-    if clock.minute % 20 != 0:
-        return False
-    if clock.second > 17:
-        return False
-    
-    # check for alerts
-    if wxAlertBroadcastEnabled:
-        alertWx = alertBrodcastNOAA()
+    try:
+        global priorVolcanoAlert, priorEmergencyAlert, priorWxAlert
+        alertUk = NO_ALERTS
+        alertDe = NO_ALERTS
+        alertFema = NO_ALERTS
+        wxAlert = NO_ALERTS
+        volcanoAlert = NO_ALERTS
+        overdueAlerts = NO_ALERTS
+        alertWx = False
+        # only allow API call every 20 minutes
+        # the watchdog will call this function 3 times, seeing possible throttling on the API
+        clock = datetime.now()
+        if clock.minute % 20 != 0:
+            return False
+        if clock.second > 17:
+            return False
+        
+        # check for alerts
+        if wxAlertBroadcastEnabled:
+            alertWx = alertBrodcastNOAA()
 
-    if emergencyAlertBrodcastEnabled:
-        if enableDEalerts:
-            alertDe = get_nina_alerts()
-        if enableGBalerts:
-            alertUk = get_govUK_alerts()
+        if emergencyAlertBrodcastEnabled:
+            if enableDEalerts:
+                alertDe = get_nina_alerts()
+            if enableGBalerts:
+                alertUk = get_govUK_alerts()
+            else:
+                # default USA alerts
+                alertFema = getIpawsAlert(latitudeValue,longitudeValue, shortAlerts=True)
+
+        if checklist_enabled:
+            overdueAlerts = format_overdue_alert()
+        
+        # format alert
+        if alertWx:
+            wxAlert = f"🚨 {alertWx[1]} EAS-WX ALERT: {alertWx[0]}"
         else:
-            # default USA alerts
-            alertFema = getIpawsAlert(latitudeValue,longitudeValue, shortAlerts=True)
+            wxAlert = False
 
-    # format alert
-    if alertWx:
-        wxAlert = f"🚨 {alertWx[1]} EAS-WX ALERT: {alertWx[0]}"
-    else:
-        wxAlert = False
+        femaAlert = alertFema
+        ukAlert = alertUk
+        deAlert = alertDe
 
-    femaAlert = alertFema
-    ukAlert = alertUk
-    deAlert = alertDe
+        if overdueAlerts != NO_ALERTS and overdueAlerts != None:
+            logger.debug("System: Adding overdue checkin to emergency alerts")
+            if femaAlert and NO_ALERTS not in femaAlert and ERROR_FETCHING_DATA not in femaAlert:
+                femaAlert += "\n\n" + overdueAlerts
+            elif ukAlert and NO_ALERTS not in ukAlert and ERROR_FETCHING_DATA not in ukAlert:
+                ukAlert += "\n\n" + overdueAlerts
+            elif deAlert and NO_ALERTS not in deAlert and ERROR_FETCHING_DATA not in deAlert:
+                deAlert += "\n\n" + overdueAlerts
+            else:
+                # only overdue alerts to send
+                if overdueAlerts != "" and overdueAlerts is not None and overdueAlerts != NO_ALERTS:
+                    if overdueAlerts != priorEmergencyAlert:
+                        priorEmergencyAlert = overdueAlerts
+                    else:
+                        return False
+                    if isinstance(emergencyAlertBroadcastCh, list):
+                        for channel in emergencyAlertBroadcastCh:
+                            send_message(overdueAlerts, int(channel), 0, deviceID)
+                    else:
+                        send_message(overdueAlerts, emergencyAlertBroadcastCh, 0, deviceID)
+                        return True
 
-    if emergencyAlertBrodcastEnabled:
-        if NO_ALERTS not in femaAlert and ERROR_FETCHING_DATA not in femaAlert:
-            if femaAlert != priorEmergencyAlert:
-                priorEmergencyAlert = femaAlert
-            else:
-                return False
-            if isinstance(emergencyAlertBroadcastCh, list):
-                for channel in emergencyAlertBroadcastCh:
-                    send_message(femaAlert, int(channel), 0, deviceID)
-            else:
-                send_message(femaAlert, emergencyAlertBroadcastCh, 0, deviceID)
-            return True
-        if NO_ALERTS not in ukAlert:
-            if ukAlert != priorEmergencyAlert:
-                priorEmergencyAlert = ukAlert
-            else:
-                return False
-            if isinstance(emergencyAlertBroadcastCh, list):
-                for channel in emergencyAlertBroadcastCh:
-                    send_message(ukAlert, int(channel), 0, deviceID)
-            else:
-                send_message(ukAlert, emergencyAlertBroadcastCh, 0, deviceID)
-            return True
-
-        if NO_ALERTS not in alertDe:
-            if deAlert != priorEmergencyAlert:
-                priorEmergencyAlert = deAlert
-            else:
-                return False
-            if isinstance(emergencyAlertBroadcastCh, list):
-                for channel in emergencyAlertBroadcastCh:
-                    send_message(deAlert, int(channel), 0, deviceID)
-            else:
-                send_message(deAlert, emergencyAlertBroadcastCh, 0, deviceID)
-            return True
-
-    if wxAlertBroadcastEnabled:
-        if wxAlert:
-            if wxAlert != priorWxAlert:
-                priorWxAlert = wxAlert
-            else:
-                return False
-            if isinstance(wxAlertBroadcastChannel, list):
-                for channel in wxAlertBroadcastChannel:
-                    send_message(wxAlert, int(channel), 0, deviceID)
-            else:
-                send_message(wxAlert, wxAlertBroadcastChannel, 0, deviceID)
-            return True
-
-    if volcanoAlertBroadcastEnabled:
-        volcanoAlert = get_volcano_usgs(latitudeValue, longitudeValue)
-        if volcanoAlert and NO_ALERTS not in volcanoAlert and ERROR_FETCHING_DATA not in volcanoAlert:
-            # check if the alert is different from the last one
-            if volcanoAlert != priorVolcanoAlert:
-                priorVolcanoAlert = volcanoAlert
-                if isinstance(volcanoAlertBroadcastChannel, list):
-                    for channel in volcanoAlertBroadcastChannel:
-                        send_message(volcanoAlert, int(channel), 0, deviceID)
+        if emergencyAlertBrodcastEnabled:
+            if NO_ALERTS not in femaAlert and ERROR_FETCHING_DATA not in femaAlert:
+                if femaAlert != priorEmergencyAlert:
+                    priorEmergencyAlert = femaAlert
                 else:
-                    send_message(volcanoAlert, volcanoAlertBroadcastChannel, 0, deviceID)
+                    return False
+                if isinstance(emergencyAlertBroadcastCh, list):
+                    for channel in emergencyAlertBroadcastCh:
+                        send_message(femaAlert, int(channel), 0, deviceID)
+                else:
+                    send_message(femaAlert, emergencyAlertBroadcastCh, 0, deviceID)
                 return True
+            if NO_ALERTS not in ukAlert:
+                if ukAlert != priorEmergencyAlert:
+                    priorEmergencyAlert = ukAlert
+                else:
+                    return False
+                if isinstance(emergencyAlertBroadcastCh, list):
+                    for channel in emergencyAlertBroadcastCh:
+                        send_message(ukAlert, int(channel), 0, deviceID)
+                else:
+                    send_message(ukAlert, emergencyAlertBroadcastCh, 0, deviceID)
+                return True
+
+            if NO_ALERTS not in alertDe:
+                if deAlert != priorEmergencyAlert:
+                    priorEmergencyAlert = deAlert
+                else:
+                    return False
+                if isinstance(emergencyAlertBroadcastCh, list):
+                    for channel in emergencyAlertBroadcastCh:
+                        send_message(deAlert, int(channel), 0, deviceID)
+                else:
+                    send_message(deAlert, emergencyAlertBroadcastCh, 0, deviceID)
+                return True
+
+        if wxAlertBroadcastEnabled:
+            if wxAlert:
+                if wxAlert != priorWxAlert:
+                    priorWxAlert = wxAlert
+                else:
+                    return False
+                if isinstance(wxAlertBroadcastChannel, list):
+                    for channel in wxAlertBroadcastChannel:
+                        send_message(wxAlert, int(channel), 0, deviceID)
+                else:
+                    send_message(wxAlert, wxAlertBroadcastChannel, 0, deviceID)
+                return True
+
+        if volcanoAlertBroadcastEnabled:
+            volcanoAlert = get_volcano_usgs(latitudeValue, longitudeValue)
+            if volcanoAlert and NO_ALERTS not in volcanoAlert and ERROR_FETCHING_DATA not in volcanoAlert:
+                # check if the alert is different from the last one
+                if volcanoAlert != priorVolcanoAlert:
+                    priorVolcanoAlert = volcanoAlert
+                    if isinstance(volcanoAlertBroadcastChannel, list):
+                        for channel in volcanoAlertBroadcastChannel:
+                            send_message(volcanoAlert, int(channel), 0, deviceID)
+                    else:
+                        send_message(volcanoAlert, volcanoAlertBroadcastChannel, 0, deviceID)
+                    return True
+    except Exception as e:
+        logger.error(f"System: Error in handleAlertBroadcast: {e}")
+    return False
 
 def onDisconnect(interface):
     # Handle disconnection of the interface
@@ -1295,9 +1398,11 @@ def initializeMeshLeaderboard():
         'longestUptime': {'nodeID': None, 'value': 0, 'timestamp': 0},    # 🕰️
         'fastestSpeed': {'nodeID': None, 'value': 0, 'timestamp': 0},     # 🚓
         'highestAltitude': {'nodeID': None, 'value': 0, 'timestamp': 0},  # 🚀
+        'tallestNode': {'nodeID': None, 'value': 0, 'timestamp': 0},      # 🪜
         'coldestTemp': {'nodeID': None, 'value': 999, 'timestamp': 0},    # 🥶
         'hottestTemp': {'nodeID': None, 'value': -999, 'timestamp': 0},   # 🥵
         'worstAirQuality': {'nodeID': None, 'value': 0, 'timestamp': 0},  # 💨
+        'mostTMessages': {'nodeID': None, 'value': 0, 'timestamp': 0},    # 💬
         'mostMessages': {'nodeID': None, 'value': 0, 'timestamp': 0},     # 💬
         'highestDBm': {'nodeID': None, 'value': -999, 'timestamp': 0},    # 📶
         'weakestDBm': {'nodeID': None, 'value': 999, 'timestamp': 0},     # 📶
@@ -1307,7 +1412,11 @@ def initializeMeshLeaderboard():
         'adminPackets': [],      # 🚨
         'tunnelPackets': [],     # 🚨
         'audioPackets': [],      # ☎️
-        'simulatorPackets': []   # 🤖
+        'simulatorPackets': [],  # 🤖
+        'emojiCounts': {},       # Track emoji counts per node
+        'emojiTypeCounts': {},   # Track emoji type counts
+        'nodeMessageCounts': {},  # Track total message counts per node
+        'nodeTMessageCounts': {}  # Track total Tmessage counts per node
     }
 
 initializeMeshLeaderboard()
@@ -1325,16 +1434,6 @@ def consumeMetadata(packet, rxNode=0, channel=-1):
         
         # if not a bot ID track it
         if nodeID != globals().get(f'myNodeNum{rxNode}') and nodeID != 0:
-            # consider Meta for most messages leaderboard
-            node_message_count = meshLeaderboard.get('nodeMessageCounts', {})
-            node_message_count[nodeID] = node_message_count.get(nodeID, 0) + 1
-            meshLeaderboard['nodeMessageCounts'] = node_message_count    
-            
-            if node_message_count[nodeID] > meshLeaderboard['mostMessages']['value']:
-                meshLeaderboard['mostMessages']['value'] = node_message_count[nodeID]
-                meshLeaderboard['mostMessages']['nodeID'] = nodeID
-                meshLeaderboard['mostMessages']['timestamp'] = time.time()
-
             # consider Meta for highest and weakest DBm
             if packet.get('rxSnr') is not None:
                 dbm = packet['rxSnr']
@@ -1342,6 +1441,20 @@ def consumeMetadata(packet, rxNode=0, channel=-1):
                     meshLeaderboard['highestDBm'] = {'nodeID': nodeID, 'value': dbm, 'timestamp': time.time()}
                 if dbm < meshLeaderboard['weakestDBm']['value']:
                     meshLeaderboard['weakestDBm'] = {'nodeID': nodeID, 'value': dbm, 'timestamp': time.time()}
+
+            # Meta for most Messages leaderboard
+            if packet_type == 'TEXT_MESSAGE':
+                message_count = meshLeaderboard.get('nodeMessageCounts', {})
+                message_count[nodeID] = message_count.get(nodeID, 0) + 1
+                meshLeaderboard['nodeMessageCounts'] = message_count
+                if message_count[nodeID] > meshLeaderboard['mostMessages']['value']:
+                    meshLeaderboard['mostMessages'] = {'nodeID': nodeID, 'value': message_count[nodeID], 'timestamp': time.time()}
+            else:
+                tmessage_count = meshLeaderboard.get('nodeTMessageCounts', {})
+                tmessage_count[nodeID] = tmessage_count.get(nodeID, 0) + 1
+                meshLeaderboard['nodeTMessageCounts'] = tmessage_count
+                if tmessage_count[nodeID] > meshLeaderboard['mostTMessages']['value']:
+                    meshLeaderboard['mostTMessages'] = {'nodeID': nodeID, 'value': tmessage_count[nodeID], 'timestamp': time.time()}
         
     except Exception as e:
         logger.debug(f"System: Metadata decode error: Device: {rxNode} Channel: {channel} {e} packet {packet}")
@@ -1351,10 +1464,11 @@ def consumeMetadata(packet, rxNode=0, channel=-1):
         if debugMetadata and 'TELEMETRY_APP' not in metadataFilter:
             print(f"DEBUG TELEMETRY_APP: {packet}\n\n")
         telemetry_packet = packet['decoded']['telemetry']
-        # Track lowest battery 🪫
+        # Track device metrics (battery, uptime)
         if telemetry_packet.get('deviceMetrics'):
             deviceMetrics = telemetry_packet['deviceMetrics']
             current_time = time.time()
+            # Track lowest battery 🪫
             try:
                 if deviceMetrics.get('batteryLevel') is not None:
                     battery = float(deviceMetrics['batteryLevel'])
@@ -1444,11 +1558,28 @@ def consumeMetadata(packet, rxNode=0, channel=-1):
                     meshLeaderboard['highestAltitude'] = {'nodeID': nodeID, 'value': altitude, 'timestamp': time.time()}
                     if logMetaStats:
                         logger.info(f"System: 🚀 New altitude record: {altitude}m from NodeID:{nodeID} ShortName:{get_name_from_number(nodeID, 'short', rxNode)}")
+            # Track tallest node 🪜 (under the highfly_altitude limit by 100m)
+            if position_data.get('altitude') is not None:
+                altitude = position_data['altitude']
+                if altitude < (highfly_altitude - 100):
+                    if altitude > meshLeaderboard['tallestNode']['value']:
+                        meshLeaderboard['tallestNode'] = {'nodeID': nodeID, 'value': altitude, 'timestamp': time.time()}
+                        if logMetaStats:
+                            logger.info(f"System: 🪜 New tallest node record: {altitude}m from NodeID:{nodeID} ShortName:{get_name_from_number(nodeID, 'short', rxNode)}")
+
             # if altitude is over highfly_altitude send a log and message for high-flying nodes and not in highfly_ignoreList
             if position_data.get('altitude', 0) > highfly_altitude and highfly_enabled and str(nodeID) not in highfly_ignoreList and not isNodeBanned(nodeID):
                 logger.info(f"System: High Altitude {position_data['altitude']}m on Device: {rxNode} Channel: {channel} NodeID:{nodeID} Lat:{position_data.get('latitude', 0)} Lon:{position_data.get('longitude', 0)}")
                 altFeet = round(position_data['altitude'] * 3.28084, 2)
                 msg = f"🚀 High Altitude Detected! NodeID:{nodeID} Alt:{altFeet:,.0f}ft/{position_data['altitude']:,.0f}m"
+                
+                # throttle sending alerts for the same node more than once every 30 minutes
+                last_alert_time = positionMetadata[nodeID].get('lastHighFlyAlert', 0)
+                current_time = time.time()
+                if current_time - last_alert_time < 1800:
+                    return False # less than 30 minutes since last alert
+                positionMetadata[nodeID]['lastHighFlyAlert'] = current_time
+                
                 if highfly_check_openskynetwork:
                     # check get_openskynetwork to see if the node is an aircraft
                     if 'latitude' in position_data and 'longitude' in position_data:
@@ -1463,9 +1594,10 @@ def consumeMetadata(packet, rxNode=0, channel=-1):
                     ):
                         plane_alt = flight_info['altitude']
                         node_alt = position_data.get('altitude', 0)
-                        if abs(node_alt - plane_alt) <= 900:  # within 900m
+                        if abs(node_alt - plane_alt) <= 1000:  # within 1000 meters
                             msg += f"\n✈️Detected near:\n{flight_info}"
                 send_message(msg, highfly_channel, 0, highfly_interface)
+
             # Keep the positionMetadata dictionary at a maximum size
             if len(positionMetadata) > MAX_SEEN_NODES:
                 # Remove the oldest entry
@@ -1687,12 +1819,12 @@ def saveLeaderboard():
 def loadLeaderboard():
     global meshLeaderboard
     try:
-        defaults = {}
-        initializeMeshLeaderboard()
         with open('data/leaderboard.pkl', 'rb') as f:
-            meshLeaderboard = pickle.load(f)
-        defaults.update(meshLeaderboard)  # loaded values overwrite defaults
-        meshLeaderboard = defaults
+            loaded = pickle.load(f)
+        # Merge with current default structure to add any new keys
+        initializeMeshLeaderboard()  # sets meshLeaderboard to default structure
+        for k, v in loaded.items():
+            meshLeaderboard[k] = v
         if logMetaStats:
             logger.debug("System: Mesh Leaderboard loaded from leaderboard.pkl")
     except FileNotFoundError:
@@ -1743,6 +1875,16 @@ def get_mesh_leaderboard(msg, fromID, deviceID):
             result += f"🚀 Altitude: {int(round(value_m, 0))}m {get_name_from_number(nodeID, 'short', 1)}\n"
         else:
             result += f"🚀 Altitude: {int(value_ft)}ft {get_name_from_number(nodeID, 'short', 1)}\n"
+
+    # Tallest node
+    if meshLeaderboard['tallestNode']['nodeID']:
+        nodeID = meshLeaderboard['tallestNode']['nodeID']
+        value_m = meshLeaderboard['tallestNode']['value']
+        value_ft = round(value_m * 3.28084, 0)
+        if use_metric:
+            result += f"🪜 Tallest: {int(round(value_m, 0))}m {get_name_from_number(nodeID, 'short', 1)}\n"
+        else:
+            result += f"🪜 Tallest: {int(value_ft)}ft {get_name_from_number(nodeID, 'short', 1)}\n"
     
     # Coldest temperature
     if meshLeaderboard['coldestTemp']['nodeID']:
@@ -1783,16 +1925,29 @@ def get_mesh_leaderboard(msg, fromID, deviceID):
         result += f"📶 Best RF: {value} dBm {get_name_from_number(nodeID, 'short', 1)}\n"
 
     # Most Telemetry Messages
+    if 'nodeTMessageCounts' in meshLeaderboard and meshLeaderboard['mostTMessages']['nodeID'] is not None:
+        nodeID = meshLeaderboard['mostTMessages']['nodeID']
+        value = meshLeaderboard['mostTMessages']['value']
+        result += f"📊 Most Telemetry: {value} {get_name_from_number(nodeID, 'short', 1)}\n"
+
+    # Most Emojis
+    if meshLeaderboard.get('mostEmojis', {}).get('nodeID') is not None:
+        nodeID = meshLeaderboard['mostEmojis']['nodeID']
+        value = meshLeaderboard['mostEmojis']['value']
+        result += f"🤪 Most Emojis: {value} {get_name_from_number(nodeID, 'short', 1)}\n"
+    
+    # Most Messages
     if 'nodeMessageCounts' in meshLeaderboard and meshLeaderboard['mostMessages']['nodeID'] is not None:
         nodeID = meshLeaderboard['mostMessages']['nodeID']
         value = meshLeaderboard['mostMessages']['value']
-        result += f"💬 Most Telemetry: {value} {get_name_from_number(nodeID, 'short', 1)}\n"
+        result += f"💬 Most Messages: {value} {get_name_from_number(nodeID, 'short', 1)}\n"
 
     # Most WiFi devices seen
     if meshLeaderboard.get('mostPaxWiFi', {}).get('nodeID'):
         nodeID = meshLeaderboard['mostPaxWiFi']['nodeID']
         value = meshLeaderboard['mostPaxWiFi']['value']
         result += f"📶 PAX Wifi: {value} {get_name_from_number(nodeID, 'short', 1)}\n"
+
     # Most BLE devices seen
     if meshLeaderboard.get('mostPaxBLE', {}).get('nodeID'):
         nodeID = meshLeaderboard['mostPaxBLE']['nodeID']
@@ -1830,12 +1985,6 @@ def get_sysinfo(nodeID=0, deviceID=1):
     sysinfo += f"📊{stats}"
     return sysinfo
 
-async def BroadcastScheduler():
-    # handle schedule checks for the broadcast of messages
-    while True:
-        schedule.run_pending()
-        await asyncio.sleep(1)
-
 async def handleSignalWatcher():
     global lastHamLibAlert
     # monitor rigctld for signal strength and frequency
@@ -1898,6 +2047,62 @@ async def handleFileWatcher():
         await asyncio.sleep(1)
         pass
 
+async def handleWsjtxWatcher():
+    # monitor WSJT-X UDP broadcasts for decode messages
+    from modules.radio import wsjtxMsgQueue, wsjtxMonitor
+    from modules.settings import sigWatchBroadcastCh, sigWatchBroadcastInterface
+    
+    # Start the WSJT-X monitor task
+    monitor_task = asyncio.create_task(wsjtxMonitor())
+    
+    while True:
+        if wsjtxMsgQueue:
+            msg = wsjtxMsgQueue.pop(0)
+            logger.debug(f"System: Detected message from WSJT-X: {msg}")
+            
+            # Broadcast to configured channels
+            if type(sigWatchBroadcastCh) is list:
+                for ch in sigWatchBroadcastCh:
+                    if antiSpam and int(ch) != publicChannel:
+                        send_message(msg, int(ch), 0, sigWatchBroadcastInterface)
+                    else:
+                        logger.warning(f"System: antiSpam prevented Alert from WSJT-X")
+            else:
+                if antiSpam and sigWatchBroadcastCh != publicChannel:
+                    send_message(msg, int(sigWatchBroadcastCh), 0, sigWatchBroadcastInterface)
+                else:
+                    logger.warning(f"System: antiSpam prevented Alert from WSJT-X")
+        
+        await asyncio.sleep(0.5)
+
+async def handleJs8callWatcher():
+    # monitor JS8Call TCP API for messages
+    from modules.radio import js8callMsgQueue, js8callMonitor
+    from modules.settings import sigWatchBroadcastCh, sigWatchBroadcastInterface
+    
+    # Start the JS8Call monitor task
+    monitor_task = asyncio.create_task(js8callMonitor())
+    
+    while True:
+        if js8callMsgQueue:
+            msg = js8callMsgQueue.pop(0)
+            logger.debug(f"System: Detected message from JS8Call: {msg}")
+            
+            # Broadcast to configured channels
+            if type(sigWatchBroadcastCh) is list:
+                for ch in sigWatchBroadcastCh:
+                    if antiSpam and int(ch) != publicChannel:
+                        send_message(msg, int(ch), 0, sigWatchBroadcastInterface)
+                    else:
+                        logger.warning(f"System: antiSpam prevented Alert from JS8Call")
+            else:
+                if antiSpam and sigWatchBroadcastCh != publicChannel:
+                    send_message(msg, int(sigWatchBroadcastCh), 0, sigWatchBroadcastInterface)
+                else:
+                    logger.warning(f"System: antiSpam prevented Alert from JS8Call")
+        
+        await asyncio.sleep(0.5)
+
 async def retry_interface(nodeID):
     global retry_int1, retry_int2, retry_int3, retry_int4, retry_int5, retry_int6, retry_int7, retry_int8, retry_int9
     global 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
@@ -1949,45 +2154,62 @@ handleSentinel_spotted = []
 handleSentinel_loop = 0
 async def handleSentinel(deviceID):
     global handleSentinel_spotted, handleSentinel_loop
-    detectedNearby = ""
+    detectedNearby = None
     resolution = "unknown"
-    closest_nodes = await get_closest_nodes(deviceID)
-    closest_node = closest_nodes[0]['id'] if closest_nodes != ERROR_FETCHING_DATA and closest_nodes else None
-    closest_distance = closest_nodes[0]['distance'] if closest_nodes != ERROR_FETCHING_DATA and closest_nodes else None
 
-    # check if the handleSentinel_spotted list contains the closest node already
-    if closest_node in [i['id'] for i in handleSentinel_spotted]:
-        # check if the distance is closer than the last time, if not just return
-        for i in range(len(handleSentinel_spotted)):
-            if handleSentinel_spotted[i]['id'] == closest_node and closest_distance is not None and closest_distance < handleSentinel_spotted[i]['distance']:
-                handleSentinel_spotted[i]['distance'] = closest_distance
-                break
-            else:
-                return
-    
-    if closest_nodes != ERROR_FETCHING_DATA and closest_nodes:
-        if closest_nodes[0]['id'] is not None:
-            detectedNearby = get_name_from_number(closest_node, 'long', deviceID)
-            detectedNearby += ", " + get_name_from_number(closest_nodes[0]['id'], 'short', deviceID)
-            detectedNearby += ", " + str(closest_nodes[0]['id'])
-            detectedNearby += ", " + decimal_to_hex(closest_nodes[0]['id'])
-            detectedNearby += f" at {closest_distance}m"
+    closest_nodes = await get_closest_nodes(deviceID, returnCount=10)
+    #logger.debug(f"handleSentinel: closest_nodes={closest_nodes}")
 
-    if handleSentinel_loop >= sentry_holdoff and detectedNearby not in ["", None]:
-        if closest_nodes and positionMetadata and closest_nodes[0]['id'] in positionMetadata:
-            metadata = positionMetadata[closest_nodes[0]['id']]
-            if metadata.get('precisionBits') is not None:
-                resolution = metadata.get('precisionBits')
+    if not closest_nodes or closest_nodes == ERROR_FETCHING_DATA:
+        return
 
-        logger.warning(f"System: {detectedNearby} is close to your location on Interface{deviceID} Accuracy is {resolution}bits")
-        send_message(f"Sentry{deviceID}: {detectedNearby}", secure_channel, 0, secure_interface)
-        if enableSMTP and email_sentry_alerts:
-            for email in sysopEmails:
-                send_email(email, f"Sentry{deviceID}: {detectedNearby}")
-        handleSentinel_loop = 0
-        handleSentinel_spotted.append({'id': closest_node, 'distance': closest_distance})
-    else:
+    # Find any watched node inside or outside the zone
+    for node in closest_nodes:
+        node_id = node['id']
+        distance = node['distance']
+
+        if str(node_id) in sentryIgnoreList:
+            return
+        # Message conditions
+        if distance >= sentry_radius and str(node_id) and str(node_id) in sentryWatchList:
+            # Outside zone
+            detectedNearby = f"{get_name_from_number(node_id, 'long', deviceID)}, {get_name_from_number(node_id, 'short', deviceID)}, {node_id}, {decimal_to_hex(node_id)} at {distance}m (OUTSIDE ZONE)"
+        elif distance <= sentry_radius and str(node_id) not in sentryWatchList:
+            # Inside the zone
+            detectedNearby = f"{get_name_from_number(node_id, 'long', deviceID)}, {get_name_from_number(node_id, 'short', deviceID)}, {node_id}, {decimal_to_hex(node_id)} at {distance}m (INSIDE ZONE)"
+
+    #logger.debug(f"handleSentinel: loop={handleSentinel_loop}/{sentry_holdoff}, detectedNearby={detectedNearby} closest_nodes={closest_nodes}")
+    if detectedNearby:
         handleSentinel_loop += 1
+        #logger.debug(f"handleSentinel: detectedNearby={detectedNearby}, loop={handleSentinel_loop}/{sentry_holdoff}")
+        if handleSentinel_loop >= sentry_holdoff:
+            # Get resolution if available
+            if positionMetadata and node_id in positionMetadata:
+                metadata = positionMetadata[node_id]
+                if metadata.get('precisionBits') is not None:
+                    resolution = metadata.get('precisionBits')
+            # Send message alert
+            logger.warning(f"System: {detectedNearby} on Interface{deviceID} Accuracy is {resolution}bits")
+            send_message(f"Sentry{deviceID}: {detectedNearby}", secure_channel, 0, secure_interface)
+            
+            # Send email alerts
+            if enableSMTP and email_sentry_alerts:
+                for email in sysopEmails:
+                    send_email(email, f"Sentry{deviceID}: {detectedNearby}")
+
+            # Execute external script alerts
+            if cmdShellSentryAlerts and distance <= sentry_radius:
+                # inside zone
+                call_external_script('', script=sentryAlertNear)
+                logger.info(f"System: Sentry Script Alert {sentryAlertNear} for NodeID:{node_id} on Interface{deviceID}")
+            elif cmdShellSentryAlerts and distance >= sentry_radius:
+                # outside zone
+                call_external_script('', script=sentryAlertFar)
+                logger.info(f"System: Sentry Script Alert {sentryAlertFar} for NodeID:{node_id} on Interface{deviceID}")
+
+            handleSentinel_loop = 0 # Loop reset
+    else:
+        handleSentinel_loop = 0  # Reset if nothing detected
 
 async def process_vox_queue():
         # process the voxMsgQueue
@@ -2005,12 +2227,16 @@ async def process_vox_queue():
 async def watchdog():
     global localTelemetryData, retry_int1, retry_int2, retry_int3, retry_int4, retry_int5, retry_int6, retry_int7, retry_int8, retry_int9
     logger.debug("System: Watchdog started")
+    wd_last_logged_minute = -1
     while True:
         await asyncio.sleep(20)
+        now = datetime.now()
 
-        # perform memory cleanup every 10 minutes
-        if datetime.now().minute % 10 == 0:
+                    
+        if now.minute % 20 == 0 and now.minute != wd_last_logged_minute:
+            # perform memory cleanup every 10 minutes
             cleanup_memory()
+            wd_last_logged_minute = now.minute
 
         # check all interfaces
         for i in range(1, 10):
@@ -2030,7 +2256,7 @@ async def watchdog():
 
                     handleMultiPing(0, i)
 
-                    if wxAlertBroadcastEnabled or emergencyAlertBrodcastEnabled or volcanoAlertBroadcastEnabled:
+                    if wxAlertBroadcastEnabled or emergencyAlertBrodcastEnabled or volcanoAlertBroadcastEnabled or checklist_enabled:
                         handleAlertBroadcast(i)
 
                     intData = displayNodeTelemetry(0, i)

modules/test_bot.py

@@ -0,0 +1,459 @@
+# test_bot.py
+# Unit tests for various modules in the meshing-around project
+import os
+import sys
+
+# Add the parent directory to sys.path to allow module imports
+parent_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..'))
+sys.path.insert(0, parent_path)
+
+import unittest
+import importlib
+import pkgutil
+import warnings
+from modules.log import logger
+from modules.settings import latitudeValue, longitudeValue
+# Suppress ResourceWarning warnings for asyncio unclosed event  here
+warnings.filterwarnings("ignore", category=ResourceWarning)
+
+
+modules_path = os.path.join(parent_path, 'modules')
+
+# Limits API calls during testing
+CHECKALL = False
+# Check for a file named .checkall in the parent directory
+checkall_path = os.path.join(parent_path, '.checkall')
+if os.path.isfile(checkall_path):
+    CHECKALL = True
+
+
+# List of module names to exclude
+exclude = ['test_bot','udp', 'system', 'log', 'gpio', 'web','test_xtide',]
+available_modules = [
+    m.name for m in pkgutil.iter_modules([modules_path])
+    if m.name not in exclude]
+
+try:
+    print("\nImporting Core Modules:")
+    from modules.log import logger, getPrettyTime
+    print("  ✔ Imported 'log'")
+    # Set location default
+    lat = latitudeValue
+    lon = longitudeValue
+    print(f"  ✔ Location set to Latitude: {lat}, Longitude: {lon}")
+    from modules.system import *
+    print("  ✔ Imported 'system'")
+    
+    print("\nImporting non-excluded modules:")
+    for module_name in [m.name for m in pkgutil.iter_modules([modules_path])]:
+        if module_name not in exclude:
+            importlib.import_module(module_name)
+            print(f"  ✔ Imported '{module_name}'")
+except Exception as e:
+    print(f"\nError importing modules: {e}")
+    print("Run this program from the main program directory: python3 script/test_bot.py")
+    exit(1)
+
+class TestBot(unittest.TestCase):
+    def test_example(self):
+        # Example test case
+        self.assertEqual(1 + 1, 2)
+
+    def test_load_bbsdb(self):
+        from bbstools import load_bbsdb
+        test_load = load_bbsdb()
+        self.assertTrue(test_load)
+    
+    def test_bbs_list_messages(self):
+        from bbstools import bbs_list_messages
+        messages = bbs_list_messages()
+        print("list_messages() returned:", messages)
+        self.assertIsInstance(messages, str)
+
+    def test_initialize_checklist_database(self):
+        from checklist import initialize_checklist_database, process_checklist_command
+        result = initialize_checklist_database()
+        result1 = process_checklist_command(0, 'checklist', name="none", location="none")
+        self.assertTrue(result)
+        self.assertIsInstance(result1, str)
+
+    def test_init_news_sources(self):
+        from filemon import initNewsSources
+        result = initNewsSources()
+        self.assertTrue(result)
+
+    def test_get_nina_alerts(self):
+        from globalalert import get_nina_alerts
+        alerts = get_nina_alerts()
+        self.assertIsInstance(alerts, str)
+
+    def test_llmTool_get_google(self):
+        from llm import llmTool_get_google
+        result = llmTool_get_google("What is 2+2?",  1)
+        self.assertIsInstance(result, list)
+
+    def test_send_ollama_query(self):
+        from llm import send_ollama_query
+        response = send_ollama_query("Hello, Ollama!")
+        self.assertIsInstance(response, str)
+
+    def test_extract_search_terms(self):
+        from llm import extract_search_terms
+        # Test with capitalized terms
+        terms = extract_search_terms("What is Python programming?")
+        self.assertIsInstance(terms, list)
+        self.assertTrue(len(terms) > 0)
+        # Test with multiple capitalized words
+        terms2 = extract_search_terms("Tell me about Albert Einstein and Marie Curie")
+        self.assertIsInstance(terms2, list)
+        self.assertTrue(len(terms2) > 0)
+
+    def test_get_wiki_context(self):
+        from llm import get_wiki_context
+        # Test with a well-known topic
+        context = get_wiki_context("Python programming language")
+        self.assertIsInstance(context, str)
+        # Context might be empty if wiki is disabled or fails, that's ok
+
+    def test_get_moon_phase(self):
+        from space import get_moon
+        phase = get_moon(lat, lon)
+        self.assertIsInstance(phase, str)
+
+    def test_get_sun_times(self):
+        from space import get_sun
+        sun_times = get_sun(lat, lon)
+        self.assertIsInstance(sun_times, str)
+    
+    def test_hf_band_conditions(self):
+        from space import hf_band_conditions
+        conditions = hf_band_conditions()
+        self.assertIsInstance(conditions, str)
+
+    def test_get_wikipedia_summary(self):
+        from wiki import get_wikipedia_summary
+        summary = get_wikipedia_summary("Python", location=(lat, lon))
+        self.assertIsInstance(summary, str)
+
+    def test_get_kiwix_summary(self):
+        from wiki import get_kiwix_summary
+        summary = get_kiwix_summary("Python")
+        self.assertIsInstance(summary, str)
+
+    def get_openskynetwork(self):
+        from locationdata import get_openskynetwork
+        flights = get_openskynetwork(lat, lon)
+        self.assertIsInstance(flights, str)
+
+    def test_initalize_qrz_database(self):
+        from qrz import initalize_qrz_database
+        result = initalize_qrz_database()
+        self.assertTrue(result)
+
+    def test_get_hamlib(self):
+        from radio import get_hamlib
+        frequency = get_hamlib('f')
+        self.assertIsInstance(frequency, str)
+
+    def test_get_rss_feed(self):
+        from rss import get_rss_feed
+        result = get_rss_feed('')
+        self.assertIsInstance(result, str)
+
+    
+    ##### GAMES Tests #####
+    def test_jokes(self):
+        from modules.games.joke import tell_joke
+        haha = tell_joke(nodeID=0, test=True)
+        print("Joke response:", haha)
+        self.assertIsInstance(haha, str)
+    
+    def test_tictactoe_initial_and_move(self):
+        from games.tictactoe import tictactoe
+        user_id = "testuser"
+        # Start a new game (no move yet)
+        initial = tictactoe.play(user_id, "")
+        print("Initial response:", initial)
+        # Make a move, e.g., '1'
+        second = tictactoe.play(user_id, "1")
+        print("After move '1':", second)
+        self.assertIsInstance(initial, str)
+        self.assertIsInstance(second, str)
+    
+    def test_playVideoPoker(self):
+        from games.videopoker import playVideoPoker
+        user_id = "testuser"
+        # Start a new game/session
+        initial = playVideoPoker(user_id, 'deal')
+        print("Initial response:", initial)
+        # Place a 5-coin bet
+        after_bet = playVideoPoker(user_id, '5')
+        print("After placing 5-coin bet:", after_bet)
+        self.assertIsInstance(initial, str)
+        self.assertIsInstance(after_bet, str)
+
+    def test_play_blackjack(self):
+        from games.blackjack import playBlackJack
+        user_id = "testuser"
+        # Start a new game/session
+        initial = playBlackJack(user_id, 'deal')
+        print("Initial response:", initial)
+        # Place a 5-chip bet
+        after_bet = playBlackJack(user_id, '5')
+        print("After placing 5-chip bet:", after_bet)
+        self.assertIsInstance(initial, str)
+        self.assertIsInstance(after_bet, str)
+
+
+    def test_hangman_initial_and_guess(self):
+        from games.hangman import hangman
+        user_id = "testuser"
+        # Start a new game (no guess yet)
+        initial = hangman.play(user_id, "")
+        print("Initial response:", initial)
+        # Guess a letter, e.g., 'e'
+        second = hangman.play(user_id, "e")
+        print("After guessing 'e':", second)
+        self.assertIsInstance(initial, str)
+        self.assertIsInstance(second, str)
+
+   
+    def test_play_lemonade_stand(self):
+        from games.lemonade import playLemonstand, lemonadeTracker
+        user_id = "testuser"
+        # Ensure user is in tracker
+        if not any(u['nodeID'] == user_id for u in lemonadeTracker):
+            lemonadeTracker.append({'nodeID': user_id, 'cups': 0, 'lemons': 0, 'sugar': 0, 'cash': 30.0, 'start': 30.0, 'cmd': 'new', 'last_played': 0})
+        # Start a new game
+        initial = playLemonstand(user_id, "", newgame=True)
+        print("Initial response:", initial)
+        # Buy 1 box of cups
+        after_cups = playLemonstand(user_id, "1")
+        print("After buying 1 box of cups:", after_cups)
+        self.assertIsInstance(initial, str)
+        self.assertIsInstance(after_cups, str)
+
+    
+    def test_play_golfsim_one_hole(self):
+        from games.golfsim import playGolf
+        user_id = "testuser"
+        # Start a new game/hole
+        initial = playGolf(user_id, "", last_cmd="new")
+        print("Initial hole info:", initial)
+        # Take first shot with driver
+        after_shot = playGolf(user_id, "driver")
+        print("After hitting driver:", after_shot)
+        self.assertIsInstance(initial, str)
+        self.assertIsInstance(after_shot, str)
+
+    
+    def test_play_dopewar_choose_city_and_list(self):
+        from games.dopewar import playDopeWars
+        user_id = 1234567899  # Use a unique test user ID
+        # Start a new game, get city selection prompt
+        initial = playDopeWars(user_id, "")
+        print("Initial city selection:", initial)
+        # Choose city 1
+        after_city = playDopeWars(user_id, "1")
+        print("After choosing city 1 (main game list):", after_city)
+        self.assertIsInstance(initial, str)
+        self.assertIsInstance(after_city, str)
+
+    
+    def test_play_mastermind_one_guess(self):
+        from games.mmind import start_mMind
+        user_id = 1234567899  # Use a unique test user ID
+        # Start a new game (should prompt for difficulty/colors)
+        initial = start_mMind(user_id, "n")
+        print("Initial response (difficulty/colors):", initial)
+        # Make a guess (e.g., "RGBY" - valid for normal)
+        after_guess = start_mMind(user_id, "RGBY")
+        print("After guessing RGBY:", after_guess)
+        self.assertIsInstance(initial, str)
+        self.assertIsInstance(after_guess, str)
+
+
+    def test_quiz_game_answer_one_and_end(self):
+        from games.quiz import quizGamePlayer
+        quizmaster_id = "admin"  # Use a valid quizmaster ID from bbs_admin_list
+        user_id = "testuser"
+        # Start the quiz as quizmaster
+        start_msg = quizGamePlayer.start_game(quizmaster_id)
+        print("Quiz start:", start_msg)
+        # User joins the quiz
+        join_msg = quizGamePlayer.join(user_id)
+        print("User joined:", join_msg)
+        # Get the first question (should be included in join_msg, but call explicitly for clarity)
+        question_msg = quizGamePlayer.next_question(user_id)
+        print("First question:", question_msg)
+        # Simulate answering with 'A' (adjust if your first question expects a different answer)
+        answer_msg = quizGamePlayer.answer(user_id, "A")
+        print("Answer response:", answer_msg)
+        # End the quiz as quizmaster
+        end_msg = quizGamePlayer.stop_game(quizmaster_id)
+        print("Quiz end:", end_msg)
+        self.assertIsInstance(start_msg, str)
+        self.assertIsInstance(join_msg, str)
+        self.assertIsInstance(question_msg, str)
+        self.assertIsInstance(answer_msg, str)
+        self.assertIsInstance(end_msg, str)
+
+    def test_survey_answer_one_and_end(self):
+        from survey import survey_module
+        user_id = "testuser"
+        survey_name = "example"  # Make sure this survey exists in your data/surveys directory
+
+        # Start the survey
+        start_msg = survey_module.start_survey(user_id, survey_name)
+        print("Survey start:", start_msg)
+        # Answer the first question with 'A' (adjust if your survey expects a different type)
+        answer_msg = survey_module.answer(user_id, "A")
+        print("Answer response:", answer_msg)
+        # End the survey
+        end_msg = survey_module.end_survey(user_id)
+        print("Survey end:", end_msg)
+
+        self.assertIsInstance(start_msg, str)
+        self.assertIsInstance(answer_msg, str)
+        self.assertIsInstance(end_msg, str)
+
+
+    def test_hamtest_answer_one(self):
+        from games.hamtest import hamtest
+        user_id = "testuser"
+        # Start a new ham test game (default level: technician)
+        initial = hamtest.newGame(user_id)
+        print("Initial question:", initial)
+        # Answer the first question with 'A'
+        answer_msg = hamtest.answer(user_id, "A")
+        print("Answer response:", answer_msg)
+        self.assertIsInstance(initial, str)
+        self.assertIsInstance(answer_msg, str)
+
+
+    ##### API Tests - Extended tests run only if CHECKALL is True #####
+
+
+    if CHECKALL:
+        logger.info("Running extended API tests as CHECKALL is enabled.")
+    def test_handledxcluster(self):
+        from modules.dxspot import handledxcluster
+        test_message = "DX band=20m mode=SSB of=K7MHI"
+        response = handledxcluster(test_message, nodeID=0, deviceID='testdevice')
+        print("DX Spotter response:", response)
+        self.assertIsInstance(response, str)
+
+        def test_getRepeaterBook(self):
+            from locationdata import getRepeaterBook
+            repeaters = getRepeaterBook(lat, lon)
+            self.assertIsInstance(repeaters, str)
+
+        def test_getArtSciRepeaters(self):
+            from locationdata import getArtSciRepeaters
+            repeaters = getArtSciRepeaters(lat, lon)
+            self.assertIsInstance(repeaters, str)
+
+        def test_get_NOAAtides(self):
+            from locationdata import get_NOAAtide
+            tides = get_NOAAtide(lat, lon)
+            self.assertIsInstance(tides, str)
+
+        def test_get_NOAAweather(self):
+            from locationdata import get_NOAAweather
+            weather = get_NOAAweather(lat, lon)
+            self.assertIsInstance(weather, str)
+
+        def test_where_am_i(self):
+            from locationdata import where_am_i
+            location = where_am_i(lat, lon)
+            self.assertIsInstance(location, str)
+
+        def test_getWeatherAlertsNOAA(self):
+            from locationdata import getWeatherAlertsNOAA
+            alerts = getWeatherAlertsNOAA(lat, lon)
+            if isinstance(alerts, tuple):
+                self.assertIsInstance(alerts[0], str)
+            else:
+                self.assertIsInstance(alerts, str)
+        
+        def test_getActiveWeatherAlertsDetailNOAA(self):
+            from locationdata import getActiveWeatherAlertsDetailNOAA
+            alerts_detail = getActiveWeatherAlertsDetailNOAA(lat, lon)
+            self.assertIsInstance(alerts_detail, str)
+        
+        def test_getIpawsAlerts(self):
+            from locationdata import getIpawsAlert
+            alerts = getIpawsAlert(lat, lon)
+            self.assertIsInstance(alerts, str)
+        
+        def test_get_flood_noaa(self):
+            from locationdata import get_flood_noaa
+            flood_info = get_flood_noaa(lat, lon, 12484500)  # Example gauge UID
+            self.assertIsInstance(flood_info, str)
+        
+        def test_get_volcano_usgs(self):
+            from locationdata import get_volcano_usgs
+            volcano_info = get_volcano_usgs(lat, lon)
+            self.assertIsInstance(volcano_info, str)
+
+        def test_get_nws_marine_alerts(self):
+            from locationdata import get_nws_marine
+            marine_alerts = get_nws_marine('https://tgftp.nws.noaa.gov/data/forecasts/marine/coastal/pz/pzz135.txt',1) # Example zone
+            self.assertIsInstance(marine_alerts, str)
+
+        def test_checkUSGSEarthQuakes(self):
+            from locationdata import checkUSGSEarthQuake
+            earthquakes = checkUSGSEarthQuake(lat, lon)
+            self.assertIsInstance(earthquakes, str)
+
+        def test_getNextSatellitePass(self):
+            from space import getNextSatellitePass
+            pass_info = getNextSatellitePass('25544', lat, lon)
+            self.assertIsInstance(pass_info, str)  
+
+        def test_get_wx_meteo(self):
+            from wx_meteo import get_wx_meteo
+            weather_report = get_wx_meteo(lat, lon)
+            self.assertIsInstance(weather_report, str)
+
+        def test_get_flood_openmeteo(self):
+            from wx_meteo import get_flood_openmeteo
+            flood_report = get_flood_openmeteo(lat, lon)
+            self.assertIsInstance(flood_report, str)
+
+    def test_check_callsign_match(self):
+        # Test the callsign filtering function for WSJT-X/JS8Call
+        from radio import check_callsign_match
+        
+        # Test with empty filter (should match all)
+        self.assertTrue(check_callsign_match("CQ K7MHI CN87", []))
+        
+        # Test exact match
+        self.assertTrue(check_callsign_match("CQ K7MHI CN87", ["K7MHI"]))
+        
+        # Test case insensitive match
+        self.assertTrue(check_callsign_match("CQ k7mhi CN87", ["K7MHI"]))
+        self.assertTrue(check_callsign_match("CQ K7MHI CN87", ["k7mhi"]))
+        
+        # Test no match
+        self.assertFalse(check_callsign_match("CQ W1AW FN31", ["K7MHI"]))
+        
+        # Test multiple callsigns
+        self.assertTrue(check_callsign_match("CQ W1AW FN31", ["K7MHI", "W1AW"]))
+        self.assertTrue(check_callsign_match("K7MHI DE W1AW", ["K7MHI", "W1AW"]))
+        
+        # Test portable/mobile suffixes
+        self.assertTrue(check_callsign_match("CQ K7MHI/P CN87", ["K7MHI"]))
+        self.assertTrue(check_callsign_match("W1AW-7", ["W1AW"]))
+        
+        # Test no false positives with partial matches
+        self.assertFalse(check_callsign_match("CQ K7MHIX CN87", ["K7MHI"]))
+        self.assertFalse(check_callsign_match("K7 TEST", ["K7MHI"]))
+
+
+
+
+if __name__ == '__main__':
+    if not CHECKALL:
+        print("\nNote: Extended API tests are skipped. To enable them, create a file named '.checkall' in the parent directory.\n")
+    unittest.main()

modules/test_xtide.py

@@ -0,0 +1,135 @@
+#!/usr/bin/env python3
+"""
+Test script for xtide module
+Tests both NOAA (disabled) and tidepredict (when available) tide predictions
+"""
+import sys
+import os
+
+# Add parent directory to path
+sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))
+
+def test_xtide_import():
+    """Test that xtide module can be imported"""
+    print("Testing xtide module import...")
+    try:
+        from modules import xtide
+        print(f"✓ xtide module imported successfully")
+        print(f"  - tidepredict available: {xtide.TIDEPREDICT_AVAILABLE}")
+        return True
+    except Exception as e:
+        print(f"✗ Failed to import xtide: {e}")
+        return False
+
+def test_locationdata_import():
+    """Test that modified locationdata can be imported"""
+    print("\nTesting locationdata module import...")
+    try:
+        from modules import locationdata
+        print(f"✓ locationdata module imported successfully")
+        return True
+    except Exception as e:
+        print(f"✗ Failed to import locationdata: {e}")
+        return False
+
+def test_settings():
+    """Test that settings has useTidePredict option"""
+    print("\nTesting settings configuration...")
+    try:
+        from modules import settings as my_settings
+        has_setting = hasattr(my_settings, 'useTidePredict')
+        print(f"✓ settings module loaded")
+        print(f"  - useTidePredict setting available: {has_setting}")
+        if has_setting:
+            print(f"  - useTidePredict value: {my_settings.useTidePredict}")
+        return True
+    except Exception as e:
+        print(f"✗ Failed to load settings: {e}")
+        return False
+
+def test_noaa_fallback():
+    """Test NOAA API fallback (without enabling tidepredict)"""
+    print("\nTesting NOAA API (default mode)...")
+    try:
+        from modules import locationdata
+        from modules import settings as my_settings
+        
+        # Test with Seattle coordinates (should use NOAA)
+        lat = 47.6062
+        lon = -122.3321
+        
+        print(f"  Testing with Seattle coordinates: {lat}, {lon}")
+        print(f"  useTidePredict = {my_settings.useTidePredict}")
+        
+        # Note: This will fail if we can't reach NOAA, but that's expected
+        result = locationdata.get_NOAAtide(str(lat), str(lon))
+        if result and "Error" not in result:
+            print(f"✓ NOAA API returned data")
+            print(f"  First 100 chars: {result[:100]}")
+            return True
+        else:
+            print(f"⚠ NOAA API returned: {result[:100]}")
+            return True  # Still pass as network might not be available
+    except Exception as e:
+        print(f"⚠ NOAA test encountered expected issue: {e}")
+        return True  # Expected in test environment
+
+def test_parse_coords():
+    """Test coordinate parsing function"""
+    print("\nTesting coordinate parsing...")
+    try:
+        from modules.xtide import parse_station_coords
+        
+        test_cases = [
+            (("43-36S", "172-43E"), (-43.6, 172.71666666666667)),
+            (("02-45N", "072-21E"), (2.75, 72.35)),
+            (("02-45S", "072-21W"), (-2.75, -72.35)),
+        ]
+        
+        all_passed = True
+        for (lat_str, lon_str), (expected_lat, expected_lon) in test_cases:
+            result_lat, result_lon = parse_station_coords(lat_str, lon_str)
+            if abs(result_lat - expected_lat) < 0.01 and abs(result_lon - expected_lon) < 0.01:
+                print(f"  ✓ {lat_str}, {lon_str} -> {result_lat:.2f}, {result_lon:.2f}")
+            else:
+                print(f"  ✗ {lat_str}, {lon_str} -> expected {expected_lat}, {expected_lon}, got {result_lat}, {result_lon}")
+                all_passed = False
+        
+        return all_passed
+    except Exception as e:
+        print(f"✗ Coordinate parsing test failed: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+def main():
+    """Run all tests"""
+    print("=" * 60)
+    print("xtide Module Test Suite")
+    print("=" * 60)
+    
+    results = []
+    results.append(("Import xtide", test_xtide_import()))
+    results.append(("Import locationdata", test_locationdata_import()))
+    results.append(("Settings configuration", test_settings()))
+    results.append(("Parse coordinates", test_parse_coords()))
+    results.append(("NOAA fallback", test_noaa_fallback()))
+    
+    print("\n" + "=" * 60)
+    print("Test Results Summary")
+    print("=" * 60)
+    
+    passed = sum(1 for _, result in results if result)
+    total = len(results)
+    
+    for test_name, result in results:
+        status = "✓ PASS" if result else "✗ FAIL"
+        print(f"{status}: {test_name}")
+    
+    print(f"\n{passed}/{total} tests passed")
+    
+    return passed == total
+
+if __name__ == "__main__":
+    success = main()
+    sys.exit(0 if success else 1)

modules/wiki.py

@@ -1,122 +1,135 @@
 # meshbot wiki module
 
-from modules.log import *
-import wikipedia # pip install wikipedia
+from modules.log import logger
+from modules.settings import (use_kiwix_server, kiwix_url, kiwix_library_name,
+                              urlTimeoutSeconds, wiki_return_limit, ERROR_FETCHING_DATA, wikipedia_enabled)
+#import wikipedia # pip install wikipedia
+import requests
+import bs4 as bs
+from urllib.parse import quote
 
-# 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
+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, bs.element.Comment):
+        return False
+    return True
 
-# 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 main article text from HTML content"""
+    soup = bs.BeautifulSoup(body, 'html.parser')
+    # Try to find the main content div (works for both Kiwix and Wikipedia HTML)
+    main = soup.find('div', class_='mw-parser-output')
+    if not main:
+        # Fallback: just use the body if main content div not found
+        main = soup.body
+    if not main:
+        return ""
+    texts = main.find_all(string=True)
+    visible_texts = filter(tag_visible, texts)
+    return " ".join(t.strip() for t in visible_texts if t.strip())
 
-    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, truncate=True):
+    """Query local Kiwix server for Wikipedia article using only search results."""
+    if search_term is None or search_term.strip() == "":
+        return ERROR_FETCHING_DATA
+    try:
+        search_encoded = quote(search_term)
+        search_url = f"{kiwix_url}/search?content={kiwix_library_name}&pattern={search_encoded}"
+        response = requests.get(search_url, timeout=urlTimeoutSeconds)
 
-    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 += '.'
+        if response.status_code == 200 and "No results were found" not in response.text:
+            soup = bs.BeautifulSoup(response.text, 'html.parser')
+            results = soup.select('div.results ul li')
+            logger.debug(f"Kiwix: Found {len(results)} results in search results for:{search_term}")
+            for li in results[:3]:
+                a = li.find('a', href=True)
+                if not a:
+                    continue
+                article_url = f"{kiwix_url}{a['href']}"
+                article_response = requests.get(article_url, timeout=urlTimeoutSeconds)
+                if article_response.status_code == 200:
+                    text = text_from_html(article_response.text)
+                    # Remove navigation and search jump 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 += '.'
+                    if truncate:
                         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
+                    else:
+                        return summary.strip()
 
-def get_wikipedia_summary(search_term, location=None, force=False):
-    lat, lon = location if location else (None, None)
-    # Use Kiwix if configured
+        logger.debug(f"System: No Kiwix Results for:{search_term}")
+        if wikipedia_enabled:
+            logger.debug("Kiwix: Falling back to Wikipedia API.")
+            return get_wikipedia_summary(search_term, force=True)
+        return ERROR_FETCHING_DATA
+
+    except Exception as e:
+        logger.warning(f"System: Error with Kiwix for:{search_term} URL:{search_url} {e}")
+        return ERROR_FETCHING_DATA
+
+def get_wikipedia_summary(search_term, location=None, force=False, truncate=True):
     if use_kiwix_server and not force:
         return get_kiwix_summary(search_term)
-    
+
+    if not search_term or not search_term.strip():
+        return ERROR_FETCHING_DATA
+
+    api_url = f"https://en.wikipedia.org/api/rest_v1/page/summary/{requests.utils.quote(search_term)}"
+    headers = {
+        "User-Agent": "MeshBot/1.0 (https://github.com/kkeeton/meshing-around; contact: youremail@example.com)"
+    }
     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}")
+        response = requests.get(api_url, timeout=5, headers=headers)
+        if response.status_code == 404:
+            logger.warning(f"System: No Wikipedia Results for:{search_term}")
+            return ERROR_FETCHING_DATA
+        response.raise_for_status()
+        data = response.json()
+        logger.debug(f"Wikipedia API response for '{search_term}': {len(data)} keys")
+        if "extract" not in data or not data.get("extract"):
+            #logger.debug(f"System: Wikipedia API returned no extract for:{search_term} (data: {data})")
+            return ERROR_FETCHING_DATA
+        if data.get("type") == "disambiguation" or "may refer to:" in data.get("extract", ""):
+            #logger.warning(f"System: Disambiguation page for:{search_term} (data: {data})")
+            # Fetch and parse the HTML disambiguation page
+            html_url = f"https://en.wikipedia.org/wiki/{requests.utils.quote(search_term)}"
+            html_resp = requests.get(html_url, timeout=5, headers=headers)
+            if html_resp.status_code == 200:
+                soup = bs.BeautifulSoup(html_resp.text, 'html.parser')
+                items = soup.select('div.mw-parser-output ul li a[href^="/wiki/"]')
+                choices = []
+                for a in items:
+                    title = a.get('title')
+                    href = a.get('href')
+                    # Filter out non-article links
+                    if title and href and ':' not in href:
+                        choices.append(f"{title} (https://en.wikipedia.org{href})")
+                    if len(choices) >= 5:
+                        break
+                if choices:
+                    return f"'{search_term}' is ambiguous. Did you mean:\n- " + "\n- ".join(choices)
+            return f"'{search_term}' is ambiguous. Please be more specific. See: {html_url}"
+        summary = data.get("extract")
+        if not summary or not isinstance(summary, str) or not summary.strip():
+            #logger.debug(f"System: No summary found for:{search_term} (data: {data})")
+            return ERROR_FETCHING_DATA
+        sentences = [s for s in summary.split('. ') if s.strip()]
+        if not sentences:
+            return ERROR_FETCHING_DATA
+        summary = '. '.join(sentences[:wiki_return_limit])
+        if summary and not summary.endswith('.'):
+            summary += '.'
+        if truncate:
+            # Truncate to 500 characters
+            return summary.strip()[:500]
+        else:
+            return summary.strip()
     except Exception as e:
-        logger.debug(f"System: Wikipedia search error for:{search_term} {e}")
+        logger.warning(f"System: Wikipedia API 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

@@ -3,7 +3,8 @@
 
 import requests
 import json
-from modules.log import *
+from modules.log import logger
+from modules.settings import ERROR_FETCHING_DATA
 
 def get_weather_data(api_url, params):
     response = requests.get(api_url, params=params)

modules/xtide.md

@@ -0,0 +1,129 @@
+# xtide Module - Global Tide Predictions
+
+This module provides global tide prediction capabilities using the [tidepredict](https://github.com/windcrusader/tidepredict) library, which uses the University of Hawaii's Research Quality Dataset for worldwide tide station coverage.
+
+## Features
+
+- Global tide predictions (not limited to US locations like NOAA)
+- Offline predictions once station data is initialized
+- Automatic selection of nearest tide station
+- Compatible with existing tide command interface
+
+## Installation
+
+1. Install tidepredict library:
+this takes about 3-500MB of disk
+
+```bash
+pip install tidepredict
+```
+note: if you see warning about system packages the override for debian OS to install it anyway is..
+
+```bash
+pip install tidepredict --break-system-packages
+```
+
+2. Enable in `config.ini`:
+```ini
+[location]
+useTidePredict = True
+```
+
+## First-Time Setup
+
+On first use, tidepredict needs to download station data from the University of Hawaii FTP server. This requires internet access and happens automatically when you:
+
+1. Run the tide command for the first time with `useTidePredict = True`
+2. Or manually initialize with:
+```bash
+python3 -m tidepredict -l <location> -genharm
+```
+
+The station data is cached locally in `~/.tidepredict/` for offline use afterward.
+
+No other downloads will happen automatically, its offline
+
+## Usage
+
+Once enabled, the existing `tide` command will automatically use tidepredict for global locations:
+
+```
+tide
+```
+
+The module will:
+1. Find the nearest tide station to your GPS coordinates
+2. Load harmonic constituents for that station
+3. Calculate tide predictions for today
+4. Format output compatible with mesh display
+
+## Configuration
+
+### config.ini Options
+
+```ini
+[location]
+# Enable global tide predictions using tidepredict
+useTidePredict = True
+
+# Standard location settings still apply
+lat = 48.50
+lon = -123.0
+useMetric = False
+```
+
+## Fallback Behavior
+
+If tidepredict is not available or encounters errors, the module will automatically fall back to the NOAA API for US locations.
+
+## Limitations
+
+- First-time setup requires internet access to download station database
+- Station coverage depends on University of Hawaii's dataset
+- Predictions may be less accurate for locations far from tide stations
+
+## Troubleshooting
+
+### "Station database not initialized" error
+
+This means the station data hasn't been downloaded yet. Ensure internet access and:
+
+```bash
+# Test station download
+python3 -m tidepredict -l Sydney
+
+# Or manually run initialization
+python3 -c "from tidepredict import process_station_list; process_station_list.create_station_dataframe()"
+```
+
+### "No tide station found nearby"
+
+The module couldn't find a nearby station. This may happen if:
+- You're in a location without nearby tide monitoring stations
+- The station database hasn't been initialized
+- Network issues prevented loading the station list
+
+Tide Station Map 
+[https://uhslc.soest.hawaii.edu/network/](https://uhslc.soest.hawaii.edu/network/)
+- click on Tide Guages
+- Find yourself on the map
+- Locate the closest Gauge and its name (typically the city name)
+
+To manually download data for the station first location the needed station id
+- `python -m tidepredict -l "Port Angeles"` finds a station
+- `python -m tidepredict -l "Port Angeles" -genharm` downloads that datafile
+
+
+
+## Data Source
+
+Tide predictions are based on harmonic analysis of historical tide data from:
+- University of Hawaii Sea Level Center (UHSLC)
+- Research Quality Dataset
+- Global coverage with 600+ stations
+
+## References
+
+- [tidepredict GitHub](https://github.com/windcrusader/tidepredict)
+- [UHSLC Data](https://uhslc.soest.hawaii.edu/)
+- [pytides](https://github.com/sam-cox/pytides) - Underlying tide calculation library

modules/xtide.py

@@ -0,0 +1,202 @@
+# xtide.py - Global tide prediction using tidepredict library
+# K7MHI Kelly Keeton 2025
+
+import json
+from datetime import datetime, timedelta
+from modules.log import logger
+import modules.settings as my_settings
+
+try:
+    from tidepredict import processdata, process_station_list, constants, timefunc
+    from tidepredict.tide import Tide
+    import pandas as pd
+    TIDEPREDICT_AVAILABLE = True
+except ImportError:
+    TIDEPREDICT_AVAILABLE = False
+    logger.error("xtide: tidepredict module not installed. Install with: pip install tidepredict")
+
+def get_nearest_station(lat, lon):
+    """
+    Find the nearest tide station to the given lat/lon coordinates.
+    Returns station code (e.g., 'h001a') or None if not found.
+    """
+    if not TIDEPREDICT_AVAILABLE:
+        return None
+    
+    try:
+        # Read the station list
+        try:
+            stations = pd.read_csv(constants.STATIONFILE)
+        except FileNotFoundError:
+            # If station file doesn't exist, create it (requires network)
+            logger.info("xtide: Creating station database from online source (requires network)")
+            try:
+                stations = process_station_list.create_station_dataframe()
+            except Exception as net_error:
+                logger.error(f"xtide: Failed to download station database: {net_error}")
+                return None
+        
+        if stations.empty:
+            logger.error("xtide: No stations found in database")
+            return None
+        
+        # Calculate distance to each station
+        # Using simple haversine-like calculation
+        def calc_distance(row):
+            try:
+                # Parse lat/lon from the format like "43-36S", "172-43E"
+                station_lat, station_lon = parse_station_coords(row['Lat'], row['Lon'])
+                
+                # Simple distance calculation (not precise but good enough)
+                dlat = lat - station_lat
+                dlon = lon - station_lon
+                return (dlat**2 + dlon**2)**0.5
+            except:
+                return float('inf')
+        
+        stations['distance'] = stations.apply(calc_distance, axis=1)
+        
+        # Find the nearest station
+        nearest = stations.loc[stations['distance'].idxmin()]
+        
+        if nearest['distance'] > 10:  # More than ~10 degrees away, might be too far
+            logger.warning(f"xtide: Nearest station is {nearest['distance']:.1f}° away at {nearest['loc_name']}")
+        
+        station_code = "h" + nearest['stat_idx'].lower()
+        logger.debug(f"xtide: Found nearest station: {nearest['loc_name']} ({station_code}) at {nearest['distance']:.2f}° away")
+        
+        return station_code, nearest['loc_name'], nearest['country']
+    
+    except Exception as e:
+        logger.error(f"xtide: Error finding nearest station: {e}")
+        return None
+
+def parse_station_coords(lat_str, lon_str):
+    """
+    Parse station coordinates from format like "43-36S", "172-43E"
+    Returns tuple of (latitude, longitude) as floats
+    """
+    try:
+        # Parse latitude
+        lat_parts = lat_str.split('-')
+        lat_deg = float(lat_parts[0])
+        lat_min = float(lat_parts[1][:-1])  # Remove N/S
+        lat_dir = lat_parts[1][-1]  # Get N/S
+        lat_val = lat_deg + lat_min/60.0
+        if lat_dir == 'S':
+            lat_val = -lat_val
+        
+        # Parse longitude
+        lon_parts = lon_str.split('-')
+        lon_deg = float(lon_parts[0])
+        lon_min = float(lon_parts[1][:-1])  # Remove E/W
+        lon_dir = lon_parts[1][-1]  # Get E/W
+        lon_val = lon_deg + lon_min/60.0
+        if lon_dir == 'W':
+            lon_val = -lon_val
+        
+        return lat_val, lon_val
+    except Exception as e:
+        logger.debug(f"xtide: Error parsing coordinates {lat_str}, {lon_str}: {e}")
+        return 0.0, 0.0
+
+def get_tide_predictions(lat=0, lon=0, days=1):
+    """
+    Get tide predictions for the given location using tidepredict library.
+    Returns formatted string with tide predictions.
+    
+    Parameters:
+    - lat: Latitude
+    - lon: Longitude  
+    - days: Number of days to predict (default: 1)
+    
+    Returns:
+    - Formatted string with tide predictions or error message
+    """
+    if not TIDEPREDICT_AVAILABLE:
+        return "module not installed, see logs for more ⚓️"
+    
+    if float(lat) == 0 and float(lon) == 0:
+        return "No GPS data for tide prediction"
+    
+    try:
+        # Find nearest station
+        station_info = get_nearest_station(float(lat), float(lon))
+        if not station_info:
+            return "No tide station found nearby. Network may be required to download station data."
+        
+        station_code, station_name, station_country = station_info
+        
+        # Load station data
+        station_dict, harmfileloc = process_station_list.read_station_info_file()
+        
+        # Check if harmonic data exists for this station
+        if station_code not in station_dict:
+            logger.warning(f"xtide: No harmonic data.     python -m tidepredict -l \"{station_name}\" -genharm")
+            return f"Tide data not available for {station_name}. Station database may need initialization."
+        
+        # Reconstruct tide model
+        tide = processdata.reconstruct_tide_model(station_dict, station_code)
+        if tide is None:
+            return f"Tide model unavailable for {station_name}"
+        
+        # Set up time range (today only)
+        now = datetime.now()
+        start_time = now.strftime("%Y-%m-%d 00:00")
+        end_time = (now + timedelta(days=days)).strftime("%Y-%m-%d 00:00")
+        
+        # Create time object
+        timeobj = timefunc.Tidetime(
+            st_time=start_time,
+            en_time=end_time,
+            station_tz=station_dict[station_code].get('tzone', 'UTC')
+        )
+        
+        # Get predictions
+        predictions = processdata.predict_plain(tide, station_dict[station_code], 't', timeobj)
+        
+        # Format output for mesh
+        lines = predictions.strip().split('\n')
+        if len(lines) > 2:
+            # Skip the header lines and format for mesh display
+            result = f"Tide: {station_name}\n"
+            tide_lines = lines[2:]  # Skip first 2 header lines
+            
+            # Format each tide prediction
+            for line in tide_lines[:8]:  # Limit to 8 entries
+                parts = line.split()
+                if len(parts) >= 4:
+                    date_str = parts[0]
+                    time_str = parts[1]
+                    height = parts[3]
+                    tide_type = ' '.join(parts[4:])
+                    
+                    # Convert to 12-hour format if not using zulu time
+                    if not my_settings.zuluTime:
+                        try:
+                            time_obj = datetime.strptime(time_str, "%H%M")
+                            hour = time_obj.hour
+                            minute = time_obj.minute
+                            if hour >= 12:
+                                time_str = f"{hour-12 if hour > 12 else 12}:{minute:02d} PM"
+                            else:
+                                time_str = f"{hour if hour > 0 else 12}:{minute:02d} AM"
+                        except:
+                            pass
+                    
+                    result += f"{tide_type} {time_str}, {height}\n"
+            
+            return result.strip()
+        else:
+            return predictions
+    
+    except FileNotFoundError as e:
+        logger.error(f"xtide: Station data file not found: {e}")
+        return "Tide station database not initialized. Network access required for first-time setup."
+    except Exception as e:
+        logger.error(f"xtide: Error getting tide predictions: {e}")
+        return f"Error getting tide data: {str(e)}"
+
+def is_enabled():
+    """Check if xtide/tidepredict is enabled in config"""
+    return getattr(my_settings, 'useTidePredict', False) and TIDEPREDICT_AVAILABLE

pong_bot.py

@@ -10,8 +10,10 @@ except ImportError:
 
 import asyncio
 import time # for sleep, get some when you can :)
+from datetime import datetime
 import random
-from modules.log import *
+from modules.log import logger, CustomFormatter, msgLogger
+import modules.settings as my_settings
 from modules.system import *
 
 # Global Variables
@@ -50,9 +52,6 @@ def auto_response(message, snr, rssi, hop, pkiStatus, message_from_id, channel_n
         logger.debug(f"System: Bot detected Commands:{cmds}")
         # run the first command after sorting
         bot_response = command_handler[cmds[0]['cmd']]()
-
-    # wait a responseDelay to avoid message collision from lora-ack
-    time.sleep(responseDelay)
     
     return bot_response
 
@@ -72,30 +71,41 @@ def handle_ping(message_from_id, deviceID,  message, hop, snr, rssi, isDM, chann
     type = ''
 
     if "ping" in message.lower():
-        msg = "🏓PONG\n"
+        msg = "🏓PONG"
         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",])
+        msg = random.choice(["🎙Testing 1,2,3", "🎙Testing",\
+                             "🎙Testing, testing",\
+                             "🎙Ah-wun, ah-two...", "🎙Is this thing on?",\
+                             "🎙Roger that!",])
         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)
+            myname = get_name_from_number(deviceID, 'short', 1)
         elif deviceID == 2:
-            myname = get_name_from_number(myNodeNum2, 'short', 2)
+            myname = get_name_from_number(deviceID, '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}"
+    # append SNR/RSSI or hop info
+    if hop.startswith("Gateway") or hop.startswith("MQTT"):
+        msg += " [GW]"
+    elif hop.startswith("Direct"):
+        msg += " [RF]"
     else:
-        msg = msg + hop
+        #flood
+        msg += " [F]"
+    
+    if (float(snr) != 0 or float(rssi) != 0) and "Hops" not in hop:
+        msg += f"\nSNR:{snr} RSSI:{rssi}"
+    elif "Hops" in hop:
+        msg += f"\n{hop}🐇 "
+    else:
+        msg += "\nflood route"
 
     if "@" in message:
         msg = msg + " @" + message.split("@")[1]
@@ -125,13 +135,13 @@ def handle_ping(message_from_id, deviceID,  message, hop, snr, rssi, isDM, chann
                 pingCount = int(message.split(" ")[1])
                 if pingCount == 123 or pingCount == 1234:
                     pingCount =  1
-                elif not autoPingInChannel and not isDM:
+                elif not my_settings.autoPingInChannel and not isDM:
                     # no autoping in channels
                     pingCount = 1
 
                 if pingCount > 51:
                     pingCount = 50
-            except:
+            except ValueError:
                 pingCount = -1
     
         if pingCount > 1:
@@ -142,7 +152,7 @@ def handle_ping(message_from_id, deviceID,  message, hop, snr, rssi, isDM, chann
                 msg = f"🚦Initalizing {pingCount} auto-ping"
 
     # if not a DM add the username to the beginning of msg
-    if not useDMForResponse and not isDM:
+    if not my_settings.useDMForResponse and not isDM:
         msg = "@" + get_name_from_number(message_from_id, 'short', deviceID) + " " + msg
             
     return msg
@@ -150,10 +160,10 @@ def handle_ping(message_from_id, deviceID,  message, hop, snr, rssi, isDM, chann
 def handle_motd(message, message_from_id, isDM):
     global MOTD
     isAdmin = False
-    msg = ""
+    msg = MOTD
     # check if the message_from_id is in the bbs_admin_list
-    if bbs_admin_list != ['']:
-        for admin in bbs_admin_list:
+    if my_settings.bbs_admin_list != ['']:
+        for admin in my_settings.bbs_admin_list:
             if str(message_from_id) == admin:
                 isAdmin = True
                 break
@@ -182,7 +192,7 @@ def handle_echo(message, message_from_id, deviceID, isDM, channel_number):
         parts = message.lower().split("echo ", 1)
         if len(parts) > 1 and parts[1].strip() != "":
             echo_msg = parts[1]
-            if channel_number != echoChannel:
+            if channel_number != my_settings.echoChannel:
                 echo_msg = "@" + get_name_from_number(message_from_id, 'short', deviceID) + " " + echo_msg
             return echo_msg
         else:
@@ -216,58 +226,79 @@ def onReceive(packet, interface):
     rxType = type(interface).__name__
 
     # Valies assinged to the packet
-    rxNode, message_from_id, snr, rssi, hop, hop_away, channel_number = 0, 0, 0, 0, 0, 0, 0
+    rxNode = message_from_id = snr = rssi = hop = hop_away = channel_number = hop_start = hop_count = hop_limit = 0
     pkiStatus = (False, 'ABC')
     replyIDset = False
+    rxNodeHostName = None
     emojiSeen = False
+    simulator_flag = False
     isDM = False
+    channel_name = "unknown"
+    session_passkey = None
+    playingGame = False
 
     if DEBUGpacket:
         # Debug print the interface object
-        for item in interface.__dict__.items(): intDebug = f"{item}\n"
+        for item in interface.__dict__.items():
+            intDebug = f"{item}\n"
         logger.debug(f"System: Packet Received on {rxType} Interface\n {intDebug} \n END of interface \n")
         # 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 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
-    
+    # determine the rxNode based on the interface type
     if rxType == 'TCPInterface':
         rxHost = interface.__dict__.get('hostname', 'unknown')
-        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
+        rxNodeHostName = interface.__dict__.get('ip', None)
+        rxNode = next(
+            (i for i in range(1, 10)
+             if multiple_interface and rxHost and
+             globals().get(f'hostname{i}', '').split(':', 1)[0] in rxHost and
+             globals().get(f'interface{i}_type', '') == 'tcp'),None)
 
-    if rxType == 'BLEInterface':
-        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
+    if rxType == 'SerialInterface':
+        rxInterface = interface.__dict__.get('devPath', 'unknown')
+        rxNode = next(
+            (i for i in range(1, 10)
+             if globals().get(f'port{i}', '') in rxInterface),None)
     
-    # check if the packet has a channel flag use it
+    if rxType == 'BLEInterface':
+        rxNode = next(
+            (i for i in range(1, 10)
+             if globals().get(f'interface{i}_type', '') == 'ble'),0)
+        
+    if rxNode is None:
+        # default to interface 1 ## FIXME needs better like a default interface setting or hash lookup
+        if 'decoded' in packet and packet['decoded']['portnum'] in ['ADMIN_APP', 'SIMULATOR_APP']:
+            session_passkey = packet.get('decoded', {}).get('admin', {}).get('sessionPasskey', None)
+        rxNode = 1
+    
+    # check if the packet has a channel flag use it ## FIXME needs to be channel hash lookup
     if packet.get('channel'):
-        channel_number = packet.get('channel', 0)
+        channel_number = packet.get('channel')
+        # get channel name from channel number from connected devices
+        for device in channel_list:
+            if device["interface_id"] == rxNode:
+                device_channels = device['channels']
+                for chan_name, info in device_channels.items():
+                    if info['number'] == channel_number:
+                        channel_name = chan_name
+                        break
+
+    # 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 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']
@@ -282,10 +313,11 @@ def onReceive(packet, interface):
             message_bytes = packet['decoded']['payload']
             message_string = message_bytes.decode('utf-8')
             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")
+            if message_from_id in [myNodeNum1, myNodeNum2, myNodeNum3, myNodeNum4, myNodeNum5, myNodeNum6, myNodeNum7, myNodeNum8, myNodeNum9]:
+                logger.warning(f"System: Packet from self {message_from_id} loop or traffic replay detected")
 
             # get the signal strength and snr if available
             if packet.get('rxSnr') or packet.get('rxRssi'):
@@ -294,53 +326,69 @@ def onReceive(packet, interface):
 
             # check if the packet has a publicKey flag use it
             if packet.get('publicKey'):
-                pkiStatus = (packet.get('pkiEncrypted', False), packet.get('publicKey', 'ABC'))
+                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)
 
             # check if the packet has a hop count flag use it
             if packet.get('hopsAway'):
                 hop_away = packet.get('hopsAway', 0)
-            else:
-                # if the packet does not have a hop count try other methods
-                if packet.get('hopLimit'):
-                    hop_limit = packet.get('hopLimit', 0)
-                else:
-                    hop_limit = 0
-                
-                if packet.get('hopStart'):
-                    hop_start = packet.get('hopStart', 0)
-                else:
-                    hop_start = 0
 
-            if enableHopLogs:
-                logger.debug(f"System: Packet HopDebugger: hop_away:{hop_away} hop_limit:{hop_limit} hop_start:{hop_start}")
+            if packet.get('hopStart'):
+                hop_start = packet.get('hopStart', 0)
+
+            if packet.get('hopLimit'):
+                hop_limit = packet.get('hopLimit', 0)
             
-            if hop_away == 0 and hop_limit == 0 and hop_start == 0:
-                hop = "Last Hop"
-                hop_count = 0
-            
-            if hop_start == hop_limit:
+            # 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 == "" and hop_count > 0:
+                # set hop string from calculated hop count
+                hop = f"{hop_count} Hop" if hop_count == 1 else f"{hop_count} Hops"
+
+            if hop_start == hop_limit and "lora" in str(transport_mechanism).lower() and (snr != 0 or rssi != 0):
+                # 2.7+ firmware direct hop over LoRa
                 hop = "Direct"
-                hop_count = 0
-            elif hop_start == 0 and hop_limit > 0 or via_mqtt:
-                hop = "MQTT"
-                hop_count = 0
-            else:
-                # set hop to Direct if the message was sent directly otherwise set the hop count
-                if hop_away > 0:
-                    hop_count = hop_away
-                else:
-                    hop_count = hop_start - hop_limit
-                    #print (f"calculated hop count: {hop_start} - {hop_limit} = {hop_count}")
 
-                hop = f"{hop_count} hops"
+            if ((hop_start == 0 and hop_limit >= 0) or via_mqtt or ("mqtt" in str(transport_mechanism).lower())):
+                hop = "MQTT"
+            elif hop == "" and hop_count == 0 and (snr != 0 or rssi != 0):
+                # this came from a UDP but we had signal info so gateway is used
+                hop = "Gateway"
+            elif "unknown" in str(transport_mechanism).lower() and (snr == 0 and rssi == 0):
+                # we for sure detected this sourced from a UDP like host
+                hop = "Gateway"
             
+            if hop in ("MQTT", "Gateway") and hop_count > 0:
+                hop = f"{hop_count} Hops"
+
+            if my_settings.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} Hostname:{rxNodeHostName}")
+
+            # 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:
+            if packet['to'] in [myNodeNum1, myNodeNum2, myNodeNum3, myNodeNum4, myNodeNum5, myNodeNum6, myNodeNum7, myNodeNum8, myNodeNum9]:
                 # message is DM to us
                 isDM = True
                 # check if the message contains a trap word, DMs are always responded to
@@ -371,7 +419,7 @@ def onReceive(packet, interface):
                             send_message(auto_response(message_string, snr, rssi, hop, pkiStatus, message_from_id, channel_number, rxNode, isDM), channel_number, message_from_id, rxNode)
                         else:
                             # or respond to channel message on the channel itself
-                            if channel_number == publicChannel and antiSpam:
+                            if channel_number == my_settings.publicChannel and my_settings.antiSpam:
                                 # warning user spamming default channel
                                 logger.warning(f"System: AntiSpam protection, sending DM to: {get_name_from_number(message_from_id, 'long', rxNode)}")
                             
@@ -384,7 +432,7 @@ def onReceive(packet, interface):
                 else:
                     # message is not for bot to respond to
                     # ignore the message but add it to the message history list
-                    if zuluTime:
+                    if my_settings.zuluTime:
                         timestamp = datetime.now().strftime("%Y-%m-%d %H:%M:%S")
                     else:
                         timestamp = datetime.now().strftime("%Y-%m-%d %I:%M:%S%p")
@@ -402,17 +450,17 @@ 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 multiple_interface:         
+                    if my_settings.repeater_enabled and multiple_interface:
                         # wait a responseDelay to avoid message collision from lora-ack.
-                        time.sleep(responseDelay)
+                        time.sleep(my_settings.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 str(channel_number) in my_settings.repeater_channels:
                             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)
+                                    time.sleep(my_settings.responseDelay)
         else:
             # Evaluate non TEXT_MESSAGE_APP packets
             consumeMetadata(packet, rxNode, channel_number)
@@ -421,66 +469,185 @@ def onReceive(packet, interface):
         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')
-    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(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 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()
-
+    logger.debug("System: RX Subscriber started")
     # here we go loopty loo
     while True:
         await asyncio.sleep(0.5)
         pass
 
+def handle_boot(mesh=True):
+    try:
+        print (CustomFormatter.bold_white + f"\nMeshtastic Autoresponder Bot CTL+C to exit\n" + CustomFormatter.reset)
+        if mesh:
+            
+            for i in range(1, 10):
+                if globals().get(f'interface{i}_enabled', False):
+                    myNodeNum = globals().get(f'myNodeNum{i}', 0)
+                    logger.info(f"System: Autoresponder Started for Device{i} {get_name_from_number(myNodeNum, 'long', i)},"
+                                f"{get_name_from_number(myNodeNum, 'short', i)}. NodeID: {myNodeNum}, {decimal_to_hex(myNodeNum)}")
+                    
+            if llm_enabled:
+                logger.debug(f"System: Ollama LLM Enabled, loading model {my_settings.llmModel} please wait")
+                llmLoad = llm_query(" ")
+                if "trouble" not in llmLoad:
+                    logger.debug(f"System: LLM Model {my_settings.llmModel} loaded")
+
+            if my_settings.bbs_enabled:
+                logger.debug(f"System: BBS Enabled, {bbsdb} has {len(bbs_messages)} messages. Direct Mail Messages waiting: {(len(bbs_dm) - 1)}")
+                if my_settings.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 my_settings.solar_conditions_enabled:
+                logger.debug("System: Celestial Telemetry Enabled")
+            
+            if my_settings.location_enabled:
+                if my_settings.use_meteo_wxApi:
+                    logger.debug("System: Location Telemetry Enabled using Open-Meteo API")
+                else:
+                    logger.debug("System: Location Telemetry Enabled using NOAA API")
+            print("debug my_settings.scheduler_enabled:", my_settings.scheduler_enabled)
+            if my_settings.dad_jokes_enabled:
+                logger.debug("System: Dad Jokes Enabled!")
+            
+            if my_settings.coastalEnabled:
+                logger.debug("System: Coastal Forecast and Tide Enabled!")
+            
+            if games_enabled:
+                logger.debug("System: Games Enabled!")
+            
+            if my_settings.wikipedia_enabled:
+                if my_settings.use_kiwix_server:
+                    logger.debug(f"System: Wikipedia search Enabled using Kiwix server at {kiwix_url}")
+                else:
+                    logger.debug("System: Wikipedia search Enabled")
+            
+            if my_settings.rssEnable:
+                logger.debug(f"System: RSS Feed Reader Enabled for feeds: {rssFeedNames}")
+            
+            if my_settings.radio_detection_enabled:
+                logger.debug(f"System: Radio Detection Enabled using rigctld at {my_settings.rigControlServerAddress} broadcasting to channels: {my_settings.sigWatchBroadcastCh} for {get_freq_common_name(get_hamlib('f'))}")
+            
+            if my_settings.file_monitor_enabled:
+                logger.warning(f"System: File Monitor Enabled for {my_settings.file_monitor_file_path}, broadcasting to channels: {my_settings.file_monitor_broadcastCh}")
+            if my_settings.enable_runShellCmd:
+                logger.debug("System: Shell Command monitor enabled")
+                if my_settings.allowXcmd:
+                    logger.warning("System: File Monitor shell XCMD Enabled")
+            if my_settings.read_news_enabled:
+                logger.debug(f"System: File Monitor News Reader Enabled for {my_settings.news_file_path}")
+            if my_settings.bee_enabled:
+                logger.debug("System: File Monitor Bee Monitor Enabled for bee.txt")
+            
+            if my_settings.wxAlertBroadcastEnabled:
+                logger.debug(f"System: Weather Alert Broadcast Enabled on channels {my_settings.wxAlertBroadcastChannel}")
+            
+            if my_settings.emergencyAlertBrodcastEnabled:
+                logger.debug(f"System: Emergency Alert Broadcast Enabled on channels {my_settings.emergencyAlertBroadcastCh} for FIPS codes {my_settings.myStateFIPSList}")
+                if my_settings.myStateFIPSList == ['']:
+                    logger.warning("System: No FIPS codes set for iPAWS Alerts")
+            
+            if my_settings.emergency_responder_enabled:
+                logger.debug(f"System: Emergency Responder Enabled on channels {my_settings.emergency_responder_alert_channel} for interface {my_settings.emergency_responder_alert_interface}")
+            
+            if my_settings.volcanoAlertBroadcastEnabled:
+                logger.debug(f"System: Volcano Alert Broadcast Enabled on channels {my_settings.volcanoAlertBroadcastChannel}")
+            
+            if my_settings.qrz_hello_enabled:
+                if my_settings.train_qrz:
+                    logger.debug("System: QRZ Welcome/Hello Enabled with training mode")
+                else:
+                    logger.debug("System: QRZ Welcome/Hello Enabled")
+
+            if my_settings.enableSMTP:
+                if my_settings.enableImap:
+                    logger.debug("System: SMTP Email Alerting Enabled using IMAP")
+                else:
+                    logger.warning("System: SMTP Email Alerting Enabled")
+
+        # Default Options
+        if my_settings.useDMForResponse:
+            logger.debug("System: Respond by DM only")
+
+        if my_settings.log_messages_to_file:
+            logger.debug("System: Logging Messages to disk")
+        if my_settings.syslog_to_file:
+            logger.debug("System: Logging System Logs to disk")
+
+        if my_settings.motd_enabled:
+            logger.debug(f"System: MOTD Enabled using {my_settings.MOTD} scheduler:{my_settings.schedulerMotd}")
+        
+        if my_settings.sentry_enabled:
+            logger.debug(f"System: Sentry Mode Enabled {my_settings.sentry_radius}m radius reporting to channel:{my_settings.secure_channel} requestLOC:{reqLocationEnabled}")
+            if my_settings.sentryIgnoreList:
+                logger.debug(f"System: Sentry BlockList Enabled for nodes: {my_settings.sentryIgnoreList}")
+            if my_settings.sentryWatchList:
+                logger.debug(f"System: Sentry WatchList Enabled for nodes: {my_settings.sentryWatchList}")
+
+        if my_settings.highfly_enabled:
+            logger.debug(f"System: HighFly Enabled using {my_settings.highfly_altitude}m limit reporting to channel:{my_settings.highfly_channel}")
+        
+        if my_settings.store_forward_enabled:
+            logger.debug(f"System: S&F(messages command) Enabled using limit: {storeFlimit} and reverse queue:{my_settings.reverseSF}")
+        
+        if my_settings.enableEcho:
+            logger.debug("System: Echo command Enabled")
+        
+        if my_settings.repeater_enabled and multiple_interface:
+            logger.debug(f"System: Repeater Enabled for Channels: {my_settings.repeater_channels}")
+        
+        if my_settings.checklist_enabled:
+            logger.debug("System: CheckList Module Enabled")
+        
+        if my_settings.ignoreChannels:
+            logger.debug(f"System: Ignoring Channels: {my_settings.ignoreChannels}")
+        
+        if my_settings.noisyNodeLogging:
+            logger.debug("System: Noisy Node Logging Enabled")
+        
+        if my_settings.logMetaStats:
+            logger.debug("System: Logging Metadata Stats Enabled, leaderboard")
+        
+        if my_settings.scheduler_enabled:
+            logger.debug("System: Scheduler Enabled")
+
+
+
+    except Exception as e:
+        logger.error(f"System: Error during boot: {e}")
+
+
 # Hello World 
 async def main():
     tasks = []
     
     try:
+        handle_boot(mesh=False) # pong bot
         # Create core tasks
-        tasks.append(asyncio.create_task(start_rx(), name="pong_rx"))
+        tasks.append(asyncio.create_task(start_rx(), name="mesh_rx"))
         tasks.append(asyncio.create_task(watchdog(), name="watchdog"))
         
         # Add optional tasks
-        if file_monitor_enabled:
+        if my_settings.file_monitor_enabled:
             tasks.append(asyncio.create_task(handleFileWatcher(), name="file_monitor"))
         
+        if my_settings.radio_detection_enabled:
+            tasks.append(asyncio.create_task(handleSignalWatcher(), name="hamlib"))
+
+        if my_settings.voxDetectionEnabled:
+            tasks.append(asyncio.create_task(voxMonitor(), name="vox_detection"))
+
+        if my_settings.scheduler_enabled:
+            from modules.scheduler import run_scheduler_loop, setup_scheduler
+            setup_scheduler(schedulerMotd, MOTD, schedulerMessage, schedulerChannel, schedulerInterface,
+    schedulerValue, schedulerTime, schedulerInterval)
+            tasks.append(asyncio.create_task(run_scheduler_loop(), name="scheduler"))
+        
         logger.debug(f"System: Starting {len(tasks)} async tasks")
         
         # Wait for all tasks with proper exception handling

requirements.txt

@@ -7,6 +7,4 @@ maidenhead
 beautifulsoup4
 dadjokes
 geopy
-schedule
-wikipedia
-googlesearch-python
+schedule

script/README.md

@@ -0,0 +1,60 @@
+## script/runShell.sh
+
+**Purpose:**  
+`runShell.sh` is a simple demo shell script for the Mesh Bot project. It demonstrates how to execute shell commands within the project’s scripting environment.
+
+**Usage:**  
+Run this script from the terminal to see a basic example of shell scripting in the project context.
+
+```sh
+bash script/runShell.sh
+```
+
+**What it does:**  
+- Changes the working directory to the script’s location.
+- Prints the current directory path and a message indicating the script is running.
+- Serves as a template for creating additional shell scripts or automating tasks related to the project.
+
+**Note:**  
+You can modify this script to add more shell commands or automation steps as needed for your workflow.
+
+## script/runShell.sh
+
+**Purpose:**  
+`runShell.sh` is a demonstration shell script for the Mesh Bot project, showing how to execute shell commands in the project environment.
+
+**Usage:**  
+Run this script from the terminal to see a basic shell scripting example:
+
+```sh
+bash script/runShell.sh
+```
+
+**What it does:**  
+- Changes to the script’s directory.
+- Prints the current directory path.
+- Displays a message indicating the script is running.
+
+**Note:**  
+You can use this as a template for your own shell scripts or to automate project-related tasks.
+
+## script/sysEnv.sh
+
+**Purpose:**  
+`sysEnv.sh` is a shell script that collects and displays system telemetry and environment information, especially useful for monitoring a Raspberry Pi or similar device running the Mesh Bot.
+
+**Usage:**  
+Run this script from the terminal to view system stats and network info:
+
+```sh
+bash script/sysEnv.sh
+```
+
+**What it does:**  
+- Reports disk space, RAM usage, CPU usage, and CPU temperature (in °C and °F).
+- Checks for available Git updates if the project is a Git repository.
+- Displays the device’s public and local IP addresses.
+- Designed to work on Linux systems, with special handling for Raspberry Pi hardware.
+
+**Note:**  
+You can expand or modify this script to include additional telemetry or environment checks as needed for your deployment.

script/addFav.py

@@ -34,8 +34,10 @@ 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 *
+    from modules.log import logger, getPrettyTime
+    from modules.system import handleFavoriteNode
+    from modules.settings import LOGGING_LEVEL
+    from modules.system import compileFavoriteList
 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")

script/docker/README.md

@@ -1,25 +1,17 @@
 # How do I use this thing?
-This is not a full turnkey setup for Docker yet but gets you most of the way there!
+This is not a full turnkey setup for Docker yet?
 
-## Setup New Image
-`docker build -t meshing-around .`
+`docker pull ghcr.io/spudgunman/meshing-around:main`
 
-there is also [script/docker/docker-install.bat](script/docker/docker-install.bat) which will automate this.
+`docker network create meshing-around-network`
 
-## Ollama Image with compose
-still a WIP
-`docker compose up -d`
+`docker compose run meshtasticd`
 
-## 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"`
+`docker compose run meshing-around`
 
-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
+`docker compose run ollama`
 
-## 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
-    ```
+
+
+
+`docker compose run debug-console`

script/docker/compose.yaml

@@ -1,52 +0,0 @@
-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/config.yaml

@@ -0,0 +1,24 @@
+### Template config.yaml 
+---
+Lora:
+GPIO:
+GPS:
+I2C:
+Display:
+Touchscreen:
+Input:
+Logging:
+  LogLevel: info # debug, info, warn, error
+#  TraceFile: /var/log/meshtasticd.json
+#  AsciiLogs: true     # default if not specified is !isatty() on stdout
+Webserver:
+  Port: 443 # Port for Webserver & Webservices
+  RootPath: /usr/share/meshtasticd/web # Root Dir of WebServer
+#  SSLKey: /etc/meshtasticd/ssl/private_key.pem # Path to SSL Key, generated if not present
+#  SSLCert: /etc/meshtasticd/ssl/certificate.pem # Path to SSL Certificate, generated if not present
+General:
+  MaxNodes: 200
+  MaxMessageQueue: 100
+  ConfigDirectory: /etc/meshtasticd/config.d/
+#  MACAddress: AA:BB:CC:DD:EE:FF
+  MACAddressSource: eth0

script/docker/docker-install.bat

@@ -1,6 +0,0 @@
-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

@@ -1,2 +0,0 @@
-REM launch meshing-around container with a terminal
-docker run -it --entrypoint /bin/bash meshing-around

script/docker/entrypoint.sh

@@ -1,6 +1,16 @@
 #!/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
+
+# if no config.ini exists, copy the default one
+if [ ! -f /app/config.ini ]; then
+    cp /app/config.template /app/config.ini
+
+    ls -l /app/config.ini
+    # Set type = tcp in [interface]
+    sed -i '/^\[interface\]/,/^[^[]/ s/^type = .*/type = tcp/' /app/config.ini
+    # Remove any commented or uncommented hostname lines in [interface]
+    sed -i '/^\[interface\]/,/^[^[]/ s/^#\? *hostname = .*$//' /app/config.ini
+    # Add hostname = meshtasticd:4403 after [interface]
+    sed -i '/^\[interface\]/a hostname = UPDATE-DOCKER-IP' /app/config.ini
+fi
+# Run the bot as appuser (if you want to drop privileges)
+exec python /app/mesh_bot.py

script/docker/ollama-entrypoint.sh

@@ -1,16 +0,0 @@
-#!/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

@@ -1,6 +1,6 @@
 #!/usr/bin/env python3
 # Usage: python3 script/injectDM.py -s NODEID -d NODEID -m "message"
-# meshing-around - helper script
+# meshing-around - helper script - enable the bbsAPI in config.ini first
 import sys
 import os
 import argparse
@@ -14,8 +14,10 @@ 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 *
+    from modules.log import logger
+    from modules.bbstools import bbs_post_dm, bbs_dm, get_bbs_stats
+    from modules.settings import LOGGING_LEVEL, vpTracker, MOTD
+    logger.setLevel(LOGGING_LEVEL)
 except Exception as e:
     print(f"Error importing modules run this program from the main program directory 'python3 script/injectDM.py'")
     exit(1)

script/sysEnv.sh

@@ -42,3 +42,15 @@ then
         fi
     fi
 fi
+
+# Get public and local IP addresses
+public_ip=$(curl -s https://ifconfig.me 2>/dev/null)
+public_ip=${public_ip:-""}
+local_ip=$(hostname -I 2>/dev/null | awk '{print $1}')
+local_ip=${local_ip:-""}
+if [ -n "$public_ip" ]; then
+    echo "Public IP: $public_ip"
+fi
+if [ -n "$local_ip" ]; then
+    echo "Local IP: $local_ip"
+fi

update.sh

@@ -3,6 +3,7 @@
 # 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 
+service_stopped=false
 if systemctl is-active --quiet mesh_bot.service; then
     echo "Stopping mesh_bot.service..."
     systemctl stop mesh_bot.service
@@ -44,11 +45,42 @@ if ! git pull origin main --rebase; then
     fi
 fi
 
+# copy modules/custom_scheduler.py template if it does not exist
+if [[ ! -f modules/custom_scheduler.py ]]; then
+    cp -n etc/custom_scheduler.py modules/
+    printf "\nCustom scheduler template copied to modules/custom_scheduler.py\n"
+elif ! cmp -s modules/custom_scheduler.template etc/custom_scheduler.py; then
+    echo "custom_scheduler.py is set. To check changes run: diff etc/custom_scheduler.py modules/custom_scheduler.py"
+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/"
+#copy custom_scheduler.py if it exists
+if [[ -f "modules/custom_scheduler.py" ]]; then
+    echo "Including custom_scheduler.py in backup..."
+    cp modules/custom_scheduler.py data/
+fi
+# Check config.ini ownership and permissions
+if [[ -f "config.ini" ]]; then
+    owner=$(stat -f "%Su" config.ini)
+    perms=$(stat -f "%A" config.ini)
+    echo "config.ini is owned by: $owner"
+    echo "config.ini permissions: $perms"
+    if [[ "$owner" == "root" ]]; then
+        echo "Warning: config.ini is owned by root check out the etc/set-permissions.sh script"
+    fi
+    if [[ $(stat -f "%Lp" config.ini) =~ .*[7,6,2]$ ]]; then
+        echo "Warning: config.ini is world-writable or world-readable! check out the etc/set-permissions.sh script"
+    fi
+
+    echo "Including config.ini in backup..."
+
+    cp config.ini data/config.backup
+fi
+#create the tar.gz backup
 tar -czf "$backup_file" "$path2backup"
 if [ $? -ne 0 ]; then
     echo "Error: Backup failed."
@@ -56,12 +88,10 @@ 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 [[ -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
@@ -71,14 +101,14 @@ 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
+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."
+    for svc in mesh_bot.service pong_bot.service mesh_bot_reporting.service mesh_bot_w3.service; do
+        if systemctl list-unit-files | grep -q "^$svc"; then
+            systemctl start "$svc"
+            echo "$svc restarted."
+        fi
+    done
 fi
 
 # Print completion message