Generate a one-line command to install MeshDash directly on your Raspberry Pi running Raspberry Pi OS (or other compatible Debian-based systems).

This method is ideal for dedicated Pi setups acting as MeshDash servers.

Your Meshtastic device must be:

Generate `docker-compose.yml` and `Dockerfile` to build and run MeshDash in a container using Docker.

This method utilizes the standard install.sh script inside the container during the build process.

Your Meshtastic device must be:

Generate a one-line command to install MeshDash on Windows using the Windows Subsystem for Linux (WSL) with a Debian-based distribution like Ubuntu.

Your Meshtastic device must be:

Manual MeshDash Installation Guide (for R1.6 Logic)

This guide provides detailed instructions for manually installing MeshDash on Debian-based systems (like Debian, Ubuntu, and Raspberry Pi OS). It mirrors the steps performed by the install.sh (version R1.6) automated installer script. Understanding each step is crucial for a successful manual setup and for troubleshooting.

1. Prerequisites

Before starting, ensure your system has the necessary tools and a compatible Python version. The install.sh script checks for these and attempts to install them. Manually, you'll need to do this yourself.

1.1. Essential System Tools

You'll need sudo (for administrative commands), apt (for package management), wget or curl (for downloading files), and unzip (for extracting archives). You'll also need bash.

Check if they are installed:

command -v sudo
command -v apt
command -v wget
command -v curl
command -v unzip
command -v bash

If any are missing (sudo, apt, bash are usually present), install them:

sudo apt update
sudo apt install wget curl unzip software-properties-common bash

software-properties-common provides the add-apt-repository command, needed if installing Python via the 'deadsnakes' PPA.

1.2. Python Version (Minimum 3.9)

MeshDash R1.6 requires Python 3.9 or newer. Check your default Python 3 version:

python3 --version

If your version is below 3.9 (e.g., Python 3.7 on Debian Buster/Raspberry Pi OS Buster), you must install a newer version. The install.sh script (R1.6) offers to do this using the 'deadsnakes' PPA.

Installing a Newer Python Version (e.g., Python 3.9):

1. Add the 'deadsnakes' PPA:

   sudo add-apt-repository ppa:deadsnakes/ppa

2. Update package lists:

   sudo apt update

3. Install Python 3.9 and its venv package:

   sudo apt install python3.9 python3.9-venv

Always install the corresponding -venv package (e.g., python3.9-venv for python3.9). This is crucial for creating virtual environments. The install.sh script also installs this (e.g., python${MIN_PYTHON_VERSION}-venv).

Verify the new Python version:

python3.9 --version

For the rest of this guide, <your_python_command> will refer to the Python command that meets the 3.9+ requirement (e.g., python3.9 or just python3 if your default is sufficient).

1.3. Essential Python Modules (pip and venv)

Ensure pip (Python package installer) and venv (for virtual environments) are available for your chosen Python interpreter (<your_python_command>).

For pip: It usually comes with Python installs from the 'deadsnakes' PPA or newer system Pythons. Check with:

<your_python_command> -m pip --version

If missing, you might try installing python3-pip (though this might install pip for the system's default python3, not necessarily your newer one) or, more reliably for a specific Python version like 3.9, use ensurepip:

sudo <your_python_command> -m ensurepip --upgrade

For venv: This should have been installed with the pythonX.Y-venv package. Check its availability (it might not have a --version flag but -h for help):

<your_python_command> -m venv -h

The install.sh (R1.6) specifically checks and attempts to install these.

2. Choosing MeshDash Version and Download URL

The install.sh script is set to download version R1.6 (from MESHDASH_VERSION="R1.6"). You can choose the version you wish to install. MeshDash versions are typically available at:

https://meshdash.co.uk/versions/<VERSION_TAG>/mesh-dash.zip

For this guide, we'll assume you're installing version R1.6. The download URL is: https://meshdash.co.uk/versions/R1.6/mesh-dash.zip

3. Installation Steps

3.1. Create Installation Directory

The install.sh script creates a subdirectory named mesh-dash (from INSTALL_SUBDIR="mesh-dash") in the directory where the script is run. Create this directory, for example, in your home directory:

mkdir ~/mesh-dash
cd ~/mesh-dash

All subsequent commands assume you are in this ~/mesh-dash directory.

3.2. Download Application Archive

Download the MeshDash R1.6 ZIP file:

wget https://meshdash.co.uk/versions/R1.6/mesh-dash.zip

3.3. Extract Application Archive

Extract the downloaded ZIP file:

unzip mesh-dash.zip

This should extract files into the current directory. Verify that key files are present: meshtastic_dashboard.py, requirements.txt, mesh_dash_tools.sh, and a static directory.

3.4. Create .new file in static directory

The install.sh script creates a marker file. If the static directory was extracted:

if [ -d "static" ]; then
    touch static/.new
    echo "Created static/.new marker file."
else
    echo "Warning: 'static' directory not found after unzipping. Cannot create .new file."
fi

3.5. Set Permissions for Tools Script

If mesh_dash_tools.sh exists, make it executable:

if [ -f mesh_dash_tools.sh ]; then
    chmod +x mesh_dash_tools.sh
    echo "mesh_dash_tools.sh made executable."
fi

3.6. Create Python Virtual Environment

Use your chosen Python command (<your_python_command>) to create the venv named mesh-dash_venv (from VENV_DIR in script):

<your_python_command> -m venv mesh-dash_venv

3.7. Activate Virtual Environment and Install Dependencies

Activate the venv:

source mesh-dash_venv/bin/activate

Your shell prompt should change. Now, upgrade pip and install dependencies from requirements.txt:

pip install --upgrade pip
pip install -r requirements.txt

This might take a few minutes. Afterwards, you can deactivate for now:

deactivate

4. Configuration

MeshDash R1.6 uses a configuration file named .mesh-dash_config. Create this file in your installation directory (~/mesh-dash):

nano .mesh-dash_config

Paste the following content, carefully replacing placeholders. This matches the structure generated by the R1.6 install.sh:

# MeshDash Configuration File

MESHTASTIC_HOST="YOUR_DEVICE_IP"
MESHTASTIC_PORT="4403"

WEBSERVER_HOST="0.0.0.0"
WEBSERVER_PORT="8000"

LOG_LEVEL="INFO"
DB_PATH="meshtastic_data.db"
MAX_PACKETS_MEMORY=200
HISTORY_DAYS="30"

SEND_LOCAL_NODE_LOCATION=false
SEND_OTHER_NODES_LOCATION=false
COMMUNITY_API=false
LOCATION_OFFSET_ENABLED=false
LOCATION_OFFSET_METERS=0.0

AUTH_TOKEN_EXPIRE_MINUTES=30

INITIAL_ADMIN_USERNAME=""
INITIAL_ADMIN_PASSWORD=""

INSTALLED_VERSION="R1.6"

# --- Informational comments from installer ---
# Python command used during installation for venv creation: <your_python_command>
# Python version detected during installation: <your_python_version_detected>

Crucial: Replace YOUR_DEVICE_IP with the actual IP of your Meshtastic device. Adjust WEBSERVER_PORT if needed. The INITIAL_ADMIN_USERNAME and INITIAL_ADMIN_PASSWORD can be set here if you want the application to create an admin user on its first run (the application should then clear these from the config). If left blank, no initial admin is created this way.

Save and close the file.

5. Generating a Manual Run Script

Create run_meshdash.sh in your installation directory (~/mesh-dash):

nano run_meshdash.sh

Paste the following (from R1.6 install.sh logic):

#!/bin/bash
# Run script for MeshDash - Generated by install.sh on $(date)

SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" &> /dev/null && pwd )"

CONFIG_FILE="$SCRIPT_DIR/.mesh-dash_config"
VENV_PATH="$SCRIPT_DIR/mesh-dash_venv"
PYTHON_EXEC="$VENV_PATH/bin/python"
MAIN_APP_SCRIPT="$SCRIPT_DIR/meshtastic_dashboard.py"

RUN_BLUE='\033[0;34m'; RUN_YELLOW='\033[0;33m'; RUN_RED='\033[0;31m'; RUN_BOLD='\033[1m'; RUN_NC='\033[0m'

run_echoinfo() { printf "${RUN_BLUE}[INFO]${RUN_NC} %s\n" "$1"; }
run_echoerror() { printf "${RUN_RED}${RUN_BOLD}[ERROR]${RUN_NC} %s\n" "$1" >&2; }

if [ ! -d "$VENV_PATH" ]; then
    run_echoerror "Virtual environment not found at: $VENV_PATH"
    exit 1
fi
if [ ! -x "$PYTHON_EXEC" ]; then
    run_echoerror "Python executable in virtual environment not found or not executable: $PYTHON_EXEC"
    exit 1
fi
if [ ! -f "$MAIN_APP_SCRIPT" ]; then
    run_echoerror "Main application script not found: $MAIN_APP_SCRIPT"
    exit 1
fi

run_echoinfo "Starting MeshDash..."
run_echoinfo "Using Python: $PYTHON_EXEC"
run_echoinfo "Application working directory: $SCRIPT_DIR"
run_echoinfo "Config file expected at: $CONFIG_FILE (app reads this directly)"
run_echoinfo "Press Ctrl+C to stop the application if running in foreground."

cd "$SCRIPT_DIR" || { run_echoerror "Failed to change directory to $SCRIPT_DIR"; exit 1; }

"$PYTHON_EXEC" "$MAIN_APP_SCRIPT"

RUN_EXIT_CODE=$?
run_echoinfo "MeshDash finished with exit code $RUN_EXIT_CODE."
exit $RUN_EXIT_CODE

Save, close, and make it executable:

chmod +x run_meshdash.sh

6. Running MeshDash Manually

From your installation directory (~/mesh-dash):

./run_meshdash.sh

Access the dashboard via your browser (e.g., http://localhost:8000 or http://<HOST_IP>:8000). Stop with Ctrl+C.

7. Setting up a Systemd Service (Optional)

This allows MeshDash to start on boot. Ensure systemctl is available.

7.1. Determine User and Group

The service should run as your regular user (e.g., pi). Find username: whoami. Find group: id -gn $(whoami).

7.2. Create the Service File

Create /etc/systemd/system/mesh-dash.service with sudo:

sudo nano /etc/systemd/system/mesh-dash.service

Paste, replacing placeholders like your_user, your_group, and full paths:

[Unit]
Description=MeshDash Service (Meshtastic Web Dashboard - vR1.6)
Documentation=https://meshdash.co.uk
After=network.target network-online.target
Wants=network-online.target

[Service]
Type=simple
User=your_user
Group=your_group
WorkingDirectory=/home/your_user/mesh-dash
EnvironmentFile=/home/your_user/mesh-dash/.mesh-dash_config
ExecStart=/home/your_user/mesh-dash/mesh-dash_venv/bin/python /home/your_user/mesh-dash/meshtastic_dashboard.py
Restart=on-failure
RestartSec=10
TimeoutStopSec=30
StandardOutput=journal
StandardError=journal

[Install]
WantedBy=multi-user.target

Crucial: All paths in WorkingDirectory, EnvironmentFile, and ExecStart must be absolute and correct for your system and username.

Save and close.

7.3. Manage the Service

sudo systemctl daemon-reload
sudo systemctl enable mesh-dash.service
sudo systemctl start mesh-dash.service
sudo systemctl status mesh-dash.service --no-pager
sudo journalctl -u mesh-dash.service -n 50 --no-pager # To check logs

8. Post-Installation

Access the dashboard as described in step 6. If mesh_dash_tools.sh exists, you can use it (often with sudo): cd ~/mesh-dash && sudo ./mesh_dash_tools.sh help.

You can remove the downloaded ZIP: rm ~/mesh-dash/mesh-dash.zip.

This completes the manual installation mirroring the R1.6 script.