Update debian/changelog for v2.0.0 production release

Version bump:
- Update VERSION to 2.0.0 (from 2.0.0-dev)
- Update pyproject.toml to 2.0.0
- Change development status to Production/Stable

Documentation updates:
- Add Debian package installation instructions (system-wide)
- Add sensor discovery and approval workflow documentation
- Update configuration section with approval workflow
- Update service management for system installation
- Update troubleshooting for system installation
- Update MQTT settings documentation
- Add links to download Debian packages from releases

The application is now production-ready with:
- Systemd integration for automatic service management
- Automatic startup and restart on failure
- Configuration via /etc/sensorpajen/
- Runtime state in /var/lib/sensorpajen/
- Interactive sensor approval workflow
- Automatic configuration reload
- Comprehensive logging via journalctl

ROADMAP.md

@@ -321,142 +321,75 @@ config/sensorpajen.env
 
 ---
 
-### Phase 8: APT Package Creation ✓ TODO
+### Phase 8: APT Package Creation ✅ DONE (2025-12-27)
 **Goal**: Create Debian package for easy installation on Raspberry Pi
 
-#### Tasks:
+**Notes**:
-1. Create debian/ directory structure:
+- Complete debian/ directory structure created
-   ```bash
+- System-wide installation to /opt/sensorpajen
-   mkdir -p debian
+- Configuration in /etc/sensorpajen
-   ```
+- Dedicated sensorpajen system user
+- Automatic venv creation in postinst
+- Bluetooth capabilities set automatically
+- Config preserved on remove/purge for safety
+- Dual-mode support: system installation and development
+- config.py auto-detects installation type
 
-2. Create `debian/control`:
+#### Files Created:
-   ``APT package installation instructions
+- ✅ debian/control - Package metadata and dependencies
-   - Development installation instructions
+- ✅ debian/compat - Debhelper compatibility level
-   - Configuration guide (relative paths)
+- ✅ debian/changelog - Package version history
-   - Service management commands
+- ✅ debian/rules - Build instructions
-   - Troubleshooting section
+- ✅ debian/install - File installation mappings
-   - Remove DHT11 references
+- ✅ debian/postinst - Post-installation script (user, venv, setcap)
-   - Remove pirate_audio references
+- ✅ debian/prerm - Pre-removal script (stop service)
+- ✅ debian/postrm - Post-removal script (cleanup)
+- ✅ debian/sensorpajen.service - System-wide systemd unit
 
-3. Create INSTALL.md:
+#### Code Updates:
-   - APT package installation steps
+- ✅ Updated src/sensorpajen/config.py to detect system installation
-   - Manual installation steps
+  - Checks for /opt/sensorpajen existence
-   - Configuration examples
+  - Uses /etc/sensorpajen for config in system mode
-   - First-time setup guide
+  - Falls back to PROJECT_ROOT/config for development
-   - Raspberry Pi specific instructionsds}, ${misc:Depends},
+- ✅ Updated scripts/approve-sensors.sh for dual-mode operation
-            python3-bluepy,
+  - Detects system vs development installation
-            python3-paho-mqtt,
+  - Uses correct venv and config paths
-            bluetooth,
+- ✅ Created scripts/verify-deb.sh - Automated build and verification
-            bluez
-   Description: Bluetooth temperature sensor monitor
-    Monitors Xiaomi Mijia LYWSD03MMC Bluetooth temperature sensors
-    and publishes data to MQTT broker.
-   ```
 
-3. Create `debian/rules`:
+#### Package Details:
-   ```makefile
+- Package name: sensorpajen
-   #!/usr/bin/make -f
+- Version: 2.0.0-dev
+- Architecture: all
+- System paths:
+  - Application: /opt/sensorpajen/
+  - Configuration: /etc/sensorpajen/
+  - Service file: /etc/systemd/system/sensorpajen.service
+  - Examples: /usr/share/doc/sensorpajen/examples/
+- Runs as dedicated sensorpajen user (system account)
+- Auto-enables service but waits for configuration before starting
 
-   %:
+#### Build and Test:
-   	dh $@ --with python3 --buildsystem=pybuild
+```bash
+# Build package
+./scripts/verify-deb.sh
 
-   override_dh_auto_install:
+# Or manually:
-   	pytOption 1: APT Package (Recommended for Raspberry Pi)
+dpkg-buildpackage -us -uc -b
+lintian ../sensorpajen_*.deb
 
-   1. Download and install the .deb package:
+# Install on Raspberry Pi:
-   ```bash
+scp ../sensorpajen_*.deb pi@raspberrypi:~/
-   sudo dpkg -i sensorpajen_1.0.0_all.deb
+ssh pi@raspberrypi
-   sudo apt-get install -f  # Fix any dependencies
+sudo apt install ./sensorpajen_*.deb
-   ```
 
-   2. Configure:
+# Configure:
-   ```bash
+sudo nano /etc/sensorpajen/sensorpajen.env
-   mkdir -p ~/sensorpajen/config
+sudo nano /etc/sensorpajen/sensors.json
-   cp /usr/share/doc/sensorpajen/examples/sensorpajen.env.example ~/sensorpajen/config/sensorpajen.env
-   cp /usr/share/doc/sensorpajen/examples/sensors.json.example ~/sensorpajen/config/sensors.json
-   # Edit both files
-   nano ~/sensorpajen/config/sensorpajen.env
-   nano ~/sensorpajen/config/sensors.json
-   chmod 600 ~/sensorpajen/config/sensorpajen.env
-   ```
 
-   3. Enable and start service:
+# Start:
-   ```bash
+sudo systemctl start sensorpajen
-   systemctl --user enable sensorpajen
+sudo journalctl -u sensorpajen -f
-   systemctl --user start sensorpajen
+```
-   ```
-   
-   ### Option 2: Development Installation
-   
-   1. Clone Repository
-   ```bash
-   git clone <repo> ~/sensorpajen
-   cd ~/sensorpajen
-   ```
-   
-   2. Create Virtual Environment
-   ```bash
-   python3 -m venv .venv
-   source .venv/bin/activate
-   pip install -e .
-   ```
-
-### Relative Paths (For Portability)
-- **Project root**: `~/sensorpajen/` (or wherever you clone/install)
-- **Application config**: `~/sensorpajen/config/`
-- **Environment file**: `~/sensorpajen/config/sensorpajen.env` (0600)
-- **Sensor mapping**: `~/sensorpajen/config/sensors.json` (0644)
-- **Service file**: `~/.config/systemd/user/sensorpajen.service`
-
-### Advantages of Relative Paths
-- Works on any system (development, production, multiple Raspberry Pis)
-- Easy to backup/restore entire directory
-- No hardcoded paths in code
-- Simple to deploy via git pull or package installation
-- User service runs without sudo
-
-### APT Package Installation
-When installed via .deb package:
-- **Python package**: `/usr/lib/python3/dist-packages/sensorpajen/`
-- **Service file**: `/lib/systemd/user/sensorpajen.service`
-- **Config templates**: `/usr/share/doc/sensorpajen/examples/`
-- **User config**: `~/sensorpajen/config/` (created by user)sensorpajen
-   ```
-   
-   5. Verify
-   ```bash
-   systemctl --user status sensorpajen
-   journalctl --user -u sensorpajen -f
-   ```uetooth access
-   if [ "$1" = "configure" ]; then
-       PYTHON_PATH=$(readlink -f /usr/bin/python3)
-       setcap 'cap_net_raw,cap_net_admin+eip' "$PYTHON_PATH" || true
-   fi
-   
-   #DEBHELPER#
-   ```
-
-7. Create `debian/README.Debian`:
-   - Installation instructions
-   - Configuration guide
-   - Service management
-
-8. Build the package:
-   ```bash
-   dpkg-buildpackage -us -uc -b
-   ```
-
-9. Test installation on Raspberry Pi:
-   ```bash
-   sudo dpkg -i ../sensorpajen_1.0.0_all.deb
-   sudo apt-get install -f  # Fix dependencies if needed
-   ```
-
-10. Create installation documentation:
-    - Package installation instructions
-    - Configuration setup after installation
-    - Service enablement
 
 ---
 

TASKS.md

@@ -1,4 +1,495 @@
 # Tasks
+
+## Task: Debian Package Creation
+
+**Status**: DONE (2025-12-27)
+**Priority**: Medium  
+**Estimated Effort**: 4-6 hours
+**Actual Effort**: ~5 hours
+
+### Implementation Summary
+
+Successfully created a complete Debian package infrastructure for system-wide installation on Raspberry Pi and Debian-based systems. The package provides:
+
+- **System-wide installation** to `/opt/sensorpajen/` with dedicated user
+- **Configuration management** via `/etc/sensorpajen/` (preserved on upgrades)
+- **Automatic setup** including Python venv, dependencies, and Bluetooth capabilities
+- **Dual-mode operation** supporting both system and development installations
+- **Build verification** with automated script
+
+### Files Created
+
+#### Debian Package Files (debian/)
+- `control` - Package metadata, dependencies, maintainer info
+- `compat` - Debhelper compatibility (v13)
+- `changelog` - Version history and release notes
+- `rules` - Build instructions (Makefile)
+- `install` - File installation mappings
+- `postinst` - Post-installation script (creates user, venv, sets capabilities)
+- `prerm` - Pre-removal script (stops service)
+- `postrm` - Post-removal script (cleanup, preserves config)
+- `sensorpajen.service` - System-wide systemd unit file
+
+#### Updated Code
+- `src/sensorpajen/config.py` - Auto-detects system vs development installation
+- `scripts/approve-sensors.sh` - Supports both installation modes
+- `scripts/verify-deb.sh` - Automated build and verification script (NEW)
+
+### Installation Paths
+
+**System Installation (via .deb):**
+- Application: `/opt/sensorpajen/`
+- Python venv: `/opt/sensorpajen/venv/`
+- Configuration: `/etc/sensorpajen/`
+- Service: `/etc/systemd/system/sensorpajen.service`
+- Examples: `/usr/share/doc/sensorpajen/examples/`
+- User: `sensorpajen` (system account, no login)
+
+**Development Installation:**
+- Application: `<project-root>/`
+- Python venv: `<project-root>/.venv/`
+- Configuration: `<project-root>/config/`
+- Service: `~/.config/systemd/user/sensorpajen.service`
+
+### Key Features Implemented
+
+✅ System-wide installation with dedicated user
+✅ Python venv created automatically in postinst
+✅ All dependencies installed from PyPI
+✅ Bluetooth capabilities set automatically (setcap)
+✅ Systemd service enabled but not started (waits for config)
+✅ Configuration preserved on upgrade/remove/purge
+✅ Example configs copied to /etc/sensorpajen on first install
+✅ Dual-mode code (auto-detects system vs dev)
+✅ Automated verification script
+✅ Full lintian compliance
+
+### Build and Install
+
+```bash
+# Verify and build
+./scripts/verify-deb.sh
+
+# Or manually
+dpkg-buildpackage -us -uc -b
+lintian ../sensorpajen_*.deb
+
+# Install on Raspberry Pi
+scp ../sensorpajen_*.deb pi@raspberrypi:~/
+ssh pi@raspberrypi
+sudo apt install ./sensorpajen_*.deb
+
+# Configure
+sudo nano /etc/sensorpajen/sensorpajen.env
+sudo nano /etc/sensorpajen/sensors.json
+
+# Start service
+sudo systemctl start sensorpajen
+sudo journalctl -u sensorpajen -f
+```
+
+### Testing Results
+
+✅ Package builds successfully with `dpkg-buildpackage`
+✅ Lintian passes without errors (warnings acceptable)
+✅ Files installed to correct locations
+✅ System user created automatically
+✅ Python venv created with all dependencies
+✅ Bluetooth capabilities set correctly
+✅ Service enabled but not started before config
+✅ Configuration preserved on upgrade/remove/purge
+✅ Service runs as sensorpajen user (not root)
+✅ Logs appear in `journalctl -u sensorpajen`
+✅ Dual-mode operation works correctly
+
+### Overview
+Create a Debian `.deb` package for system-wide installation of sensorpajen on Raspberry Pi OS and other Debian-based systems. This enables easy distribution and installation via `apt`/`dpkg` instead of manual git clone + pip install.
+
+### Functional Requirements
+
+1. **System-Wide Installation**
+   - Install application to `/opt/sensorpajen/`
+   - Create Python virtual environment in `/opt/sensorpajen/venv/`
+   - Install systemd service file to `/etc/systemd/system/`
+   - Place configuration in `/etc/sensorpajen/`
+   - Put example configs in `/usr/share/doc/sensorpajen/examples/`
+
+2. **Dedicated Service User**
+   - Create `sensorpajen` system user if not exists
+   - Service runs as `sensorpajen:sensorpajen`
+   - User has no login shell, no home directory (system account)
+
+3. **Automatic Service Configuration**
+   - Auto-enable systemd service on installation
+   - Configure Bluetooth capabilities (setcap) automatically
+   - Service starts after installation if config exists
+
+4. **Configuration Management**
+   - Install example configs to `/usr/share/doc/sensorpajen/examples/`:
+     - `sensorpajen.env.example`
+     - `sensors.json.example`
+     - `discovered_sensors.json.example`
+   - Actual config expected in `/etc/sensorpajen/`:
+     - `sensorpajen.env`
+     - `sensors.json`
+   - Do NOT overwrite existing config on upgrade
+   - Preserve config on package removal
+   - Keep config even on purge (user explicitly chooses)
+   - Postinst should copy the examples into `/etc/sensorpajen/` only if they are missing, leaving any existing config untouched
+   - Upgrades should refresh `/usr/share/doc/sensorpajen/examples/` with new defaults but never alter live configs under `/etc/sensorpajen/`
+
+5. **Dependency Management**
+   - Depend on system packages: `python3`, `python3-venv`, `python3-pip`, `bluetooth`, `bluez`
+   - Create venv and install Python deps from PyPI in postinst script
+   - Use `pyproject.toml` for Python dependency specification
+
+6. **Package Metadata**
+   - Package name: `sensorpajen`
+   - Section: `misc`
+   - Priority: `optional`
+   - Architecture: `all`
+   - Maintainer: Fredrik (fredrik@wahlberg.se)
+   - Homepage: Repository URL
+   - Description: "Raspberry Pi Bluetooth temperature sensor monitor"
+   - Depends: System packages
+   - Recommends: `mosquitto-clients` (optional)
+   - **Version Source**: Extract version from `pyproject.toml` during build process.
+
+7. **Files to Include**
+   - All Python source code from `src/sensorpajen/`
+   - Scripts from `scripts/` (approve-sensors.sh)
+   - Systemd service file (system service, not user service)
+   - Example configuration files
+   - Documentation: `README.md`, `INSTALL.md`
+   - License file
+
+### Acceptance Criteria
+
+- [ ] Package builds successfully with `dpkg-buildpackage -us -uc -b`
+- [ ] Can install on fresh Raspberry Pi OS with `sudo apt install ./sensorpajen_*.deb`
+- [ ] Service user `sensorpajen` created automatically
+- [ ] Python venv created in `/opt/sensorpajen/venv/` with all dependencies
+- [ ] Bluetooth capabilities set on Python executable
+- [ ] Systemd service enabled but not started (waits for config)
+- [ ] After copying examples to `/etc/sensorpajen/` and editing, service starts successfully
+- [ ] Service runs as `sensorpajen` user, not root
+- [ ] Logs appear in `journalctl -u sensorpajen`
+- [ ] Package upgrade preserves `/etc/sensorpajen/` config files
+- [ ] Package removal (`dpkg -r`) stops service but keeps config
+- [ ] Package purge (`dpkg -P`) keeps config (user explicitly deletes if wanted)
+- [ ] `lintian` passes with no errors (warnings acceptable)
+- [ ] Automated verification script exists that builds the `.deb` and runs `lintian`
+
+### Implementation Details
+
+#### 1. Create `debian/` Directory Structure
+
+```
+debian/
+├── control              # Package metadata and dependencies
+├── rules                # Build instructions (Makefile)
+├── install              # Files to install and destinations
+├── postinst             # Post-installation script
+├── prerm                # Pre-removal script
+├── postrm               # Post-removal script
+├── changelog            # Required for native build (minimal entry)
+└── sensorpajen.service  # Systemd service file (system-wide)
+```
+
+#### 2. `debian/control` File
+
+```
+Source: sensorpajen
+Section: misc
+Priority: optional
+Maintainer: Fredrik <fredrik@wahlberg.se>
+Build-Depends: debhelper-compat (= 13)
+Standards-Version: 4.5.0
+Homepage: https://git.example.com/fredrik/sensorpajen
+
+Package: sensorpajen
+Architecture: all
+Depends: python3 (>= 3.9), python3-venv, python3-pip, bluetooth, bluez, ${misc:Depends}
+Recommends: mosquitto-clients
+Description: Raspberry Pi Bluetooth temperature sensor monitor
+ Monitors Xiaomi Mijia LYWSD03MMC temperature sensors via Bluetooth Low Energy
+ and publishes readings to MQTT broker. Supports ATC firmware with automatic
+ sensor discovery and approval workflow.
+```
+
+#### 3. `debian/install` File
+
+```
+src/sensorpajen/* opt/sensorpajen/src/sensorpajen/
+scripts/approve-sensors.sh opt/sensorpajen/scripts/
+pyproject.toml opt/sensorpajen/
+README.md usr/share/doc/sensorpajen/
+INSTALL.md usr/share/doc/sensorpajen/
+config/*.example usr/share/doc/sensorpajen/examples/
+```
+
+#### 4. `debian/rules` File
+
+```makefile
+#!/usr/bin/make -f
+
+%:
+	dh $@
+
+override_dh_auto_build:
+	# No build step needed for pure Python
+
+override_dh_auto_install:
+	# Installation handled by debian/install file
+	
+override_dh_auto_clean:
+	# Clean build artifacts
+	rm -rf build/ dist/ *.egg-info
+```
+
+#### 5. `debian/postinst` Script
+
+```bash
+#!/bin/bash
+set -e
+
+# Create sensorpajen system user
+if ! getent passwd sensorpajen > /dev/null; then
+    useradd --system --no-create-home --shell /usr/sbin/nologin sensorpajen
+fi
+
+# Create config directory
+mkdir -p /etc/sensorpajen
+chown sensorpajen:sensorpajen /etc/sensorpajen
+
+# Create virtual environment
+cd /opt/sensorpajen
+python3 -m venv venv
+venv/bin/pip install --upgrade pip
+venv/bin/pip install .
+
+# Set Bluetooth capabilities
+PYTHON_PATH=$(readlink -f venv/bin/python3)
+setcap cap_net_raw,cap_net_admin+eip "$PYTHON_PATH" || echo "Warning: setcap failed, install libcap2-bin and rerun"
+
+# Install systemd service
+cp debian/sensorpajen.service /etc/systemd/system/
+systemctl daemon-reload
+
+# Enable service (but don't start - needs config first)
+systemctl enable sensorpajen.service || echo "Warning: systemctl enable failed, enable manually"
+
+# Check if config exists, if so restart service
+if [ -f /etc/sensorpajen/sensorpajen.env ] && [ -f /etc/sensorpajen/sensors.json ]; then
+    systemctl restart sensorpajen.service
+    echo "sensorpajen service started"
+else
+    echo "Configuration needed: Copy examples from /usr/share/doc/sensorpajen/examples/ to /etc/sensorpajen/"
+    echo "Then run: sudo systemctl start sensorpajen"
+fi
+
+# Copy example configs if they're missing (never overwrite live config)
+for sample in sensorpajen.env.example sensors.json.example discovered_sensors.json.example; do
+  target="/etc/sensorpajen/${sample%.example}"
+  if [ ! -f "$target" ]; then
+    cp "/usr/share/doc/sensorpajen/examples/$sample" "$target"
+    chown sensorpajen:sensorpajen "$target"
+    echo "Copied $sample to /etc/sensorpajen/"
+  fi
+done
+
+exit 0
+```
+
+#### 6. `debian/prerm` Script
+
+```bash
+#!/bin/bash
+set -e
+
+# Stop service before removal
+if systemctl is-active --quiet sensorpajen.service; then
+    systemctl stop sensorpajen.service
+fi
+
+# Disable service
+systemctl disable sensorpajen.service || true
+
+exit 0
+```
+
+#### 7. `debian/postrm` Script
+
+```bash
+#!/bin/bash
+set -e
+
+case "$1" in
+    remove)
+        # Service removed but config preserved
+        echo "sensorpajen removed, config preserved in /etc/sensorpajen/"
+        ;;
+    purge)
+        # Even on purge, keep config (user choice to delete manually)
+        echo "Config preserved in /etc/sensorpajen/ - delete manually if needed"
+        # Could optionally remove user here, but safer to keep
+        ;;
+esac
+
+# Clean up systemd
+systemctl daemon-reload || true
+
+exit 0
+```
+
+#### 8. `debian/sensorpajen.service` File
+
+```ini
+[Unit]
+Description=Sensorpajen Bluetooth Temperature Monitor
+Documentation=https://github.com/fredrik/sensorpajen
+After=bluetooth.target network.target
+Wants=bluetooth.target
+
+[Service]
+Type=simple
+User=sensorpajen
+Group=sensorpajen
+WorkingDirectory=/opt/sensorpajen
+EnvironmentFile=/etc/sensorpajen/sensorpajen.env
+ExecStart=/opt/sensorpajen/venv/bin/python -m sensorpajen.main
+Restart=always
+RestartSec=10
+
+# Bluetooth capabilities require this to be false
+NoNewPrivileges=false
+
+# Hardening (where possible with BT requirements)
+PrivateTmp=true
+ProtectSystem=strict
+ProtectHome=true
+ReadWritePaths=/etc/sensorpajen
+
+[Install]
+WantedBy=multi-user.target
+```
+
+#### 9. Build Process
+
+```bash
+# From repository root
+dpkg-deb --build debian sensorpajen_2.0.0_armhf.deb
+
+# Check package contents
+dpkg-deb -c sensorpajen_2.0.0_armhf.deb
+
+# Check for issues
+lintian sensorpajen_2.0.0_armhf.deb
+
+> On every upgrade, rewrite `/usr/share/doc/sensorpajen/examples/` with the new package-provided examples so admins always have the latest defaults, but never overwrite existing files under `/etc/sensorpajen/`.
+
+### Automated Verification
+
+Provide a script (e.g., `scripts/verify-deb.sh`) that runs the build and linting steps in a clean environment. The script should:
+
+```
+#!/bin/bash
+set -e
+
+./ci/build-debian.sh    # builds the deb into a temp directory
+lintian sensorpajen_*.deb
+
+echo "Package verification succeeded"
+```
+
+Acceptable tooling: `bash`, `lintian`, `dpkg-deb`. If lintian reports errors, the script should fail and print the diagnostics so you can triage the issue.
+```
+
+#### 10. Installation Test
+
+```bash
+# Install
+sudo dpkg -i sensorpajen_2.0.0_armhf.deb
+
+# Copy and edit config
+sudo cp /usr/share/doc/sensorpajen/examples/sensorpajen.env.example /etc/sensorpajen/sensorpajen.env
+sudo cp /usr/share/doc/sensorpajen/examples/sensors.json.example /etc/sensorpajen/sensors.json
+sudo nano /etc/sensorpajen/sensorpajen.env
+
+# Start service
+sudo systemctl start sensorpajen
+
+# Check status
+sudo systemctl status sensorpajen
+sudo journalctl -u sensorpajen -f
+
+# Test upgrade
+# (make changes, rebuild, reinstall - config should persist)
+
+# Test removal
+sudo dpkg -r sensorpajen  # Config stays
+sudo dpkg -P sensorpajen  # Config still stays
+```
+
+### File Paths Reference
+
+| Purpose | Path |
+|---------|------|
+| Application code | `/opt/sensorpajen/src/sensorpajen/` |
+| Python venv | `/opt/sensorpajen/venv/` |
+| Scripts | `/opt/sensorpajen/scripts/` |
+| Systemd service | `/etc/systemd/system/sensorpajen.service` |
+| Active config | `/etc/sensorpajen/sensorpajen.env`, `/etc/sensorpajen/sensors.json` |
+| Discovery data | `/etc/sensorpajen/discovered_sensors.json` |
+| Example configs | `/usr/share/doc/sensorpajen/examples/*.example` |
+| Documentation | `/usr/share/doc/sensorpajen/` |
+| Approve script | `/opt/sensorpajen/scripts/approve-sensors.sh` |
+
+### Configuration Updates Needed
+
+When implementing, update these to use `/etc/sensorpajen`:
+
+**`src/sensorpajen/config.py`**:
+```python
+# Change PROJECT_ROOT logic for system installation
+if Path('/opt/sensorpajen').exists():
+    # System installation
+    PROJECT_ROOT = Path('/opt/sensorpajen')
+    CONFIG_DIR = Path('/etc/sensorpajen')
+else:
+    # Development installation
+    PROJECT_ROOT = Path(__file__).parent.parent.parent
+    CONFIG_DIR = PROJECT_ROOT / "config"
+```
+
+**`scripts/approve-sensors.sh`**:
+```bash
+# Update paths for system installation
+if [ -d "/opt/sensorpajen" ]; then
+    cd /opt/sensorpajen
+    source /etc/sensorpajen/sensorpajen.env
+    source venv/bin/activate
+else
+    # Development mode
+    cd "$(dirname "$0")/.."
+    source config/sensorpajen.env
+    source .venv/bin/activate
+fi
+```
+
+### Notes
+
+- Package is **system-wide**, not user-scoped
+- Config in `/etc/sensorpajen/` is **never** auto-deleted
+- Service runs as dedicated `sensorpajen` user for security
+- Virtual environment created post-install to handle PyPI dependencies
+- Bluetooth capabilities set automatically
+- Service enabled but not started until config exists
+- Follow Debian package naming: `sensorpajen_2.0.0_armhf.deb`
+- Test on fresh Pi before considering complete
+
+---
+
 ## Task: Add Auto-Discovery and Approval Flow for Sensors
 
 ### Problem Statement

VERSION

@@ -1 +1 @@
-2.0.0-dev
+2.0.0

config/sensorpajen.env.example

@@ -5,15 +5,22 @@ MQTT_USER=hasse
 MQTT_PASSWORD=casablanca
 MQTT_CLIENT_ID=mibridge
 
-# Sensor Configuration (relative to project root)
+# Sensor Configuration
-SENSOR_CONFIG_FILE=config/sensors.json
+# For system installation (/opt/sensorpajen): Use absolute paths
-DISCOVERED_SENSORS_FILE=config/discovered_sensors.json
+# SENSOR_CONFIG_FILE=/etc/sensorpajen/sensors.json
+# DISCOVERED_SENSORS_FILE=/etc/sensorpajen/discovered_sensors.json
+#
+# For development installation: Use relative paths (from project root)
+# SENSOR_CONFIG_FILE=config/sensors.json
+# DISCOVERED_SENSORS_FILE=config/discovered_sensors.json
+#
+# If not set, defaults will be used based on installation type
 
 # Application Settings
 WATCHDOG_TIMEOUT=5
 ENABLE_BATTERY=true
 LOG_LEVEL=INFO
-CONFIG_RELOAD_INTERVAL=900  # 15 minutes in seconds
+CONFIG_RELOAD_INTERVAL=900
 
 # ntfy Notifications (optional)
 NTFY_ENABLED=false

debian/README.md

@@ -0,0 +1,353 @@
+# Debian Package Build Guide
+
+This directory contains the Debian packaging files for **sensorpajen**, a Bluetooth temperature sensor monitor for Raspberry Pi.
+
+## Overview
+
+The Debian package installs sensorpajen as a **system-wide service** with:
+
+- Installation to `/opt/sensorpajen/`
+- Configuration in `/etc/sensorpajen/`
+- Dedicated `sensorpajen` system user
+- Systemd service integration
+- Automatic Python virtual environment setup
+- Bluetooth capability configuration
+
+## Prerequisites
+
+### Required Packages
+
+```bash
+sudo apt install \
+    debhelper \
+    dpkg-dev \
+    python3 \
+    python3-venv \
+    python3-pip
+```
+
+### Optional (for verification)
+
+```bash
+sudo apt install lintian
+```
+
+## Quick Start
+
+### Automated Build and Verification
+
+```bash
+# From project root
+./scripts/verify-deb.sh
+```
+
+This script will:
+1. Check for required tools
+2. Build the package
+3. Show package contents
+4. Run lintian checks
+5. Display installation instructions
+
+### Manual Build
+
+```bash
+# From project root
+dpkg-buildpackage -us -uc -b
+```
+
+The `.deb` file will be created in the parent directory:
+```bash
+ls -lh ../sensorpajen_*.deb
+```
+
+## Build Output
+
+```
+../sensorpajen_2.0.0-dev_all.deb     # Installable package
+../sensorpajen_2.0.0-dev_armhf.build      # Build log
+../sensorpajen_2.0.0-dev_armhf.buildinfo  # Build metadata
+../sensorpajen_2.0.0-dev_armhf.changes    # Changes file
+```
+
+## Package Verification
+
+### Check Package Contents
+
+```bash
+dpkg-deb -c ../sensorpajen_*.deb
+```
+
+### Check Package Metadata
+
+```bash
+dpkg-deb -I ../sensorpajen_*.deb
+```
+
+### Run Lintian
+
+```bash
+lintian ../sensorpajen_*.deb
+```
+
+**Note**: Warnings are acceptable. Focus on fixing errors.
+
+## Installation
+
+### On Raspberry Pi
+
+```bash
+# Copy package to Pi
+scp ../sensorpajen_*.deb pi@raspberrypi:~/
+
+# SSH to Pi and install
+ssh pi@raspberrypi
+sudo apt install ./sensorpajen_*.deb
+```
+
+### Local Testing (Not Recommended)
+
+Installing on your development machine will modify `/opt` and `/etc`:
+
+```bash
+sudo apt install ../sensorpajen_*.deb
+```
+
+**Warning**: This will create system directories and a system user on your dev machine.
+
+## Post-Installation Configuration
+
+After installing the package:
+
+```bash
+# 1. Edit MQTT credentials
+sudo nano /etc/sensorpajen/sensorpajen.env
+
+# 2. Configure sensors
+sudo nano /etc/sensorpajen/sensors.json
+
+# 3. Start the service
+sudo systemctl start sensorpajen
+
+# 4. Check status
+sudo systemctl status sensorpajen
+
+# 5. View logs
+sudo journalctl -u sensorpajen -f
+```
+
+## Package Structure
+
+### Installed Files
+
+| Source | Destination |
+|--------|-------------|
+| `src/sensorpajen/*.py` | `/opt/sensorpajen/src/sensorpajen/` |
+| `scripts/approve-sensors.sh` | `/opt/sensorpajen/scripts/` |
+| `pyproject.toml` | `/opt/sensorpajen/` |
+| `README.md`, `INSTALL.md`, `ROADMAP.md` | `/usr/share/doc/sensorpajen/` |
+| `config/*.example` | `/usr/share/doc/sensorpajen/examples/` |
+| `debian/sensorpajen.service` | `/etc/systemd/system/` |
+| *(created in postinst)* | `/opt/sensorpajen/venv/` |
+| *(created in postinst)* | `/etc/sensorpajen/` |
+
+### Configuration Files
+
+- **Active Config**: `/etc/sensorpajen/sensorpajen.env` (credentials)
+- **Active Config**: `/etc/sensorpajen/sensors.json` (sensor list)
+- **Discovery Data**: `/etc/sensorpajen/discovered_sensors.json`
+- **Examples**: `/usr/share/doc/sensorpajen/examples/*.example`
+
+## Maintainer Scripts
+
+### postinst (Post-Installation)
+
+Runs after package installation:
+
+1. Creates `sensorpajen` system user (if doesn't exist)
+2. Creates `/etc/sensorpajen/` directory
+3. Copies example configs to `/etc/sensorpajen/` (if missing)
+4. Creates Python virtual environment in `/opt/sensorpajen/venv/`
+5. Installs Python dependencies via pip
+6. Sets Bluetooth capabilities on Python executable
+7. Installs systemd service file
+8. Enables service (but doesn't start until configured)
+
+### prerm (Pre-Removal)
+
+Runs before package removal:
+
+1. Stops the sensorpajen service
+2. Disables the service (on remove, not upgrade)
+
+### postrm (Post-Removal)
+
+Runs after package removal:
+
+1. Removes systemd service file
+2. Reloads systemd daemon
+3. **Preserves** configuration in `/etc/sensorpajen/`
+4. **Preserves** `sensorpajen` user
+
+**Note**: Configuration and user are intentionally preserved to prevent data loss.
+
+## Upgrade Behavior
+
+When upgrading to a new version:
+
+```bash
+sudo apt install ./sensorpajen_2.1.0_all.deb
+```
+
+- ✅ Service is stopped during upgrade
+- ✅ Old files are replaced
+- ✅ Configuration in `/etc/sensorpajen/` is **preserved**
+- ✅ Python dependencies are updated
+- ✅ Service is restarted after upgrade
+- ✅ Example files in `/usr/share/doc/` are updated
+
+## Removal Behavior
+
+### Remove (Keep Config)
+
+```bash
+sudo apt remove sensorpajen
+```
+
+- Service stopped and disabled
+- Application files removed from `/opt/sensorpajen/`
+- Configuration **preserved** in `/etc/sensorpajen/`
+- User **preserved**
+
+### Purge (Still Keeps Config)
+
+```bash
+sudo apt purge sensorpajen
+```
+
+- Same as remove
+- Configuration still **preserved** (by design, for safety)
+- User still **preserved**
+
+### Complete Removal
+
+To completely remove everything:
+
+```bash
+sudo apt purge sensorpajen
+sudo rm -rf /etc/sensorpajen
+sudo userdel sensorpajen
+```
+
+## Troubleshooting
+
+### Build Fails: "debhelper: command not found"
+
+```bash
+sudo apt install debhelper
+```
+
+### Build Fails: "dh_python3: command not found"
+
+```bash
+sudo apt install dh-python
+```
+
+### Lintian Warnings About Permissions
+
+The postinst script runs as root and sets file permissions. This is expected and safe.
+
+### Package Won't Install: Dependency Issues
+
+```bash
+# Fix missing dependencies
+sudo apt install -f
+```
+
+### Service Won't Start After Install
+
+Check if configuration has been edited:
+
+```bash
+sudo journalctl -u sensorpajen -n 50
+```
+
+Common issues:
+- MQTT_HOST still has example value
+- sensors.json is empty
+- Bluetooth adapter not available
+
+### Bluetooth Capability Not Set
+
+```bash
+# Manually set capability
+sudo setcap cap_net_raw,cap_net_admin+eip $(readlink -f /opt/sensorpajen/venv/bin/python3)
+
+# Verify
+getcap $(readlink -f /opt/sensorpajen/venv/bin/python3)
+```
+
+## Development Workflow
+
+### Making Changes
+
+1. Edit source code in `src/sensorpajen/`
+2. Update version in `pyproject.toml`
+3. Update `debian/changelog` with new entry
+4. Rebuild package: `./scripts/verify-deb.sh`
+5. Test on Raspberry Pi
+
+### Version Numbering
+
+- Development: `2.0.0-dev`
+- Release: `2.0.0`
+- Patch: `2.0.1`
+
+Update in both:
+- `pyproject.toml` (line 6: `version = "..."`)
+- `debian/changelog` (first line)
+
+### Testing on Pi
+
+```bash
+# Build
+./scripts/verify-deb.sh
+
+# Copy to Pi
+scp ../sensorpajen_*.deb pi@raspberrypi:~/
+
+# Install on Pi
+ssh pi@raspberrypi
+sudo systemctl stop sensorpajen  # If upgrading
+sudo apt install ./sensorpajen_*.deb
+sudo systemctl status sensorpajen
+```
+
+## Package Metadata
+
+**Package Name**: sensorpajen  
+**Section**: misc  
+**Priority**: optional  
+**Architecture**: all (pure Python)  
+**Maintainer**: Fredrik <fredrik@wahlberg.se>  
+**Depends**: python3 (>= 3.9), python3-venv, python3-pip, bluetooth, bluez, libcap2-bin  
+**Recommends**: mosquitto-clients
+
+## Additional Resources
+
+- **TASKS.md**: Detailed implementation notes
+- **ROADMAP.md**: Phase 8 section for APT package creation
+- **INSTALL.md**: User installation guide
+- **systemd/README.md**: Service management guide
+
+## Support
+
+For issues or questions:
+1. Check `sudo journalctl -u sensorpajen -n 100`
+2. Verify configuration files in `/etc/sensorpajen/`
+3. Check Bluetooth adapter: `hciconfig`
+4. Test MQTT connection: `mosquitto_pub -h <host> -t test -m "test"`
+
+---
+
+**Last Updated**: December 27, 2025  
+**Package Version**: 2.0.0-dev

debian/changelog

@@ -0,0 +1,19 @@
+sensorpajen (2.0.0) stable; urgency=medium
+
+  * Production release v2.0.0
+  * Modernized service architecture with systemd
+  * Automatic sensor discovery and approval workflow
+  * Fixed state directory for discovered_sensors.json
+  * Improved documentation with installation guide
+  * Bytecode cleanup in postinst for clean installs
+
+ -- Fredrik <fredrik@wahlberg.se>  Sun, 28 Dec 2025 10:56:00 +0100
+
+sensorpajen (2.0.0-dev) unstable; urgency=medium
+
+  * Initial Debian package release
+  * Modernized service architecture with systemd
+  * Automatic sensor discovery and approval workflow
+
+ -- Fredrik <fredrik@wahlberg.se>  Sun, 28 Dec 2025 09:00:00 +0100
+

debian/control

@@ -0,0 +1,22 @@
+Source: sensorpajen
+Section: misc
+Priority: optional
+Maintainer: Fredrik <fredrik@wahlberg.se>
+Build-Depends: debhelper-compat (= 13)
+Standards-Version: 4.5.0
+Homepage: https://github.com/yourusername/sensorpajen
+
+Package: sensorpajen
+Architecture: all
+Depends: python3 (>= 3.9), python3-venv, python3-pip, bluetooth, bluez, libcap2-bin, ${misc:Depends}
+Recommends: mosquitto-clients
+Description: Raspberry Pi Bluetooth temperature sensor monitor
+ Monitors Xiaomi Mijia LYWSD03MMC temperature sensors via Bluetooth Low Energy
+ and publishes readings to MQTT broker. Supports ATC firmware with automatic
+ sensor discovery and approval workflow.
+ .
+ Features:
+  - Automatic sensor discovery
+  - MQTT publishing
+  - Systemd service integration
+  - User approval workflow for new sensors

debian/debhelper-build-stamp

@@ -0,0 +1 @@
+sensorpajen

debian/files

@@ -0,0 +1 @@
+sensorpajen_2.0.0-dev_all.deb misc optional

debian/install

@@ -0,0 +1,8 @@
+src/sensorpajen/*.py opt/sensorpajen/src/sensorpajen/
+scripts/approve-sensors.sh opt/sensorpajen/scripts/
+pyproject.toml opt/sensorpajen/
+requirements.txt opt/sensorpajen/
+readme.md usr/share/doc/sensorpajen/
+INSTALL.md usr/share/doc/sensorpajen/
+ROADMAP.md usr/share/doc/sensorpajen/
+config/*.example usr/share/doc/sensorpajen/examples/

debian/postinst

@@ -0,0 +1,151 @@
+#!/bin/bash
+set -e
+
+case "$1" in
+    configure)
+        # Create sensorpajen system user if it doesn't exist
+        if ! getent passwd sensorpajen > /dev/null; then
+            useradd --system --no-create-home --shell /usr/sbin/nologin sensorpajen
+            echo "Created system user: sensorpajen"
+        fi
+
+        # Create config directory with proper permissions
+        mkdir -p /etc/sensorpajen
+        chown sensorpajen:sensorpajen /etc/sensorpajen
+        chmod 750 /etc/sensorpajen
+
+        # Create state directory with proper permissions (writable at runtime)
+        mkdir -p /var/lib/sensorpajen
+        chown sensorpajen:sensorpajen /var/lib/sensorpajen
+        chmod 750 /var/lib/sensorpajen
+
+        # Copy example configs to /etc/sensorpajen if they don't exist
+        for sample in sensorpajen.env.example sensors.json.example; do
+            source_file="/usr/share/doc/sensorpajen/examples/$sample"
+            target_file="/etc/sensorpajen/${sample%.example}"
+            
+            if [ -f "$source_file" ] && [ ! -f "$target_file" ]; then
+                cp "$source_file" "$target_file"
+                chown sensorpajen:sensorpajen "$target_file"
+                
+                # Set restrictive permissions on env file (contains credentials)
+                if [ "$sample" = "sensorpajen.env.example" ]; then
+                    chmod 600 "$target_file"
+                    echo "Created $target_file (edit this file with your MQTT credentials)"
+                else
+                    chmod 640 "$target_file"
+                    echo "Created $target_file"
+                fi
+            fi
+        done
+
+        # Create virtual environment in /opt/sensorpajen
+        cd /opt/sensorpajen
+        if [ ! -d "venv" ]; then
+            echo "Creating Python virtual environment..."
+            python3 -m venv venv
+            venv/bin/pip install --upgrade pip setuptools wheel
+        fi
+
+        # Install Python dependencies from requirements.txt
+        echo "Installing Python dependencies..."
+        if [ -f "/opt/sensorpajen/requirements.txt" ]; then
+            venv/bin/pip install -r /opt/sensorpajen/requirements.txt
+        else
+            echo "Warning: requirements.txt not found, installing bluepy and paho-mqtt directly"
+            venv/bin/pip install bluepy paho-mqtt pybluez
+        fi
+        
+        if [ $? -ne 0 ]; then
+            echo "Error: Failed to install dependencies"
+            exit 1
+        fi
+
+        # Install sensorpajen package itself
+        echo "Installing sensorpajen application..."
+        cd /opt/sensorpajen
+        # Clean up any stale bytecode before building wheel
+        find . -name "*.pyc" -delete
+        find . -name "__pycache__" -type d -delete
+        venv/bin/pip install --no-deps . || {
+            echo "Error: Failed to install sensorpajen package"
+            exit 1
+        }
+        cd /
+
+        # Set ownership of application directory BEFORE setting capabilities
+        chown -R sensorpajen:sensorpajen /opt/sensorpajen
+
+        # Set Bluetooth capabilities on Python executable (after ownership change)
+        PYTHON_PATH=$(readlink -f /opt/sensorpajen/venv/bin/python3)
+        if command -v setcap >/dev/null 2>&1; then
+            setcap cap_net_raw,cap_net_admin+eip "$PYTHON_PATH" || {
+                echo "Warning: setcap failed. You may need to run Bluetooth operations as root."
+                echo "Try: sudo setcap cap_net_raw,cap_net_admin+eip $PYTHON_PATH"
+            }
+        else
+            echo "Warning: setcap not found (install libcap2-bin package)"
+        fi
+
+        # Install systemd service file
+        if [ -f /opt/sensorpajen/debian/sensorpajen.service ]; then
+            cp /opt/sensorpajen/debian/sensorpajen.service /etc/systemd/system/
+        elif [ -f /usr/share/doc/sensorpajen/sensorpajen.service ]; then
+            cp /usr/share/doc/sensorpajen/sensorpajen.service /etc/systemd/system/
+        fi
+
+        # Reload systemd
+        systemctl daemon-reload
+
+        # Enable service (but don't start - needs configuration first)
+        systemctl enable sensorpajen.service || {
+            echo "Warning: Could not enable sensorpajen service"
+        }
+
+        # Check if configuration is ready
+        if [ -f /etc/sensorpajen/sensorpajen.env ] && [ -f /etc/sensorpajen/sensors.json ]; then
+            # Check if env file has been configured (not default values)
+            if grep -q "MQTT_HOST=192.168.0.114" /etc/sensorpajen/sensorpajen.env; then
+                echo ""
+                echo "======================================================================"
+                echo "  Configuration needed!"
+                echo "======================================================================"
+                echo "  Edit /etc/sensorpajen/sensorpajen.env with your MQTT settings"
+                echo "  Edit /etc/sensorpajen/sensors.json with your sensor list"
+                echo "  Then run: sudo systemctl start sensorpajen"
+                echo "======================================================================"
+                echo ""
+            else
+                # Configuration appears to be customized, restart service
+                systemctl restart sensorpajen.service && {
+                    echo "Sensorpajen service started"
+                    echo "View logs: sudo journalctl -u sensorpajen -f"
+                } || {
+                    echo "Failed to start service. Check: sudo systemctl status sensorpajen"
+                }
+            fi
+        else
+            echo ""
+            echo "======================================================================"
+            echo "  Sensorpajen installed successfully!"
+            echo "======================================================================"
+            echo "  Next steps:"
+            echo "    1. Edit /etc/sensorpajen/sensorpajen.env"
+            echo "    2. Edit /etc/sensorpajen/sensors.json"
+            echo "    3. sudo systemctl start sensorpajen"
+            echo "    4. sudo journalctl -u sensorpajen -f"
+            echo "======================================================================"
+            echo ""
+        fi
+        ;;
+
+    abort-upgrade|abort-remove|abort-deconfigure)
+        ;;
+
+    *)
+        echo "postinst called with unknown argument \`$1'" >&2
+        exit 1
+        ;;
+esac
+
+exit 0

debian/postrm

@@ -0,0 +1,41 @@
+#!/bin/bash
+set -e
+
+case "$1" in
+    remove)
+        # Service removed but config and user preserved
+        echo "Sensorpajen removed. Configuration preserved in /etc/sensorpajen/"
+        echo "To remove config: sudo rm -rf /etc/sensorpajen/"
+        
+        # Remove systemd service file
+        rm -f /etc/systemd/system/sensorpajen.service
+        systemctl daemon-reload || true
+        ;;
+
+    purge)
+        # Even on purge, we keep config by default (user can manually delete)
+        # This is safer as it prevents accidental data loss
+        echo "Configuration preserved in /etc/sensorpajen/"
+        echo "To remove config: sudo rm -rf /etc/sensorpajen/"
+        echo "To remove user: sudo userdel sensorpajen"
+        
+        # Remove systemd service file
+        rm -f /etc/systemd/system/sensorpajen.service
+        systemctl daemon-reload || true
+        
+        # Note: We intentionally do NOT remove:
+        # - /etc/sensorpajen (contains user data)
+        # - sensorpajen user (may own other files/processes)
+        # User must remove these manually if desired
+        ;;
+
+    upgrade|failed-upgrade|abort-install|abort-upgrade|disappear)
+        ;;
+
+    *)
+        echo "postrm called with unknown argument \`$1'" >&2
+        exit 1
+        ;;
+esac
+
+exit 0

debian/prerm

@@ -0,0 +1,27 @@
+#!/bin/bash
+set -e
+
+case "$1" in
+    remove|upgrade|deconfigure)
+        # Stop service before removal or upgrade
+        if systemctl is-active --quiet sensorpajen.service 2>/dev/null; then
+            echo "Stopping sensorpajen service..."
+            systemctl stop sensorpajen.service || true
+        fi
+
+        # Disable service on removal (not upgrade)
+        if [ "$1" = "remove" ]; then
+            systemctl disable sensorpajen.service || true
+        fi
+        ;;
+
+    failed-upgrade)
+        ;;
+
+    *)
+        echo "prerm called with unknown argument \`$1'" >&2
+        exit 1
+        ;;
+esac
+
+exit 0

debian/rules

@@ -0,0 +1,20 @@
+#!/usr/bin/make -f
+
+%:
+	dh $@
+
+override_dh_auto_build:
+	# No build step needed for pure Python
+
+override_dh_auto_install:
+	# Installation handled by debian/install file
+	dh_auto_install
+
+override_dh_auto_clean:
+	# Clean build artifacts
+	rm -rf build/ dist/ *.egg-info
+	rm -rf src/*.egg-info
+
+override_dh_builddeb:
+	# Use gzip compression for better compatibility
+	dh_builddeb -- -Zgzip

debian/sensorpajen.debhelper.log

@@ -0,0 +1 @@
+dh_builddeb

debian/sensorpajen.postrm.debhelper

@@ -0,0 +1,12 @@
+# Automatically added by dh_installsystemd/13.14.1ubuntu5
+if [ "$1" = remove ] && [ -d /run/systemd/system ] ; then
+	systemctl --system daemon-reload >/dev/null || true
+fi
+# End automatically added section
+# Automatically added by dh_installsystemd/13.14.1ubuntu5
+if [ "$1" = "purge" ]; then
+	if [ -x "/usr/bin/deb-systemd-helper" ]; then
+		deb-systemd-helper purge 'sensorpajen.service' >/dev/null || true
+	fi
+fi
+# End automatically added section

debian/sensorpajen.service

@@ -0,0 +1,32 @@
+[Unit]
+Description=Sensorpajen - Bluetooth Temperature Sensor Monitor
+Documentation=https://github.com/yourusername/sensorpajen
+After=network.target bluetooth.target
+Wants=bluetooth.target
+
+[Service]
+Type=simple
+User=sensorpajen
+Group=sensorpajen
+WorkingDirectory=/opt/sensorpajen
+EnvironmentFile=/etc/sensorpajen/sensorpajen.env
+ExecStart=/opt/sensorpajen/venv/bin/python -m sensorpajen.main
+Restart=always
+RestartSec=10
+
+# Bluetooth capabilities require this to be false
+NoNewPrivileges=false
+
+# Logging
+StandardOutput=journal
+StandardError=journal
+SyslogIdentifier=sensorpajen
+
+# Security hardening (where possible with Bluetooth requirements)
+PrivateTmp=true
+ProtectSystem=strict
+ProtectHome=true
+ReadWritePaths=/etc/sensorpajen /var/lib/sensorpajen
+
+[Install]
+WantedBy=multi-user.target

debian/sensorpajen.substvars

@@ -0,0 +1,2 @@
+misc:Depends=
+misc:Pre-Depends=

debian/sensorpajen/DEBIAN/control

@@ -0,0 +1,20 @@
+Package: sensorpajen
+Version: 2.0.0-dev
+Architecture: all
+Maintainer: Fredrik <fredrik@wahlberg.se>
+Installed-Size: 112
+Depends: python3 (>= 3.9), python3-venv, python3-pip, bluetooth, bluez, libcap2-bin
+Recommends: mosquitto-clients
+Section: misc
+Priority: optional
+Homepage: https://github.com/yourusername/sensorpajen
+Description: Raspberry Pi Bluetooth temperature sensor monitor
+ Monitors Xiaomi Mijia LYWSD03MMC temperature sensors via Bluetooth Low Energy
+ and publishes readings to MQTT broker. Supports ATC firmware with automatic
+ sensor discovery and approval workflow.
+ .
+ Features:
+  - Automatic sensor discovery
+  - MQTT publishing
+  - Systemd service integration
+  - User approval workflow for new sensors

debian/sensorpajen/DEBIAN/md5sums

@@ -0,0 +1,19 @@
+3b3c15c00bf48fc519b8fbe507a93a7e  opt/sensorpajen/pyproject.toml
+0894789523a53bb372980c0906a7d0b5  opt/sensorpajen/requirements.txt
+940d73f24eb9f971ce27f9355e3072f3  opt/sensorpajen/scripts/approve-sensors.sh
+20eb4f3839b990a530410768897402c0  opt/sensorpajen/src/sensorpajen/__init__.py
+3c6c65213de874065f81b7b3d8948c8b  opt/sensorpajen/src/sensorpajen/approve_sensors.py
+f69225e19918cca05351fa2da8fd7618  opt/sensorpajen/src/sensorpajen/config.py
+65c63383dde4f0b249b708f854ec75a3  opt/sensorpajen/src/sensorpajen/discovery_manager.py
+7604c2bc0a854d6d43ff0f0646386fc5  opt/sensorpajen/src/sensorpajen/main.py
+331bf9b314492acc6ce03896367f3cf6  opt/sensorpajen/src/sensorpajen/mqtt_publisher.py
+5f4ea191e35ce092f39ec0a4f663cb38  opt/sensorpajen/src/sensorpajen/sensor_reader.py
+c8dd8fe8fc174a9cd35251fdf80e7b5f  opt/sensorpajen/src/sensorpajen/utils.py
+b9ad3ea8307d8ed8e938da37ad00f229  usr/lib/systemd/system/sensorpajen.service
+4ddb9618c940286f91df901ec818959a  usr/share/doc/sensorpajen/INSTALL.md.gz
+bd2f1371c60af415bc9d0dbc1111184d  usr/share/doc/sensorpajen/ROADMAP.md.gz
+380e8e6b01b757ceac05bc5805844ae4  usr/share/doc/sensorpajen/changelog.Debian.gz
+14152a98d7cd7fe8daf280aacc4cbf3f  usr/share/doc/sensorpajen/examples/discovered_sensors.json.example
+74c99b732363f93f0a1c134e1a8c3d35  usr/share/doc/sensorpajen/examples/sensorpajen.env.example
+292efbddd951c39cb2c9546d5fac5e05  usr/share/doc/sensorpajen/examples/sensors.json.example
+5f647c63bfc3b174611694779fd215e0  usr/share/doc/sensorpajen/readme.md.gz

debian/sensorpajen/DEBIAN/postinst

@@ -0,0 +1,151 @@
+#!/bin/bash
+set -e
+
+case "$1" in
+    configure)
+        # Create sensorpajen system user if it doesn't exist
+        if ! getent passwd sensorpajen > /dev/null; then
+            useradd --system --no-create-home --shell /usr/sbin/nologin sensorpajen
+            echo "Created system user: sensorpajen"
+        fi
+
+        # Create config directory with proper permissions
+        mkdir -p /etc/sensorpajen
+        chown sensorpajen:sensorpajen /etc/sensorpajen
+        chmod 750 /etc/sensorpajen
+
+        # Create state directory with proper permissions (writable at runtime)
+        mkdir -p /var/lib/sensorpajen
+        chown sensorpajen:sensorpajen /var/lib/sensorpajen
+        chmod 750 /var/lib/sensorpajen
+
+        # Copy example configs to /etc/sensorpajen if they don't exist
+        for sample in sensorpajen.env.example sensors.json.example; do
+            source_file="/usr/share/doc/sensorpajen/examples/$sample"
+            target_file="/etc/sensorpajen/${sample%.example}"
+            
+            if [ -f "$source_file" ] && [ ! -f "$target_file" ]; then
+                cp "$source_file" "$target_file"
+                chown sensorpajen:sensorpajen "$target_file"
+                
+                # Set restrictive permissions on env file (contains credentials)
+                if [ "$sample" = "sensorpajen.env.example" ]; then
+                    chmod 600 "$target_file"
+                    echo "Created $target_file (edit this file with your MQTT credentials)"
+                else
+                    chmod 640 "$target_file"
+                    echo "Created $target_file"
+                fi
+            fi
+        done
+
+        # Create virtual environment in /opt/sensorpajen
+        cd /opt/sensorpajen
+        if [ ! -d "venv" ]; then
+            echo "Creating Python virtual environment..."
+            python3 -m venv venv
+            venv/bin/pip install --upgrade pip setuptools wheel
+        fi
+
+        # Install Python dependencies from requirements.txt
+        echo "Installing Python dependencies..."
+        if [ -f "/opt/sensorpajen/requirements.txt" ]; then
+            venv/bin/pip install -r /opt/sensorpajen/requirements.txt
+        else
+            echo "Warning: requirements.txt not found, installing bluepy and paho-mqtt directly"
+            venv/bin/pip install bluepy paho-mqtt pybluez
+        fi
+        
+        if [ $? -ne 0 ]; then
+            echo "Error: Failed to install dependencies"
+            exit 1
+        fi
+
+        # Install sensorpajen package itself
+        echo "Installing sensorpajen application..."
+        cd /opt/sensorpajen
+        # Clean up any stale bytecode before building wheel
+        find . -name "*.pyc" -delete
+        find . -name "__pycache__" -type d -delete
+        venv/bin/pip install --no-deps . || {
+            echo "Error: Failed to install sensorpajen package"
+            exit 1
+        }
+        cd /
+
+        # Set ownership of application directory BEFORE setting capabilities
+        chown -R sensorpajen:sensorpajen /opt/sensorpajen
+
+        # Set Bluetooth capabilities on Python executable (after ownership change)
+        PYTHON_PATH=$(readlink -f /opt/sensorpajen/venv/bin/python3)
+        if command -v setcap >/dev/null 2>&1; then
+            setcap cap_net_raw,cap_net_admin+eip "$PYTHON_PATH" || {
+                echo "Warning: setcap failed. You may need to run Bluetooth operations as root."
+                echo "Try: sudo setcap cap_net_raw,cap_net_admin+eip $PYTHON_PATH"
+            }
+        else
+            echo "Warning: setcap not found (install libcap2-bin package)"
+        fi
+
+        # Install systemd service file
+        if [ -f /opt/sensorpajen/debian/sensorpajen.service ]; then
+            cp /opt/sensorpajen/debian/sensorpajen.service /etc/systemd/system/
+        elif [ -f /usr/share/doc/sensorpajen/sensorpajen.service ]; then
+            cp /usr/share/doc/sensorpajen/sensorpajen.service /etc/systemd/system/
+        fi
+
+        # Reload systemd
+        systemctl daemon-reload
+
+        # Enable service (but don't start - needs configuration first)
+        systemctl enable sensorpajen.service || {
+            echo "Warning: Could not enable sensorpajen service"
+        }
+
+        # Check if configuration is ready
+        if [ -f /etc/sensorpajen/sensorpajen.env ] && [ -f /etc/sensorpajen/sensors.json ]; then
+            # Check if env file has been configured (not default values)
+            if grep -q "MQTT_HOST=192.168.0.114" /etc/sensorpajen/sensorpajen.env; then
+                echo ""
+                echo "======================================================================"
+                echo "  Configuration needed!"
+                echo "======================================================================"
+                echo "  Edit /etc/sensorpajen/sensorpajen.env with your MQTT settings"
+                echo "  Edit /etc/sensorpajen/sensors.json with your sensor list"
+                echo "  Then run: sudo systemctl start sensorpajen"
+                echo "======================================================================"
+                echo ""
+            else
+                # Configuration appears to be customized, restart service
+                systemctl restart sensorpajen.service && {
+                    echo "Sensorpajen service started"
+                    echo "View logs: sudo journalctl -u sensorpajen -f"
+                } || {
+                    echo "Failed to start service. Check: sudo systemctl status sensorpajen"
+                }
+            fi
+        else
+            echo ""
+            echo "======================================================================"
+            echo "  Sensorpajen installed successfully!"
+            echo "======================================================================"
+            echo "  Next steps:"
+            echo "    1. Edit /etc/sensorpajen/sensorpajen.env"
+            echo "    2. Edit /etc/sensorpajen/sensors.json"
+            echo "    3. sudo systemctl start sensorpajen"
+            echo "    4. sudo journalctl -u sensorpajen -f"
+            echo "======================================================================"
+            echo ""
+        fi
+        ;;
+
+    abort-upgrade|abort-remove|abort-deconfigure)
+        ;;
+
+    *)
+        echo "postinst called with unknown argument \`$1'" >&2
+        exit 1
+        ;;
+esac
+
+exit 0

debian/sensorpajen/DEBIAN/postrm

@@ -0,0 +1,41 @@
+#!/bin/bash
+set -e
+
+case "$1" in
+    remove)
+        # Service removed but config and user preserved
+        echo "Sensorpajen removed. Configuration preserved in /etc/sensorpajen/"
+        echo "To remove config: sudo rm -rf /etc/sensorpajen/"
+        
+        # Remove systemd service file
+        rm -f /etc/systemd/system/sensorpajen.service
+        systemctl daemon-reload || true
+        ;;
+
+    purge)
+        # Even on purge, we keep config by default (user can manually delete)
+        # This is safer as it prevents accidental data loss
+        echo "Configuration preserved in /etc/sensorpajen/"
+        echo "To remove config: sudo rm -rf /etc/sensorpajen/"
+        echo "To remove user: sudo userdel sensorpajen"
+        
+        # Remove systemd service file
+        rm -f /etc/systemd/system/sensorpajen.service
+        systemctl daemon-reload || true
+        
+        # Note: We intentionally do NOT remove:
+        # - /etc/sensorpajen (contains user data)
+        # - sensorpajen user (may own other files/processes)
+        # User must remove these manually if desired
+        ;;
+
+    upgrade|failed-upgrade|abort-install|abort-upgrade|disappear)
+        ;;
+
+    *)
+        echo "postrm called with unknown argument \`$1'" >&2
+        exit 1
+        ;;
+esac
+
+exit 0

debian/sensorpajen/DEBIAN/prerm

@@ -0,0 +1,27 @@
+#!/bin/bash
+set -e
+
+case "$1" in
+    remove|upgrade|deconfigure)
+        # Stop service before removal or upgrade
+        if systemctl is-active --quiet sensorpajen.service 2>/dev/null; then
+            echo "Stopping sensorpajen service..."
+            systemctl stop sensorpajen.service || true
+        fi
+
+        # Disable service on removal (not upgrade)
+        if [ "$1" = "remove" ]; then
+            systemctl disable sensorpajen.service || true
+        fi
+        ;;
+
+    failed-upgrade)
+        ;;
+
+    *)
+        echo "prerm called with unknown argument \`$1'" >&2
+        exit 1
+        ;;
+esac
+
+exit 0

debian/sensorpajen/opt/sensorpajen/pyproject.toml

@@ -0,0 +1,65 @@
+[build-system]
+requires = ["setuptools>=61.0", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "sensorpajen"
+version = "2.0.0-dev"
+description = "Bluetooth temperature sensor monitor for Xiaomi Mijia LYWSD03MMC"
+readme = "README.md"
+requires-python = ">=3.9"
+license = {text = "MIT"}
+authors = [
+    {name = "Fredrik", email = "your@email.com"}
+]
+keywords = ["bluetooth", "temperature", "sensor", "mqtt", "raspberry-pi"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Operating System :: POSIX :: Linux",
+    "Topic :: Home Automation",
+]
+
+dependencies = [
+    "pybluez>=0.31",
+    "bluepy>=1.3.0",
+    "paho-mqtt>=1.6.0",
+]
+
+[project.optional-dependencies]
+dev = [
+    "pytest>=7.0",
+    "pytest-cov>=4.0",
+    "black>=23.0",
+    "ruff>=0.1.0",
+]
+
+[project.urls]
+Homepage = "https://github.com/yourusername/sensorpajen"
+Repository = "https://github.com/yourusername/sensorpajen"
+
+[project.scripts]
+sensorpajen = "sensorpajen.main:main"
+sensorpajen-approve-sensors = "sensorpajen.approve_sensors:main"
+
+[tool.setuptools.packages.find]
+where = ["src"]
+
+[tool.black]
+line-length = 100
+target-version = ["py39", "py310", "py311"]
+
+[tool.ruff]
+line-length = 100
+target-version = "py39"
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]
+python_files = ["test_*.py"]
+python_classes = ["Test*"]
+python_functions = ["test_*"]

debian/sensorpajen/opt/sensorpajen/requirements.txt

@@ -0,0 +1,3 @@
+pybluez
+bluepy
+paho-mqtt

debian/sensorpajen/opt/sensorpajen/scripts/approve-sensors.sh

@@ -0,0 +1,48 @@
+#!/bin/bash
+# Wrapper script for approve-sensors that works in both dev and system mode
+
+# Detect installation type
+if [ -d "/opt/sensorpajen" ]; then
+    # System installation
+    PROJECT_ROOT="/opt/sensorpajen"
+    VENV_PATH="/opt/sensorpajen/venv"
+    
+    # Load config from system location
+    if [ -f "/etc/sensorpajen/sensorpajen.env" ]; then
+        set -a
+        source /etc/sensorpajen/sensorpajen.env
+        set +a
+    else
+        echo "Warning: /etc/sensorpajen/sensorpajen.env not found"
+        # Set minimal defaults
+        export MQTT_HOST="${MQTT_HOST:-localhost}"
+        export MQTT_PORT="${MQTT_PORT:-1883}"
+    fi
+else
+    # Development installation
+    SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+    PROJECT_ROOT="$( cd "$SCRIPT_DIR/.." && pwd )"
+    VENV_PATH="$PROJECT_ROOT/.venv"
+    
+    # Set minimal required environment variables
+    export MQTT_HOST="${MQTT_HOST:-localhost}"
+    export MQTT_PORT="${MQTT_PORT:-1883}"
+
+    # Load actual config if it exists (will override defaults)
+    if [ -f "$PROJECT_ROOT/config/sensorpajen.env" ]; then
+        set -a
+        source "$PROJECT_ROOT/config/sensorpajen.env"
+        set +a
+    fi
+fi
+
+# Activate virtual environment
+if [ -f "$VENV_PATH/bin/activate" ]; then
+    source "$VENV_PATH/bin/activate"
+else
+    echo "Error: Virtual environment not found at $VENV_PATH"
+    exit 1
+fi
+
+# Run the approve-sensors command
+python -m sensorpajen.approve_sensors "$@"

debian/sensorpajen/opt/sensorpajen/src/sensorpajen/__init__.py

@@ -0,0 +1,10 @@
+"""
+Sensorpajen - Bluetooth Temperature Sensor Monitor
+
+Monitors Xiaomi Mijia LYWSD03MMC Bluetooth temperature sensors
+and publishes data to MQTT broker.
+"""
+
+__version__ = "2.0.0-dev"
+__author__ = "Fredrik"
+__license__ = "MIT"

debian/sensorpajen/opt/sensorpajen/src/sensorpajen/approve_sensors.py

@@ -0,0 +1,305 @@
+#!/usr/bin/env python3
+"""
+CLI tool for approving or ignoring discovered sensors.
+
+Interactive tool to manage pending and ignored sensors.
+"""
+
+import sys
+import json
+import logging
+import argparse
+from pathlib import Path
+from typing import List
+
+from . import config
+from .discovery_manager import DiscoveryManager, DiscoveredSensor
+
+logger = logging.getLogger(__name__)
+
+
+def format_metadata_comment(sensor: DiscoveredSensor) -> str:
+    """
+    Format sensor metadata as a comment string.
+    
+    Args:
+        sensor: Discovered sensor
+        
+    Returns:
+        Formatted comment string
+    """
+    return (
+        f"MAC: {sensor.mac}, "
+        f"Name: {sensor.name}, "
+        f"Last seen: {sensor.last_seen}, "
+        f"Temp: {sensor.sample_reading.get('temperature', 'N/A')}°C, "
+        f"Humidity: {sensor.sample_reading.get('humidity', 'N/A')}%, "
+        f"Battery: {sensor.sample_reading.get('battery_percent', 'N/A')}%"
+    )
+
+
+def display_sensor(sensor: DiscoveredSensor, index: int, total: int):
+    """
+    Display sensor information to the user.
+    
+    Args:
+        sensor: Discovered sensor to display
+        index: Current sensor number (1-based)
+        total: Total number of sensors
+    """
+    print(f"\n{'='*70}")
+    print(f"Sensor {index}/{total}")
+    print(f"{'='*70}")
+    print(f"MAC Address:  {sensor.mac}")
+    print(f"Device Name:  {sensor.name}")
+    print(f"Last Seen:    {sensor.last_seen}")
+    print(f"Status:       {sensor.status}")
+    
+    if sensor.status == "ignored" and sensor.ignored_at:
+        print(f"Ignored At:   {sensor.ignored_at}")
+        if sensor.ignore_reason:
+            print(f"Reason:       {sensor.ignore_reason}")
+    
+    # Display sample reading
+    reading = sensor.sample_reading
+    print(f"\nSample Reading:")
+    print(f"  Temperature:  {reading.get('temperature', 'N/A')}°C")
+    print(f"  Humidity:     {reading.get('humidity', 'N/A')}%")
+    print(f"  Battery:      {reading.get('battery_percent', 'N/A')}%")
+    print(f"  Voltage:      {reading.get('battery_voltage', 'N/A')}mV")
+    print(f"{'='*70}")
+
+
+def get_user_choice() -> str:
+    """
+    Get user's choice for what to do with the sensor.
+    
+    Returns:
+        User choice: 'a' (approve), 'i' (ignore), 's' (skip)
+    """
+    while True:
+        choice = input("\n[A]pprove, [I]gnore, [S]kip, [Q]uit? ").strip().lower()
+        if choice in ['a', 'i', 's', 'q']:
+            return choice
+        print("Invalid choice. Please enter A, I, S, or Q.")
+
+
+def approve_sensor(sensor: DiscoveredSensor, manager: DiscoveryManager):
+    """
+    Approve a sensor and add it to sensors.json.
+    
+    Args:
+        sensor: Sensor to approve
+        manager: Discovery manager
+    """
+    # Check if sensor already exists in sensors.json
+    sensor_config_path = Path(config.SENSOR_CONFIG_FILE)
+    
+    try:
+        with open(sensor_config_path, 'r') as f:
+            data = json.load(f)
+        
+        # Check for duplicates
+        for existing_sensor in data.get('sensors', []):
+            if existing_sensor.get('mac', '').upper() == sensor.mac:
+                print(f"\n⚠️  Sensor {sensor.mac} already exists in sensors.json")
+                print("   Renaming must be done manually in the file.")
+                return
+        
+    except FileNotFoundError:
+        # File doesn't exist yet, create with empty sensors list
+        data = {'sensors': []}
+    except json.JSONDecodeError as e:
+        print(f"\n❌ Error: Invalid JSON in {sensor_config_path}: {e}")
+        return
+    
+    # Get sensor name from user
+    while True:
+        name = input("\nEnter sensor name (required): ").strip()
+        if name:
+            break
+        print("Sensor name cannot be empty.")
+    
+    # Pre-fill comment with metadata
+    default_comment = format_metadata_comment(sensor)
+    print(f"\nDefault comment:")
+    print(f"  {default_comment}")
+    
+    edit = input("\nEdit comment? [y/N]: ").strip().lower()
+    if edit == 'y':
+        print("\nEnter comment (or press Enter to keep default):")
+        comment = input("> ").strip()
+        if not comment:
+            comment = default_comment
+    else:
+        comment = default_comment
+    
+    # Add to sensors.json
+    new_sensor = {
+        "mac": sensor.mac,
+        "name": name
+    }
+    
+    if comment:
+        new_sensor["comment"] = comment
+    
+    data.setdefault('sensors', []).append(new_sensor)
+    
+    try:
+        with open(sensor_config_path, 'w') as f:
+            json.dump(data, f, indent=2)
+        
+        print(f"\n✅ Sensor approved and added to sensors.json")
+        print(f"   Name: {name}")
+        print(f"   Configuration will be reloaded automatically within 15 minutes")
+        
+        # Mark as approved in discovery manager and save
+        print(f"\nUpdating discovery status...")
+        manager.approve(sensor.mac)
+        print(f"✅ Marked as approved in discovered_sensors.json")
+        
+    except Exception as e:
+        print(f"\n❌ Error saving to sensors.json: {e}")
+
+
+def ignore_sensor(sensor: DiscoveredSensor, manager: DiscoveryManager):
+    """
+    Ignore a sensor.
+    
+    Args:
+        sensor: Sensor to ignore
+        manager: Discovery manager
+    """
+    reason = input("\nReason for ignoring (optional): ").strip()
+    
+    manager.ignore(sensor.mac, reason if reason else None)
+    
+    print(f"\n✅ Sensor ignored and marked in discovered_sensors.json")
+    if reason:
+        print(f"   Reason: {reason}")
+
+
+def process_sensors(sensors: List[DiscoveredSensor], manager: DiscoveryManager):
+    """
+    Process list of sensors interactively.
+    
+    Args:
+        sensors: List of sensors to process
+        manager: Discovery manager
+    """
+    if not sensors:
+        print("\n✅ No sensors to process")
+        return
+    
+    print(f"\nFound {len(sensors)} sensor(s) to review")
+    
+    for i, sensor in enumerate(sensors, 1):
+        # Mark as reviewed when shown
+        manager.mark_reviewed(sensor.mac)
+        
+        display_sensor(sensor, i, len(sensors))
+        
+        choice = get_user_choice()
+        
+        if choice == 'q':
+            print("\n👋 Exiting...")
+            break
+        elif choice == 'a':
+            approve_sensor(sensor, manager)
+        elif choice == 'i':
+            ignore_sensor(sensor, manager)
+        elif choice == 's':
+            print("\n⏭️  Skipped")
+            continue
+
+
+def main():
+    """Main entry point for approve-sensors CLI."""
+    # Parse command line arguments
+    parser = argparse.ArgumentParser(
+        description="Approve or ignore discovered Bluetooth sensors",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Examples:
+  %(prog)s                    # Show only new pending sensors
+  %(prog)s --all             # Show all pending sensors (including reviewed)
+  %(prog)s --ignored         # Show only ignored sensors
+  %(prog)s --all --ignored   # Show all sensors
+        """
+    )
+    parser.add_argument(
+        '--all', '-a',
+        action='store_true',
+        help='Show all pending sensors, including previously reviewed ones'
+    )
+    parser.add_argument(
+        '--ignored', '-i',
+        action='store_true',
+        help='Show ignored sensors'
+    )
+    
+    args = parser.parse_args()
+    
+    # Setup logging
+    logging.basicConfig(
+        level=logging.WARNING,
+        format='%(levelname)s: %(message)s'
+    )
+    
+    print("=" * 70)
+    print("Sensorpajen - Approve Sensors")
+    print("=" * 70)
+    
+    try:
+        # Load discovery manager
+        manager = DiscoveryManager()
+        
+        # Get sensors based on flags
+        if args.all:
+            pending = manager.get_pending()
+            pending_label = "all pending"
+        else:
+            pending = manager.get_new_pending()
+            pending_label = "new pending"
+        
+        ignored = manager.get_ignored() if args.ignored else []
+        
+        if not pending and not ignored:
+            if args.all or args.ignored:
+                print(f"\n✅ No {pending_label if pending else 'ignored'} sensors found")
+            else:
+                print("\n✅ No new sensors to review")
+                all_pending = manager.get_pending()
+                if all_pending:
+                    print(f"\nThere are {len(all_pending)} previously reviewed pending sensor(s).")
+                    print("Run with --all to review them again.")
+            return 0
+        
+        # Process pending sensors
+        if pending:
+            print(f"\n📋 Processing {len(pending)} {pending_label} sensor(s)...")
+            process_sensors(pending, manager)
+        
+        # Process ignored sensors if requested
+        if ignored:
+            if pending:
+                print("\n" + "=" * 70)
+            print(f"\n📋 Processing {len(ignored)} ignored sensor(s)...")
+            process_sensors(ignored, manager)
+        
+        print("\n" + "=" * 70)
+        print("Done!")
+        print("=" * 70)
+        
+        return 0
+        
+    except KeyboardInterrupt:
+        print("\n\n👋 Interrupted by user")
+        return 1
+    except Exception as e:
+        logger.error(f"Error: {e}", exc_info=True)
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

debian/sensorpajen/opt/sensorpajen/src/sensorpajen/config.py

@@ -0,0 +1,160 @@
+"""
+Configuration management for Sensorpajen.
+
+Loads configuration from environment variables with sensible defaults.
+Configuration files are loaded relative to the project root.
+"""
+
+import os
+import json
+import logging
+from pathlib import Path
+from typing import Dict, List
+
+logger = logging.getLogger(__name__)
+
+# Determine project root and config directory
+# Check if running from system installation (/opt/sensorpajen) or development
+_opt_sensorpajen_exists = Path('/opt/sensorpajen').exists()
+_var_lib_exists = Path('/var/lib/sensorpajen').exists()
+
+if _opt_sensorpajen_exists:
+    # System installation
+    PROJECT_ROOT = Path('/opt/sensorpajen')
+    CONFIG_DIR = Path('/etc/sensorpajen')
+    STATE_DIR = Path('/var/lib/sensorpajen')
+else:
+    # Development installation (3 levels up from this file: src/sensorpajen/config.py)
+    PROJECT_ROOT = Path(__file__).parent.parent.parent
+    CONFIG_DIR = PROJECT_ROOT / "config"
+    STATE_DIR = CONFIG_DIR
+
+# MQTT Configuration from environment
+MQTT_HOST = os.environ.get("MQTT_HOST")
+MQTT_PORT = int(os.environ.get("MQTT_PORT", "1883"))
+MQTT_USER = os.environ.get("MQTT_USER")
+MQTT_PASSWORD = os.environ.get("MQTT_PASSWORD")
+MQTT_CLIENT_ID = os.environ.get("MQTT_CLIENT_ID", "sensorpajen")
+MQTT_TOPIC_PREFIX = os.environ.get("MQTT_TOPIC_PREFIX", "MiTemperature2")
+
+# Validate required MQTT configuration
+if not MQTT_HOST:
+    raise RuntimeError(
+        "MQTT_HOST environment variable must be set. "
+        "Please configure config/sensorpajen.env"
+    )
+
+# Sensor configuration file
+SENSOR_CONFIG_FILE = os.environ.get(
+    "SENSOR_CONFIG_FILE",
+    str(CONFIG_DIR / "sensors.json")
+)
+
+# Application settings
+WATCHDOG_TIMEOUT = int(os.environ.get("WATCHDOG_TIMEOUT", "5"))
+ENABLE_BATTERY = os.environ.get("ENABLE_BATTERY", "true").lower() == "true"
+LOG_LEVEL = os.environ.get("LOG_LEVEL", "INFO").upper()
+
+# Bluetooth settings
+SKIP_IDENTICAL = int(os.environ.get("SKIP_IDENTICAL", "50"))
+DEBOUNCE = os.environ.get("DEBOUNCE", "true").lower() == "true"
+
+# ntfy notification settings (optional)
+NTFY_ENABLED = os.environ.get("NTFY_ENABLED", "false").lower() == "true"
+NTFY_URL = os.environ.get("NTFY_URL", "https://ntfy.sh")
+NTFY_TOPIC = os.environ.get("NTFY_TOPIC", "sensorpajen")
+NTFY_TOKEN = os.environ.get("NTFY_TOKEN", "")
+
+# Discovery settings
+DISCOVERED_SENSORS_FILE = os.environ.get(
+    "DISCOVERED_SENSORS_FILE",
+    str(STATE_DIR / "discovered_sensors.json")
+)
+CONFIG_RELOAD_INTERVAL = int(os.environ.get("CONFIG_RELOAD_INTERVAL", "900"))  # 15 minutes
+
+
+class SensorConfig:
+    """Manages sensor configuration from JSON file."""
+    
+    def __init__(self, config_file: str = SENSOR_CONFIG_FILE):
+        """
+        Initialize sensor configuration.
+        
+        Args:
+            config_file: Path to sensors JSON configuration file
+        """
+        self.config_file = Path(config_file)
+        self.sensors: Dict[str, str] = {}
+        self.load()
+    
+    def load(self):
+        """Load sensor configuration from JSON file."""
+        if not self.config_file.exists():
+            logger.warning(
+                f"Sensor configuration file not found: {self.config_file}\n"
+                f"Starting with no sensors - use discovery to add sensors"
+            )
+            return
+        
+        try:
+            with open(self.config_file, 'r') as f:
+                data = json.load(f)
+            
+            # Convert sensors list to MAC -> name mapping
+            for sensor in data.get('sensors', []):
+                mac = sensor.get('mac', '').upper()
+                name = sensor.get('name')
+                
+                if mac and name:
+                    self.sensors[mac] = name
+                    logger.debug(f"Loaded sensor: {mac} -> {name}")
+            
+            logger.info(f"Loaded {len(self.sensors)} sensors from {self.config_file}")
+            
+        except json.JSONDecodeError as e:
+            raise RuntimeError(f"Invalid JSON in {self.config_file}: {e}")
+        except Exception as e:
+            raise RuntimeError(f"Error loading sensor config: {e}")
+    
+    def get_name(self, mac: str) -> str:
+        """
+        Get sensor name by MAC address.
+        
+        Args:
+            mac: MAC address (any case)
+            
+        Returns:
+            Sensor name or the MAC address if not found
+        """
+        return self.sensors.get(mac.upper(), mac)
+    
+    def get_all_macs(self) -> List[str]:
+        """Get list of all configured MAC addresses."""
+        return list(self.sensors.keys())
+
+
+def validate_config():
+    """
+    Validate configuration and log settings.
+    Should be called at application startup.
+    """
+    install_type = "System" if Path('/opt/sensorpajen').exists() else "Development"
+    logger.info("=== Sensorpajen Configuration ===")
+    logger.info(f"Installation Type: {install_type}")
+    logger.info(f"Project Root: {PROJECT_ROOT}")
+    logger.info(f"Config Directory: {CONFIG_DIR}")
+    logger.info(f"State Directory: {STATE_DIR}")
+    logger.info(f"MQTT Host: {MQTT_HOST}:{MQTT_PORT}")
+    logger.info(f"MQTT User: {MQTT_USER}")
+    logger.info(f"MQTT Client ID: {MQTT_CLIENT_ID}")
+    logger.info(f"MQTT Topic Prefix: {MQTT_TOPIC_PREFIX}")
+    logger.info(f"Sensor Config: {SENSOR_CONFIG_FILE}")
+    logger.info(f"Discovered Sensors: {DISCOVERED_SENSORS_FILE}")
+    logger.info(f"Watchdog Timeout: {WATCHDOG_TIMEOUT}s")
+    logger.info(f"Battery Monitoring: {ENABLE_BATTERY}")
+    logger.info(f"Config Reload Interval: {CONFIG_RELOAD_INTERVAL}s")
+    logger.info(f"ntfy Enabled: {NTFY_ENABLED}")
+    if NTFY_ENABLED:
+        logger.info(f"ntfy URL: {NTFY_URL}/{NTFY_TOPIC}")
+    logger.info(f"Log Level: {LOG_LEVEL}")
+    logger.info("================================")

debian/sensorpajen/opt/sensorpajen/src/sensorpajen/discovery_manager.py

@@ -0,0 +1,263 @@
+"""
+Discovery manager for tracking and managing discovered sensors.
+
+Maintains a database of discovered sensors with their metadata and status.
+"""
+
+import json
+import logging
+import subprocess
+from datetime import datetime
+from pathlib import Path
+from typing import Dict, List, Optional
+from dataclasses import dataclass, asdict
+
+from . import config
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class DiscoveredSensor:
+    """Represents a discovered sensor with metadata."""
+    mac: str
+    name: str
+    rssi: int
+    first_seen: str
+    last_seen: str
+    sample_reading: Dict[str, float]
+    status: str = "pending"  # pending, approved, ignored
+    reviewed: bool = False  # Has been shown in approval CLI
+    ignored_at: Optional[str] = None
+    ignore_reason: Optional[str] = None
+
+
+class DiscoveryManager:
+    """Manages discovered sensors and their approval status."""
+    
+    def __init__(self, discovery_file: str = config.DISCOVERED_SENSORS_FILE):
+        """
+        Initialize discovery manager.
+        
+        Args:
+            discovery_file: Path to discovered sensors JSON file
+        """
+        self.discovery_file = Path(discovery_file)
+        self.sensors: Dict[str, DiscoveredSensor] = {}
+        self.load()
+    
+    def load(self):
+        """Load discovered sensors from JSON file."""
+        if not self.discovery_file.exists():
+            logger.info(f"Creating new discovered sensors file: {self.discovery_file}")
+            self.discovery_file.parent.mkdir(parents=True, exist_ok=True)
+            self.save()
+            return
+        
+        try:
+            with open(self.discovery_file, 'r') as f:
+                data = json.load(f)
+            
+            for sensor_data in data:
+                sensor = DiscoveredSensor(**sensor_data)
+                self.sensors[sensor.mac.upper()] = sensor
+            
+            logger.info(f"Loaded {len(self.sensors)} discovered sensors")
+            
+        except json.JSONDecodeError as e:
+            logger.error(f"Invalid JSON in {self.discovery_file}: {e}")
+        except Exception as e:
+            logger.error(f"Error loading discovered sensors: {e}")
+    
+    def save(self):
+        """Save discovered sensors to JSON file."""
+        try:
+            # Ensure directory exists
+            self.discovery_file.parent.mkdir(parents=True, exist_ok=True)
+            
+            # Convert sensors to list of dicts
+            data = [asdict(sensor) for sensor in self.sensors.values()]
+            
+            with open(self.discovery_file, 'w') as f:
+                json.dump(data, f, indent=2)
+            
+            logger.debug(f"Saved {len(self.sensors)} discovered sensors")
+            
+        except Exception as e:
+            logger.error(f"Error saving discovered sensors: {e}")
+    
+    def add_or_update(self, mac: str, name: str, rssi: int, 
+                     temperature: float, humidity: float, 
+                     battery_percent: int, battery_voltage: int) -> bool:
+        """
+        Add or update a discovered sensor.
+        
+        Args:
+            mac: MAC address
+            name: Advertised device name
+            rssi: Signal strength
+            temperature: Temperature reading
+            humidity: Humidity reading
+            battery_percent: Battery percentage
+            battery_voltage: Battery voltage in mV
+            
+        Returns:
+            True if this is a newly discovered sensor, False if updated existing
+        """
+        mac = mac.upper()
+        now = datetime.now().isoformat()
+        
+        sample_reading = {
+            "temperature": temperature,
+            "humidity": humidity,
+            "battery_percent": battery_percent,
+            "battery_voltage": battery_voltage
+        }
+        
+        if mac in self.sensors:
+            # Update existing sensor
+            sensor = self.sensors[mac]
+            sensor.last_seen = now
+            sensor.rssi = rssi
+            sensor.sample_reading = sample_reading
+            self.save()
+            return False
+        else:
+            # New sensor discovered
+            sensor = DiscoveredSensor(
+                mac=mac,
+                name=name,
+                rssi=rssi,
+                first_seen=now,
+                last_seen=now,
+                sample_reading=sample_reading,
+                status="pending"
+            )
+            self.sensors[mac] = sensor
+            self.save()
+            logger.info(f"New sensor discovered: {mac} ({name})")
+            return True
+    
+    def is_known(self, mac: str) -> bool:
+        """
+        Check if a sensor has been discovered before.
+        
+        Args:
+            mac: MAC address
+            
+        Returns:
+            True if sensor is in discovered list
+        """
+        return mac.upper() in self.sensors
+    
+    def get_status(self, mac: str) -> Optional[str]:
+        """
+        Get status of a discovered sensor.
+        
+        Args:
+            mac: MAC address
+            
+        Returns:
+            Status string or None if not found
+        """
+        sensor = self.sensors.get(mac.upper())
+        return sensor.status if sensor else None
+    
+    def approve(self, mac: str):
+        """
+        Mark a sensor as approved.
+        
+        Args:
+            mac: MAC address
+        """
+        mac = mac.upper()
+        if mac in self.sensors:
+            self.sensors[mac].status = "approved"
+            self.save()
+            logger.info(f"Sensor approved: {mac}")
+    
+    def ignore(self, mac: str, reason: Optional[str] = None):
+        """
+        Mark a sensor as ignored.
+        
+        Args:
+            mac: MAC address
+            reason: Optional reason for ignoring
+        """
+        mac = mac.upper()
+        if mac in self.sensors:
+            self.sensors[mac].status = "ignored"
+            self.sensors[mac].ignored_at = datetime.now().isoformat()
+            self.sensors[mac].ignore_reason = reason
+            self.save()
+            logger.info(f"Sensor ignored: {mac}")
+    
+    def get_pending(self) -> List[DiscoveredSensor]:
+        """Get list of sensors with status 'pending'."""
+        return [s for s in self.sensors.values() if s.status == "pending"]
+    
+    def get_new_pending(self) -> List[DiscoveredSensor]:
+        """Get list of pending sensors that haven't been reviewed yet."""
+        return [s for s in self.sensors.values() if s.status == "pending" and not s.reviewed]
+    
+    def get_ignored(self) -> List[DiscoveredSensor]:
+        """Get list of sensors with status 'ignored'."""
+        return [s for s in self.sensors.values() if s.status == "ignored"]
+    
+    def mark_reviewed(self, mac: str):
+        """
+        Mark a sensor as reviewed (shown in approval CLI).
+        
+        Args:
+            mac: MAC address
+        """
+        mac = mac.upper()
+        if mac in self.sensors:
+            self.sensors[mac].reviewed = True
+            self.save()
+    
+    def send_ntfy_notification(self, sensor: DiscoveredSensor):
+        """
+        Send ntfy notification for a newly discovered sensor.
+        
+        Args:
+            sensor: Discovered sensor to notify about
+        """
+        if not config.NTFY_ENABLED:
+            logger.debug("ntfy notifications disabled")
+            return
+        
+        if not config.NTFY_TOKEN:
+            logger.warning("ntfy enabled but NTFY_TOKEN not set")
+            return
+        
+        try:
+            message = (
+                f"🆕 New sensor discovered!\n\n"
+                f"MAC: {sensor.mac}\n"
+                f"Name: {sensor.name}\n"
+                f"Last seen: {sensor.last_seen}\n"
+                f"Temp: {sensor.sample_reading.get('temperature', 'N/A')}°C\n"
+                f"Humidity: {sensor.sample_reading.get('humidity', 'N/A')}%\n"
+                f"Battery: {sensor.sample_reading.get('battery_percent', 'N/A')}%\n\n"
+                f"Run 'sensorpajen approve-sensors' to approve or ignore."
+            )
+            
+            url = f"{config.NTFY_URL}/{config.NTFY_TOPIC}"
+            
+            result = subprocess.run(
+                ["curl", "-H", f"Authorization: Bearer {config.NTFY_TOKEN}",
+                 "-d", message, url],
+                capture_output=True,
+                timeout=10
+            )
+            
+            if result.returncode == 0:
+                logger.info(f"Sent ntfy notification for {sensor.mac}")
+            else:
+                logger.warning(f"ntfy notification failed: {result.stderr.decode()}")
+                
+        except subprocess.TimeoutExpired:
+            logger.warning("ntfy notification timed out")
+        except Exception as e:
+            logger.error(f"Error sending ntfy notification: {e}")

debian/sensorpajen/opt/sensorpajen/src/sensorpajen/main.py

@@ -0,0 +1,226 @@
+#!/usr/bin/env python3
+"""
+Sensorpajen - Main entry point
+
+Bluetooth temperature sensor monitor for Xiaomi Mijia LYWSD03MMC sensors.
+Publishes sensor data to MQTT broker.
+"""
+
+import sys
+import signal
+import logging
+import time
+import threading
+from pathlib import Path
+
+from . import __version__
+from . import config
+from .mqtt_publisher import MQTTPublisher
+from .sensor_reader import SensorReader, Measurement
+from .discovery_manager import DiscoveryManager
+
+
+class Sensorpajen:
+    """Main application class."""
+    
+    def __init__(self):
+        """Initialize the application."""
+        self.mqtt_publisher: MQTTPublisher = None
+        self.sensor_reader: SensorReader = None
+        self.sensor_config: config.SensorConfig = None
+        self.discovery_manager: DiscoveryManager = None
+        self.running = False
+        self.config_reload_timer: threading.Timer = None
+        
+        # Setup logging
+        self._setup_logging()
+        
+        # Setup signal handlers
+        signal.signal(signal.SIGTERM, self._signal_handler)
+        signal.signal(signal.SIGINT, self._signal_handler)
+    
+    def _setup_logging(self):
+        """Configure logging to stdout for journald."""
+        log_level = getattr(logging, config.LOG_LEVEL, logging.INFO)
+        
+        logging.basicConfig(
+            level=log_level,
+            format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+            stream=sys.stdout
+        )
+        
+        # Set our logger
+        self.logger = logging.getLogger(__name__)
+    
+    def _signal_handler(self, sig, frame):
+        """Handle shutdown signals."""
+        signal_name = "SIGTERM" if sig == signal.SIGTERM else "SIGINT"
+        self.logger.info(f"Received {signal_name}, shutting down gracefully...")
+        self.shutdown()
+        sys.exit(0)
+    
+    def _on_measurement(self, measurement: Measurement):
+        """
+        Callback for new sensor measurements.
+        
+        Args:
+            measurement: Sensor measurement data
+        """
+        try:
+            # Publish to MQTT
+            self.mqtt_publisher.publish_measurement(
+                sensor_name=measurement.sensor_name,
+                temperature=measurement.temperature,
+                humidity=measurement.humidity,
+                battery_voltage=measurement.voltage,
+                battery_level=measurement.battery
+            )
+        except Exception as e:
+            self.logger.error(f"Error handling measurement: {e}")
+    
+    def _reload_config(self):
+        """Reload sensor configuration periodically."""
+        if not self.running:
+            return
+        
+        try:
+            self.logger.info("Reloading sensor configuration...")
+            old_sensors = set(self.sensor_config.sensors.keys())
+            self.sensor_config.load()
+            new_sensors = set(self.sensor_config.sensors.keys())
+            
+            added = new_sensors - old_sensors
+            removed = old_sensors - new_sensors
+            
+            if added:
+                self.logger.info(f"Added sensors: {', '.join(added)}")
+            if removed:
+                self.logger.info(f"Removed sensors: {', '.join(removed)}")
+            if not added and not removed:
+                self.logger.debug("No sensor configuration changes")
+                
+        except Exception as e:
+            self.logger.error(f"Error reloading configuration: {e}")
+        finally:
+            # Schedule next reload
+            if self.running:
+                self.config_reload_timer = threading.Timer(
+                    config.CONFIG_RELOAD_INTERVAL,
+                    self._reload_config
+                )
+                self.config_reload_timer.daemon = True
+                self.config_reload_timer.start()
+    
+    def start(self):
+        """Start the application."""
+        try:
+            self.logger.info("=" * 50)
+            self.logger.info(f"Starting Sensorpajen v{__version__}")
+            self.logger.info("=" * 50)
+            
+            # Validate and log configuration
+            config.validate_config()
+            
+            # Load sensor configuration
+            self.sensor_config = config.SensorConfig()
+            
+            if len(self.sensor_config.sensors) == 0:
+                self.logger.warning("No sensors configured")
+                self.logger.warning("Starting in discovery-only mode")
+                self.logger.warning("Use 'sensorpajen approve-sensors' to add sensors")
+            
+            # Initialize discovery manager
+            self.logger.info("Initializing discovery manager...")
+            self.discovery_manager = DiscoveryManager()
+            
+            # Initialize MQTT publisher
+            self.logger.info("Initializing MQTT publisher...")
+            self.mqtt_publisher = MQTTPublisher()
+            self.mqtt_publisher.connect()
+            
+            # Wait a moment for MQTT connection
+            time.sleep(1)
+            
+            if not self.mqtt_publisher.is_connected():
+                self.logger.warning("MQTT connection not established yet, continuing anyway...")
+            
+            # Initialize sensor reader
+            self.logger.info("Initializing Bluetooth sensor reader...")
+            self.sensor_reader = SensorReader(
+                sensor_config=self.sensor_config,
+                discovery_manager=self.discovery_manager,
+                on_measurement=self._on_measurement,
+                interface=0  # hci0
+            )
+            
+            # Start config reload timer
+            self.config_reload_timer = threading.Timer(
+                config.CONFIG_RELOAD_INTERVAL,
+                self._reload_config
+            )
+            self.config_reload_timer.daemon = True
+            self.config_reload_timer.start()
+            self.logger.info(f"Config reload scheduled every {config.CONFIG_RELOAD_INTERVAL}s")
+            
+            # Start reading sensors (blocking call)
+            self.logger.info("=" * 50)
+            self.logger.info("Sensorpajen is now running")
+            self.logger.info("Monitoring sensors via Bluetooth...")
+            self.logger.info("Publishing to MQTT...")
+            self.logger.info("Press Ctrl+C to stop")
+            self.logger.info("=" * 50)
+            
+            self.running = True
+            self.sensor_reader.start()
+            
+        except FileNotFoundError as e:
+            self.logger.error(f"Configuration error: {e}")
+            sys.exit(1)
+        except RuntimeError as e:
+            self.logger.error(f"Configuration error: {e}")
+            sys.exit(1)
+        except Exception as e:
+            self.logger.error(f"Failed to start application: {e}", exc_info=True)
+            self.shutdown()
+            sys.exit(1)
+    
+    def shutdown(self):
+        """Shutdown the application gracefully."""
+        if not self.running:
+            return
+        
+        self.running = False
+        self.logger.info("Shutting down...")
+        
+        # Cancel config reload timer
+        if self.config_reload_timer:
+            try:
+                self.config_reload_timer.cancel()
+            except Exception as e:
+                self.logger.error(f"Error canceling reload timer: {e}")
+        
+        # Stop sensor reader
+        if self.sensor_reader:
+            try:
+                self.sensor_reader.stop()
+            except Exception as e:
+                self.logger.error(f"Error stopping sensor reader: {e}")
+        
+        # Disconnect MQTT
+        if self.mqtt_publisher:
+            try:
+                self.mqtt_publisher.disconnect()
+            except Exception as e:
+                self.logger.error(f"Error disconnecting MQTT: {e}")
+        
+        self.logger.info("Shutdown complete")
+
+
+def main():
+    """Main entry point."""
+    app = Sensorpajen()
+    app.start()
+
+
+if __name__ == "__main__":
+    main()

debian/sensorpajen/opt/sensorpajen/src/sensorpajen/mqtt_publisher.py

@@ -0,0 +1,131 @@
+"""
+MQTT Publisher for sensor data.
+
+Handles connection to MQTT broker and publishing of sensor measurements.
+"""
+
+import logging
+import paho.mqtt.client as mqtt
+from typing import Optional
+from . import config
+
+logger = logging.getLogger(__name__)
+
+
+class MQTTPublisher:
+    """Manages MQTT connection and publishing of sensor data."""
+    
+    def __init__(self):
+        """Initialize MQTT publisher with configuration."""
+        self.client: Optional[mqtt.Client] = None
+        self.connected = False
+        self._setup_client()
+    
+    def _setup_client(self):
+        """Setup MQTT client with callbacks."""
+        # Handle both paho-mqtt v1.x and v2.x
+        try:
+            # Try v2.x format (with callback_api_version)
+            self.client = mqtt.Client(
+                callback_api_version=mqtt.CallbackAPIVersion.VERSION1,
+                client_id=config.MQTT_CLIENT_ID
+            )
+        except (TypeError, AttributeError):
+            # Fall back to v1.x format
+            self.client = mqtt.Client(config.MQTT_CLIENT_ID)
+        
+        # Set credentials if provided
+        if config.MQTT_USER and config.MQTT_PASSWORD:
+            self.client.username_pw_set(config.MQTT_USER, config.MQTT_PASSWORD)
+        
+        # Setup callbacks
+        self.client.on_connect = self._on_connect
+        self.client.on_disconnect = self._on_disconnect
+        self.client.on_publish = self._on_publish
+        
+        logger.info(f"MQTT client configured for {config.MQTT_HOST}:{config.MQTT_PORT}")
+    
+    def _on_connect(self, client, userdata, flags, rc):
+        """Callback for when client connects to broker."""
+        if rc == 0:
+            self.connected = True
+            logger.info(f"Connected to MQTT broker at {config.MQTT_HOST}:{config.MQTT_PORT}")
+        else:
+            self.connected = False
+            logger.error(f"Failed to connect to MQTT broker. Return code: {rc}")
+    
+    def _on_disconnect(self, client, userdata, rc):
+        """Callback for when client disconnects from broker."""
+        self.connected = False
+        if rc != 0:
+            logger.warning(f"Unexpected disconnection from MQTT broker. Return code: {rc}")
+        else:
+            logger.info("Disconnected from MQTT broker")
+    
+    def _on_publish(self, client, userdata, mid):
+        """Callback for when message is published."""
+        logger.debug(f"Message published: {mid}")
+    
+    def connect(self):
+        """Connect to MQTT broker."""
+        try:
+            logger.info(f"Connecting to MQTT broker at {config.MQTT_HOST}:{config.MQTT_PORT}")
+            self.client.connect(config.MQTT_HOST, config.MQTT_PORT, keepalive=60)
+            self.client.loop_start()  # Start network loop in background thread
+        except Exception as e:
+            logger.error(f"Failed to connect to MQTT broker: {e}")
+            raise
+    
+    def disconnect(self):
+        """Disconnect from MQTT broker."""
+        if self.client:
+            self.client.loop_stop()
+            self.client.disconnect()
+            logger.info("Disconnected from MQTT broker")
+    
+    def publish_measurement(self, sensor_name: str, temperature: float, 
+                          humidity: int, battery_voltage: float = None, 
+                          battery_level: int = None):
+        """
+        Publish sensor measurement to MQTT.
+        
+        Args:
+            sensor_name: Name of the sensor
+            temperature: Temperature in Celsius
+            humidity: Humidity percentage
+            battery_voltage: Battery voltage (optional)
+            battery_level: Battery level percentage (optional)
+        """
+        if not self.connected:
+            logger.warning("Not connected to MQTT broker, skipping publish")
+            return
+        
+        topic_prefix = f"{config.MQTT_TOPIC_PREFIX}/{sensor_name}"
+        
+        try:
+            # Publish temperature
+            self.client.publish(f"{topic_prefix}/temp", f"{temperature:.1f}")
+            logger.debug(f"{sensor_name}: temp={temperature:.1f}°C")
+            
+            # Publish humidity
+            self.client.publish(f"{topic_prefix}/humidity", f"{humidity}")
+            logger.debug(f"{sensor_name}: humidity={humidity}%")
+            
+            # Publish battery info if enabled and available
+            if config.ENABLE_BATTERY:
+                if battery_voltage is not None:
+                    self.client.publish(f"{topic_prefix}/batteryvoltage", f"{battery_voltage:.3f}")
+                    logger.debug(f"{sensor_name}: battery_voltage={battery_voltage:.3f}V")
+                
+                if battery_level is not None:
+                    self.client.publish(f"{topic_prefix}/batterylevel", f"{battery_level}")
+                    logger.debug(f"{sensor_name}: battery_level={battery_level}%")
+            
+            logger.info(f"Published: {sensor_name} - {temperature:.1f}°C, {humidity}%")
+            
+        except Exception as e:
+            logger.error(f"Error publishing to MQTT: {e}")
+    
+    def is_connected(self) -> bool:
+        """Check if connected to MQTT broker."""
+        return self.connected

debian/sensorpajen/opt/sensorpajen/src/sensorpajen/sensor_reader.py

@@ -0,0 +1,292 @@
+"""
+Bluetooth sensor reader for Xiaomi Mijia LYWSD03MMC sensors with ATC firmware.
+
+Reads temperature, humidity, and battery data from BLE advertisements.
+"""
+
+import logging
+import time
+import threading
+import bluetooth._bluetooth as bluez
+from dataclasses import dataclass
+from typing import Optional, Callable, Dict
+
+from . import config
+from .utils import (enable_le_scan, disable_le_scan, 
+                   parse_le_advertising_events, raw_packet_to_str, toggle_device)
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class Measurement:
+    """Sensor measurement data."""
+    temperature: float
+    humidity: int
+    voltage: float
+    battery: int = 0
+    rssi: int = 0
+    sensor_name: str = ""
+    timestamp: int = 0
+
+
+class SensorReader:
+    """Reads Xiaomi LYWSD03MMC sensors with ATC firmware via BLE."""
+    
+    def __init__(self, sensor_config: config.SensorConfig,
+                 discovery_manager,
+                 on_measurement: Callable[[Measurement], None],
+                 interface: int = 0):
+        """
+        Initialize sensor reader.
+        
+        Args:
+            sensor_config: Sensor configuration mapping
+            discovery_manager: Discovery manager for tracking new sensors
+            on_measurement: Callback function for new measurements
+            interface: Bluetooth interface number (default 0 for hci0)
+        """
+        self.sensor_config = sensor_config
+        self.discovery_manager = discovery_manager
+        self.on_measurement = on_measurement
+        self.interface = interface
+        self.sock: Optional[int] = None
+        self.running = False
+        self.last_ble_packet = time.time()
+        self.adv_counter: Dict[str, str] = {}  # Track advertisement numbers to avoid duplicates
+        self.watchdog_thread: Optional[threading.Thread] = None
+        
+    def start(self):
+        """Start BLE scanning for sensors."""
+        try:
+            logger.info(f"Starting BLE scan on hci{self.interface}")
+            
+            # Enable bluetooth device
+            toggle_device(self.interface, True)
+            
+            # Open bluetooth socket
+            try:
+                self.sock = bluez.hci_open_dev(self.interface)
+            except Exception as e:
+                logger.error(f"Cannot open bluetooth device hci{self.interface}: {e}")
+                raise
+            
+            # Enable LE scanning without filtering duplicates
+            enable_le_scan(self.sock, filter_duplicates=False)
+            
+            # Start watchdog if configured
+            if config.WATCHDOG_TIMEOUT > 0:
+                self.running = True
+                self.watchdog_thread = threading.Thread(target=self._watchdog_loop, daemon=True)
+                self.watchdog_thread.start()
+                logger.info(f"Watchdog started with {config.WATCHDOG_TIMEOUT}s timeout")
+            
+            logger.info("BLE scanning enabled")
+            logger.info(f"Monitoring {len(self.sensor_config.sensors)} sensors")
+            
+            # Start parsing advertisements (blocking call)
+            parse_le_advertising_events(
+                self.sock,
+                handler=self._handle_ble_packet,
+                debug=False
+            )
+            
+        except KeyboardInterrupt:
+            logger.info("Received keyboard interrupt")
+            self.stop()
+        except Exception as e:
+            logger.error(f"Error in sensor reader: {e}")
+            self.stop()
+            raise
+    
+    def stop(self):
+        """Stop BLE scanning."""
+        self.running = False
+        
+        if self.sock:
+            try:
+                disable_le_scan(self.sock)
+                logger.info("BLE scanning disabled")
+            except Exception as e:
+                logger.error(f"Error disabling BLE scan: {e}")
+        
+        if self.watchdog_thread and self.watchdog_thread.is_alive():
+            self.watchdog_thread.join(timeout=2)
+    
+    def _watchdog_loop(self):
+        """Watchdog thread to restart BLE scanning if no packets received."""
+        restart_counter = 1
+        
+        while self.running:
+            time.sleep(1)
+            now = time.time()
+            elapsed = now - self.last_ble_packet
+            
+            if elapsed > config.WATCHDOG_TIMEOUT:
+                logger.warning(
+                    f"Watchdog: No BLE packet within {int(elapsed)}s. "
+                    f"Restarting BLE scan (count: {restart_counter})"
+                )
+                try:
+                    disable_le_scan(self.sock)
+                    time.sleep(1)
+                    enable_le_scan(self.sock, filter_duplicates=False)
+                    restart_counter += 1
+                    self.last_ble_packet = now  # Reset timer
+                except Exception as e:
+                    logger.error(f"Error restarting BLE scan: {e}")
+    
+    def _handle_ble_packet(self, mac: str, adv_type: int, data: bytes, rssi: int):
+        """
+        Handle incoming BLE advertisement packet.
+        
+        Args:
+            mac: MAC address of the device
+            adv_type: Advertisement type
+            data: Advertisement data
+            rssi: Signal strength
+        """
+        # Update last packet time for watchdog
+        self.last_ble_packet = time.time()
+        
+        # Convert data to hex string
+        data_str = raw_packet_to_str(data)
+        
+        # Check if this is an ATC packet
+        # ATC format: [... service UUID 0x181A ... MAC ... data ...]
+        atc_identifier = data_str[6:10].upper()
+        if atc_identifier != "1A18":
+            return  # Not an ATC packet
+        
+        # Extract MAC from packet and verify it matches
+        packet_mac = data_str[10:22].upper()
+        mac_str = mac.replace(":", "").upper()
+        
+        if packet_mac != mac_str:
+            return  # MAC mismatch
+        
+        mac_with_colons = mac.upper()
+        
+        # Parse ATC data packet first to get sensor data
+        try:
+            parsed_data = self._parse_atc_data(data_str)
+            if not parsed_data:
+                return
+                
+            temperature, humidity, battery_percent, battery_voltage, adv_number = parsed_data
+            
+            # Check if this is a known sensor
+            if mac_with_colons not in self.sensor_config.sensors:
+                # Unknown sensor - check if we should discover it
+                self._handle_unknown_sensor(
+                    mac_with_colons, 
+                    rssi, 
+                    temperature, 
+                    humidity, 
+                    battery_percent, 
+                    battery_voltage
+                )
+                return
+            
+            # Check advertisement number to avoid duplicates
+            if mac_str in self.adv_counter:
+                if self.adv_counter[mac_str] == adv_number:
+                    return  # Duplicate packet
+            self.adv_counter[mac_str] = adv_number
+            
+            # Create measurement for known sensor
+            sensor_name = self.sensor_config.get_name(mac_with_colons)
+            measurement = Measurement(
+                temperature=temperature,
+                humidity=humidity,
+                voltage=battery_voltage / 1000.0,
+                battery=battery_percent,
+                rssi=rssi,
+                sensor_name=sensor_name,
+                timestamp=int(time.time())
+            )
+            
+            # Log the measurement
+            logger.info(
+                f"{measurement.sensor_name}: {measurement.temperature}°C, "
+                f"{measurement.humidity}%, {measurement.voltage}V, "
+                f"battery {measurement.battery}%, RSSI {rssi}dBm"
+            )
+            
+            # Call measurement callback
+            if self.on_measurement:
+                self.on_measurement(measurement)
+                    
+        except Exception as e:
+            logger.error(f"Error parsing ATC packet from {mac}: {e}")
+    
+    def _handle_unknown_sensor(self, mac: str, rssi: int, temperature: float,
+                               humidity: int, battery_percent: int, battery_voltage: int):
+        """
+        Handle discovery of unknown sensor.
+        
+        Args:
+            mac: MAC address with colons
+            rssi: Signal strength
+            temperature: Temperature reading
+            humidity: Humidity reading
+            battery_percent: Battery percentage
+            battery_voltage: Battery voltage in mV
+        """
+        # Get or construct device name from MAC
+        # ATC sensors advertise as ATC_XXXXXX where XXXXXX is last 3 bytes
+        mac_suffix = mac.replace(":", "")[-6:]
+        device_name = f"ATC_{mac_suffix}"
+        
+        # Check if already discovered
+        if self.discovery_manager.is_known(mac):
+            # Just update the discovery record
+            self.discovery_manager.add_or_update(
+                mac, device_name, rssi, temperature, humidity,
+                battery_percent, battery_voltage
+            )
+            return
+        
+        # New sensor - discover and notify
+        is_new = self.discovery_manager.add_or_update(
+            mac, device_name, rssi, temperature, humidity,
+            battery_percent, battery_voltage
+        )
+        
+        if is_new:
+            logger.info(f"New sensor discovered: {mac} ({device_name})")
+            sensor = self.discovery_manager.sensors[mac]
+            self.discovery_manager.send_ntfy_notification(sensor)
+    
+    def _parse_atc_data(self, data_str: str) -> Optional[tuple]:
+        """
+        Parse ATC advertisement data.
+        
+        Returns:
+            Tuple of (temperature, humidity, battery_percent, battery_voltage, adv_number) or None
+        """
+        try:
+            # Temperature: bytes 22-26, signed int16, big endian, /10
+            temp_hex = data_str[22:26]
+            temp_raw = int(temp_hex, 16)
+            if temp_raw & 0x8000:  # Check sign bit
+                temp_raw = temp_raw - 0x10000
+            temperature = temp_raw / 10.0
+            
+            # Humidity: bytes 26-28, uint8
+            humidity = int(data_str[26:28], 16)
+            
+            # Battery: bytes 28-30, uint8
+            battery_percent = int(data_str[28:30], 16)
+            
+            # Battery voltage: bytes 30-34, uint16, big endian, mV
+            battery_voltage = int(data_str[30:34], 16)
+            
+            # Advertisement number: last 2 bytes
+            adv_number = data_str[-2:]
+            
+            return (temperature, humidity, battery_percent, battery_voltage, adv_number)
+            
+        except (ValueError, IndexError) as e:
+            logger.debug(f"Error parsing ATC data: {e}")
+            return None

debian/sensorpajen/opt/sensorpajen/src/sensorpajen/utils.py

@@ -0,0 +1,421 @@
+# -*- coding: utf-8 -*-
+# This file is from https://github.com/colin-guyon/py-bluetooth-utils 
+# published under MIT License
+
+# MIT License
+
+# Copyright (c) 2020 Colin GUYON
+
+# Permission is hereby granted, free of charge, to any person obtaining a copy
+# of this software and associated documentation files (the "Software"), to deal
+# in the Software without restriction, including without limitation the rights
+# to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+# copies of the Software, and to permit persons to whom the Software is
+# furnished to do so, subject to the following conditions:
+
+# The above copyright notice and this permission notice shall be included in all
+# copies or substantial portions of the Software.
+
+# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+# FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+# AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+# OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+# SOFTWARE.
+
+"""
+Module containing some bluetooth utility functions (linux only).
+
+It either uses HCI commands using PyBluez, or does ioctl calls like it's
+done in Bluez tools such as hciconfig.
+
+Main functions:
+  - toggle_device : enable or disable a bluetooth device
+  - set_scan : set scan type on a device ("noscan", "iscan", "pscan", "piscan")
+  - enable/disable_le_scan : enable BLE scanning
+  - parse_le_advertising_events : parse and read BLE advertisements packets
+  - start/stop_le_advertising : advertise custom data using BLE
+
+Bluez : http://www.bluez.org/
+PyBluez : http://karulis.github.io/pybluez/
+
+The module was in particular inspired from 'iBeacon-Scanner-'
+https://github.com/switchdoclabs/iBeacon-Scanner-/blob/master/blescan.py
+and sometimes directly from the Bluez sources.
+"""
+
+from __future__ import absolute_import
+import sys
+import struct
+import fcntl
+import array
+import socket
+from errno import EALREADY
+
+# import PyBluez
+import bluetooth._bluetooth as bluez
+
+__all__ = ('toggle_device', 'set_scan',
+           'enable_le_scan', 'disable_le_scan', 'parse_le_advertising_events',
+           'start_le_advertising', 'stop_le_advertising',
+           'raw_packet_to_str')
+
+LE_META_EVENT = 0x3E
+LE_PUBLIC_ADDRESS = 0x00
+LE_RANDOM_ADDRESS = 0x01
+
+OGF_LE_CTL = 0x08
+OCF_LE_SET_SCAN_PARAMETERS = 0x000B
+OCF_LE_SET_SCAN_ENABLE = 0x000C
+OCF_LE_CREATE_CONN = 0x000D
+OCF_LE_SET_ADVERTISING_PARAMETERS = 0x0006
+OCF_LE_SET_ADVERTISE_ENABLE = 0x000A
+OCF_LE_SET_ADVERTISING_DATA = 0x0008
+
+SCAN_TYPE_PASSIVE = 0x00
+SCAN_FILTER_DUPLICATES = 0x01
+SCAN_DISABLE = 0x00
+SCAN_ENABLE = 0x01
+
+# sub-events of LE_META_EVENT
+EVT_LE_CONN_COMPLETE = 0x01
+EVT_LE_ADVERTISING_REPORT = 0x02
+EVT_LE_CONN_UPDATE_COMPLETE = 0x03
+EVT_LE_READ_REMOTE_USED_FEATURES_COMPLETE = 0x04
+
+# Advertisement event types
+ADV_IND = 0x00
+ADV_DIRECT_IND = 0x01
+ADV_SCAN_IND = 0x02
+ADV_NONCONN_IND = 0x03
+ADV_SCAN_RSP = 0x04
+
+# Allow Scan Request from Any, Connect Request from Any
+FILTER_POLICY_NO_WHITELIST = 0x00
+# Allow Scan Request from White List Only, Connect Request from Any
+FILTER_POLICY_SCAN_WHITELIST = 0x01
+# Allow Scan Request from Any, Connect Request from White List Only
+FILTER_POLICY_CONN_WHITELIST = 0x02
+# Allow Scan Request from White List Only, Connect Request from White List Only
+FILTER_POLICY_SCAN_AND_CONN_WHITELIST = 0x03
+
+
+def toggle_device(dev_id, enable):
+    """
+    Power ON or OFF a bluetooth device.
+
+    :param dev_id: Device id.
+    :type dev_id: ``int``
+    :param enable: Whether to enable of disable the device.
+    :type enable: ``bool``
+    """
+    hci_sock = socket.socket(socket.AF_BLUETOOTH,
+                             socket.SOCK_RAW,
+                             socket.BTPROTO_HCI)
+    print("Power %s bluetooth device %d" % ('ON' if enable else 'OFF', dev_id))
+    # di = struct.pack("HbBIBBIIIHHHH10I", dev_id, *((0,) * 22))
+    # fcntl.ioctl(hci_sock.fileno(), bluez.HCIGETDEVINFO, di)
+    req_str = struct.pack("H", dev_id)
+    request = array.array("b", req_str)
+    try:
+        fcntl.ioctl(hci_sock.fileno(),
+                    bluez.HCIDEVUP if enable else bluez.HCIDEVDOWN,
+                    request[0])
+    except IOError as e:
+        if e.errno == EALREADY:
+            print("Bluetooth device %d is already %s" % (
+                  dev_id, 'enabled' if enable else 'disabled'))
+        else:
+            raise
+    finally:
+        hci_sock.close()
+
+
+# Types of bluetooth scan
+SCAN_DISABLED = 0x00
+SCAN_INQUIRY = 0x01
+SCAN_PAGE = 0x02
+
+
+def set_scan(dev_id, scan_type):
+    """
+    Set scan type on a given bluetooth device.
+
+    :param dev_id: Device id.
+    :type dev_id: ``int``
+    :param scan_type: One of
+        ``'noscan'``
+        ``'iscan'``
+        ``'pscan'``
+        ``'piscan'``
+    :type scan_type: ``str``
+    """
+    hci_sock = socket.socket(socket.AF_BLUETOOTH,
+                             socket.SOCK_RAW,
+                             socket.BTPROTO_HCI)
+    if scan_type == "noscan":
+        dev_opt = SCAN_DISABLED
+    elif scan_type == "iscan":
+        dev_opt = SCAN_INQUIRY
+    elif scan_type == "pscan":
+        dev_opt = SCAN_PAGE
+    elif scan_type == "piscan":
+        dev_opt = SCAN_PAGE | SCAN_INQUIRY
+    else:
+        raise ValueError("Unknown scan type %r" % scan_type)
+
+    req_str = struct.pack("HI", dev_id, dev_opt)
+    print("Set scan type %r to bluetooth device %d" % (scan_type, dev_id))
+    try:
+        fcntl.ioctl(hci_sock.fileno(), bluez.HCISETSCAN, req_str)
+    finally:
+        hci_sock.close()
+
+
+def raw_packet_to_str(pkt):
+    """
+    Returns the string representation of a raw HCI packet.
+    """
+    if sys.version_info > (3, 0):
+        return ''.join('%02x' % struct.unpack("B", bytes([x]))[0] for x in pkt)
+    else:
+        return ''.join('%02x' % struct.unpack("B", x)[0] for x in pkt)
+
+
+def enable_le_scan(sock, interval=0x0800, window=0x0800,
+                   filter_policy=FILTER_POLICY_NO_WHITELIST,
+                   filter_duplicates=True):
+    """
+    Enable LE passive scan (with filtering of duplicate packets enabled).
+
+    :param sock: A bluetooth HCI socket (retrieved using the
+        ``hci_open_dev`` PyBluez function).
+    :param interval: Scan interval.
+    :param window: Scan window (must be less or equal than given interval).
+    :param filter_policy: One of
+        ``FILTER_POLICY_NO_WHITELIST`` (default value)
+        ``FILTER_POLICY_SCAN_WHITELIST``
+        ``FILTER_POLICY_CONN_WHITELIST``
+        ``FILTER_POLICY_SCAN_AND_CONN_WHITELIST``
+
+    .. note:: Scan interval and window are to multiply by 0.625 ms to
+        get the real time duration.
+    """
+    print("Enable LE scan")
+    own_bdaddr_type = LE_PUBLIC_ADDRESS  # does not work with LE_RANDOM_ADDRESS
+    cmd_pkt = struct.pack("<BHHBB", SCAN_TYPE_PASSIVE, interval, window,
+                          own_bdaddr_type, filter_policy)
+    bluez.hci_send_cmd(sock, OGF_LE_CTL, OCF_LE_SET_SCAN_PARAMETERS, cmd_pkt)
+    print("scan params: interval=%.3fms window=%.3fms own_bdaddr=%s "
+          "whitelist=%s" %
+          (interval * 0.625, window * 0.625,
+           'public' if own_bdaddr_type == LE_PUBLIC_ADDRESS else 'random',
+           'yes' if filter_policy in (FILTER_POLICY_SCAN_WHITELIST,
+                                      FILTER_POLICY_SCAN_AND_CONN_WHITELIST)
+           else 'no'))
+    cmd_pkt = struct.pack("<BB", SCAN_ENABLE, SCAN_FILTER_DUPLICATES if filter_duplicates else 0x00)
+    bluez.hci_send_cmd(sock, OGF_LE_CTL, OCF_LE_SET_SCAN_ENABLE, cmd_pkt)
+
+
+def disable_le_scan(sock):
+    """
+    Disable LE scan.
+
+    :param sock: A bluetooth HCI socket (retrieved using the
+        ``hci_open_dev`` PyBluez function).
+    """
+    print("Disable LE scan")
+    cmd_pkt = struct.pack("<BB", SCAN_DISABLE, 0x00)
+    bluez.hci_send_cmd(sock, OGF_LE_CTL, OCF_LE_SET_SCAN_ENABLE, cmd_pkt)
+
+
+def start_le_advertising(sock, min_interval=1000, max_interval=1000,
+                         adv_type=ADV_NONCONN_IND, data=()):
+    """
+    Start LE advertising.
+
+    :param sock: A bluetooth HCI socket (retrieved using the
+        ``hci_open_dev`` PyBluez function).
+    :param min_interval: Minimum advertising interval.
+    :param max_interval: Maximum advertising interval.
+    :param adv_type: Advertisement type (``ADV_NONCONN_IND`` by default).
+    :param data: The advertisement data (maximum of 31 bytes).
+    :type data: iterable
+    """
+    own_bdaddr_type = 0
+    direct_bdaddr_type = 0
+    direct_bdaddr = (0,) * 6
+    chan_map = 0x07  # All channels: 37, 38, 39
+    filter = 0
+
+    struct_params = [min_interval, max_interval, adv_type, own_bdaddr_type,
+                     direct_bdaddr_type]
+    struct_params.extend(direct_bdaddr)
+    struct_params.extend((chan_map, filter))
+
+    cmd_pkt = struct.pack("<HHBBB6BBB", *struct_params)
+    bluez.hci_send_cmd(sock, OGF_LE_CTL, OCF_LE_SET_ADVERTISING_PARAMETERS,
+                       cmd_pkt)
+
+    cmd_pkt = struct.pack("<B", 0x01)
+    bluez.hci_send_cmd(sock, OGF_LE_CTL, OCF_LE_SET_ADVERTISE_ENABLE, cmd_pkt)
+
+    data_length = len(data)
+    if data_length > 31:
+        raise ValueError("data is too long (%d but max is 31 bytes)",
+                         data_length)
+    cmd_pkt = struct.pack("<B%dB" % data_length, data_length, *data)
+    bluez.hci_send_cmd(sock, OGF_LE_CTL, OCF_LE_SET_ADVERTISING_DATA, cmd_pkt)
+    print("Advertising started data_length=%d data=%r" % (data_length, data))
+
+
+def stop_le_advertising(sock):
+    """
+    Stop LE advertising.
+
+    :param sock: A bluetooth HCI socket (retrieved using the
+        ``hci_open_dev`` PyBluez function).
+    """
+    cmd_pkt = struct.pack("<B", 0x00)
+    bluez.hci_send_cmd(sock, OGF_LE_CTL, OCF_LE_SET_ADVERTISE_ENABLE, cmd_pkt)
+    print("Advertising stopped")
+
+
+def parse_le_advertising_events(sock, mac_addr=None, packet_length=None,
+                                handler=None, debug=False):
+    """
+    Parse and report LE advertisements.
+
+    This is a blocking call, an infinite loop is started and the
+    given handler will be called each time a new LE advertisement packet
+    is detected and corresponds to the given filters.
+
+    .. note:: The :func:`.start_le_advertising` function must be
+        called before calling this function.
+
+    :param sock: A bluetooth HCI socket (retrieved using the
+        ``hci_open_dev`` PyBluez function).
+    :param mac_addr: list of filtered mac address representations
+        (uppercase, with ':' separators).
+        If not specified, the LE advertisement of any device will be reported.
+        Example: mac_addr=('00:2A:5F:FF:25:11', 'DA:FF:12:33:66:12')
+    :type mac_addr: ``list`` of ``string``
+    :param packet_length: Filter a specific length of LE advertisement packet.
+    :type packet_length: ``int``
+    :param handler: Handler that will be called each time a LE advertisement
+        packet is available (in accordance with the ``mac_addr``
+        and ``packet_length`` filters).
+    :type handler: ``callable`` taking 4 parameters:
+        mac (``str``), adv_type (``int``), data (``bytes``) and rssi (``int``)
+    :param debug: Enable debug prints.
+    :type debug: ``bool``
+    """
+    if not debug and handler is None:
+        raise ValueError("You must either enable debug or give a handler !")
+
+    old_filter = sock.getsockopt(bluez.SOL_HCI, bluez.HCI_FILTER, 14)
+
+    flt = bluez.hci_filter_new()
+    bluez.hci_filter_set_ptype(flt, bluez.HCI_EVENT_PKT)
+    # bluez.hci_filter_all_events(flt)
+    bluez.hci_filter_set_event(flt, LE_META_EVENT)
+    sock.setsockopt(bluez.SOL_HCI, bluez.HCI_FILTER, flt)
+
+    print("socket filter set to ptype=HCI_EVENT_PKT event=LE_META_EVENT")
+    print("Listening ...")
+
+    try:
+        while True:
+            pkt = full_pkt = sock.recv(255)
+            ptype, event, plen = struct.unpack("BBB", pkt[:3])
+
+            if event != LE_META_EVENT:
+                # Should never occur because we filtered with this type of event
+                print("Not a LE_META_EVENT !")
+                continue
+
+            sub_event, = struct.unpack("B", pkt[3:4])
+            if sub_event != EVT_LE_ADVERTISING_REPORT:
+                if debug:
+                    print("Not a EVT_LE_ADVERTISING_REPORT !")
+                continue
+
+            pkt = pkt[4:]
+            adv_type = struct.unpack("b", pkt[1:2])[0]
+            mac_addr_str = bluez.ba2str(pkt[3:9])
+
+            if packet_length and plen != packet_length:
+                # ignore this packet
+                if debug:
+                    print("packet with non-matching length: mac=%s adv_type=%02x plen=%s" %
+                          (mac_addr_str, adv_type, plen))
+                    print(raw_packet_to_str(pkt))
+                continue
+
+            data = pkt[9:-1]
+
+            rssi = struct.unpack("b", full_pkt[len(full_pkt)-1:len(full_pkt)])[0]
+
+            if mac_addr and mac_addr_str not in mac_addr:
+                if debug:
+                    print("packet with non-matching mac %s adv_type=%02x data=%s RSSI=%s" %
+                          (mac_addr_str, adv_type, raw_packet_to_str(data), rssi))
+                continue
+
+            if debug:
+                print("LE advertisement: mac=%s adv_type=%02x data=%s RSSI=%d" %
+                      (mac_addr_str, adv_type, raw_packet_to_str(data), rssi))
+
+            if handler is not None:
+                try:
+                    handler(mac_addr_str, adv_type, data, rssi)
+                except Exception as e:
+                    print('Exception when calling handler with a BLE advertising event: %r' % (e,))
+                    import traceback
+                    traceback.print_exc()
+
+    except KeyboardInterrupt:
+        print("\nRestore previous socket filter")
+        sock.setsockopt(bluez.SOL_HCI, bluez.HCI_FILTER, old_filter)
+        raise
+
+"""
+def hci_le_add_white_list(int dd, const bdaddr_t *bdaddr, uint8_t type, int to)
+{
+    struct hci_request {
+        uint16_t ogf;
+        uint16_t ocf;
+        int      event;
+        void     *cparam;
+        int      clen;
+        void     *rparam;
+        int      rlen;
+    };
+
+    struct hci_request rq;
+    le_add_device_to_white_list_cp cp;
+    uint8_t status;
+
+    memset(&cp, 0, sizeof(cp));
+    cp.bdaddr_type = type;
+    bacpy(&cp.bdaddr, bdaddr);
+
+    memset(&rq, 0, sizeof(rq));
+    rq.ogf = OGF_LE_CTL;
+    rq.ocf = OCF_LE_ADD_DEVICE_TO_WHITE_LIST;
+    rq.cparam = &cp;
+    rq.clen = LE_ADD_DEVICE_TO_WHITE_LIST_CP_SIZE;
+    rq.rparam = &status;
+    rq.rlen = 1;
+
+    if (hci_send_req(dd, &rq, to) < 0)
+            return -1;
+
+    if (status) {
+            errno = EIO;
+            return -1;
+    }
+
+    return 0;
+}"""

debian/sensorpajen/usr/lib/systemd/system/sensorpajen.service

@@ -0,0 +1,32 @@
+[Unit]
+Description=Sensorpajen - Bluetooth Temperature Sensor Monitor
+Documentation=https://github.com/yourusername/sensorpajen
+After=network.target bluetooth.target
+Wants=bluetooth.target
+
+[Service]
+Type=simple
+User=sensorpajen
+Group=sensorpajen
+WorkingDirectory=/opt/sensorpajen
+EnvironmentFile=/etc/sensorpajen/sensorpajen.env
+ExecStart=/opt/sensorpajen/venv/bin/python -m sensorpajen.main
+Restart=always
+RestartSec=10
+
+# Bluetooth capabilities require this to be false
+NoNewPrivileges=false
+
+# Logging
+StandardOutput=journal
+StandardError=journal
+SyslogIdentifier=sensorpajen
+
+# Security hardening (where possible with Bluetooth requirements)
+PrivateTmp=true
+ProtectSystem=strict
+ProtectHome=true
+ReadWritePaths=/etc/sensorpajen /var/lib/sensorpajen
+
+[Install]
+WantedBy=multi-user.target

debian/sensorpajen/usr/share/doc/sensorpajen/examples/discovered_sensors.json.example

@@ -0,0 +1,32 @@
+[
+  {
+    "mac": "A4:C1:38:12:34:56",
+    "name": "ATC_123456",
+    "rssi": -65,
+    "first_seen": "2025-12-27T10:30:15",
+    "last_seen": "2025-12-27T10:35:42",
+    "sample_reading": {
+      "temperature": 21.5,
+      "humidity": 45,
+      "battery_percent": 87,
+      "battery_voltage": 2950
+    },
+    "status": "pending"
+  },
+  {
+    "mac": "A4:C1:38:AB:CD:EF",
+    "name": "ATC_ABCDEF",
+    "rssi": -72,
+    "first_seen": "2025-12-27T11:00:00",
+    "last_seen": "2025-12-27T11:10:00",
+    "sample_reading": {
+      "temperature": 19.8,
+      "humidity": 52,
+      "battery_percent": 65,
+      "battery_voltage": 2800
+    },
+    "status": "ignored",
+    "ignored_at": "2025-12-27T11:15:00",
+    "ignore_reason": "Test sensor, not needed"
+  }
+]

debian/sensorpajen/usr/share/doc/sensorpajen/examples/sensorpajen.env.example

@@ -0,0 +1,29 @@
+# MQTT Configuration
+MQTT_HOST=192.168.0.114
+MQTT_PORT=1883
+MQTT_USER=hasse
+MQTT_PASSWORD=casablanca
+MQTT_CLIENT_ID=mibridge
+
+# Sensor Configuration
+# For system installation (/opt/sensorpajen): Use absolute paths
+# SENSOR_CONFIG_FILE=/etc/sensorpajen/sensors.json
+# DISCOVERED_SENSORS_FILE=/etc/sensorpajen/discovered_sensors.json
+#
+# For development installation: Use relative paths (from project root)
+# SENSOR_CONFIG_FILE=config/sensors.json
+# DISCOVERED_SENSORS_FILE=config/discovered_sensors.json
+#
+# If not set, defaults will be used based on installation type
+
+# Application Settings
+WATCHDOG_TIMEOUT=5
+ENABLE_BATTERY=true
+LOG_LEVEL=INFO
+CONFIG_RELOAD_INTERVAL=900
+
+# ntfy Notifications (optional)
+NTFY_ENABLED=false
+NTFY_URL=https://ntfy.sh
+NTFY_TOPIC=sensorpajen
+NTFY_TOKEN=

debian/sensorpajen/usr/share/doc/sensorpajen/examples/sensors.json.example

@@ -0,0 +1,37 @@
+{
+  "sensors": [
+    {
+      "mac": "A4:C1:38:98:7B:B6",
+      "name": "mi_temp_1",
+      "comment": "Example sensor - replace with your sensors"
+    },
+    {
+      "mac": "A4:C1:38:29:03:0D",
+      "name": "mi_temp_2"
+    },
+    {
+      "mac": "A4:C1:38:62:CA:83",
+      "name": "mi_temp_3"
+    },
+    {
+      "mac": "A4:C1:38:D5:EA:63",
+      "name": "mi_temp_4"
+    },
+    {
+      "mac": "A4:C1:38:7C:9C:63",
+      "name": "mi_temp_5"
+    },
+    {
+      "mac": "A4:C1:38:68:2C:DA",
+      "name": "mi_temp_6"
+    },
+    {
+      "mac": "A4:C1:38:AD:74:2B",
+      "name": "mi_temp_7"
+    },
+    {
+      "mac": "A4:C1:38:46:9F:D1",
+      "name": "mi_temp_8"
+    }
+  ]
+}

pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "sensorpajen"
-version = "2.0.0-dev"
+version = "2.0.0"
 description = "Bluetooth temperature sensor monitor for Xiaomi Mijia LYWSD03MMC"
 readme = "README.md"
 requires-python = ">=3.9"
@@ -14,7 +14,7 @@ authors = [
 ]
 keywords = ["bluetooth", "temperature", "sensor", "mqtt", "raspberry-pi"]
 classifiers = [
-    "Development Status :: 4 - Beta",
+    "Development Status :: 5 - Production/Stable",
     "Intended Audience :: Developers",
     "License :: OSI Approved :: MIT License",
     "Programming Language :: Python :: 3",
@@ -26,6 +26,7 @@ classifiers = [
 ]
 
 dependencies = [
+    "pybluez>=0.31",
     "bluepy>=1.3.0",
     "paho-mqtt>=1.6.0",
 ]

readme.md

@@ -22,48 +22,72 @@ Raspberry Pi service that monitors Xiaomi Mijia LYWSD03MMC Bluetooth temperature
 
 ## Installation
 
-See [INSTALL.md](INSTALL.md) for complete installation instructions.
+### System Installation (Debian Package - Recommended for Raspberry Pi)
 
-### Quick Start
+The easiest way to install on Raspberry Pi OS is using the pre-built Debian package:
 
 ```bash
-# Clone repository
+# Download the latest release
-git clone <repo-url> ~/sensorpajen
+wget https://gitea.wahlberg.se/api/v1/repos/fredrik/sensorpajen/releases/download/v2.0.0/sensorpajen_2.0.0_all.deb
-cd ~/sensorpajen
 
-# Create and activate virtual environment
+# Install
-python3 -m venv .venv
+sudo dpkg -i sensorpajen_2.0.0_all.deb
-source .venv/bin/activate
-
-# Install dependencies
-pip install -e .
 
 # Configure
-cp config/sensorpajen.env.example config/sensorpajen.env
+sudo nano /etc/sensorpajen/sensorpajen.env  # Edit MQTT settings
-cp config/sensors.json.example config/sensors.json
+sudo systemctl restart sensorpajen
-nano config/sensorpajen.env  # Edit MQTT settings
-nano config/sensors.json     # Edit sensor MAC addresses
 
-# Set Bluetooth capabilities
+# View logs
-sudo setcap 'cap_net_raw,cap_net_admin+eip' $(readlink -f .venv/bin/python3)
+sudo journalctl -u sensorpajen -f
-
-# Install systemd service
-mkdir -p ~/.config/systemd/user/
-cp systemd/sensorpajen.service ~/.config/systemd/user/
-systemctl --user daemon-reload
-sudo loginctl enable-linger $USER
-
-# Start service
-systemctl --user enable sensorpajen
-systemctl --user start sensorpajen
-
-# Check status
-systemctl --user status sensorpajen
-journalctl --user -u sensorpajen -f
 ```
 
+The system package installs:
+- Application in `/opt/sensorpajen/`
+- Configuration in `/etc/sensorpajen/`
+- Runtime state in `/var/lib/sensorpajen/`
+- Systemd service (runs automatically)
+
+### Development Installation
+
+See [INSTALL.md](INSTALL.md) for complete development setup.
+
 ## Configuration
 
+### Quick Setup
+
+After installation, configure your MQTT broker and sensors:
+
+```bash
+# Edit MQTT settings
+sudo nano /etc/sensorpajen/sensorpajen.env
+
+# Restart service to apply changes
+sudo systemctl restart sensorpajen
+```
+
+### Approving Sensors (Discovery Workflow)
+
+The service automatically discovers nearby Bluetooth sensors and stores them in a pending list. You approve which ones to monitor:
+
+```bash
+# Start sensor discovery (if not already running)
+sudo systemctl start sensorpajen
+
+# Let it scan for a minute or two to discover sensors
+sleep 120
+
+# View discovered sensors and approve them
+sudo sensorpajen approve-sensors
+```
+
+The approval CLI will:
+1. Show newly discovered sensors with their current readings
+2. Ask you to approve, ignore, or skip each sensor
+3. Save approved sensors to `/etc/sensorpajen/sensors.json`
+4. Mark their status in `/var/lib/sensorpajen/discovered_sensors.json`
+
+When you approve a sensor, it's added to your configuration and the service automatically starts monitoring it.
+
 ### MQTT Settings
 
 Edit `config/sensorpajen.env`:
@@ -71,7 +95,7 @@ Edit `config/sensorpajen.env`:
 ```bash
 MQTT_HOST=192.168.1.10
 MQTT_PORT=1883
-MQTT_USERNAME=username
+MQTT_USER=username
 MQTT_PASSWORD=password
 MQTT_CLIENT_ID=sensorpajen
 MQTT_TOPIC_PREFIX=MiTemperature2
@@ -79,10 +103,11 @@ MQTT_TOPIC_PREFIX=MiTemperature2
 
 ### Sensors
 
-Edit `config/sensors.json`:
+Sensors are automatically managed via the approval workflow. You can also manually edit `/etc/sensorpajen/sensors.json`:
 
 ```json
-[
+{
+  "sensors": [
     {
       "mac": "A4:C1:38:12:34:56",
       "name": "Living Room"
@@ -91,30 +116,39 @@ Edit `config/sensors.json`:
       "mac": "A4:C1:38:AB:CD:EF",
       "name": "Bedroom"
     }
-]
+  ]
-```
+}
 
 ## Service Management
 
-See [systemd/README.md](systemd/README.md) for detailed service management instructions.
+### System Installation (Debian Package)
 
 ```bash
 # Start/stop service
-systemctl --user start sensorpajen
+sudo systemctl start sensorpajen
-systemctl --user stop sensorpajen
+sudo systemctl stop sensorpajen
 
 # Enable/disable autostart
-systemctl --user enable sensorpajen
+sudo systemctl enable sensorpajen
-systemctl --user disable sensorpajen
+sudo systemctl disable sensorpajen
 
 # View status
-systemctl --user status sensorpajen
+sudo systemctl status sensorpajen
 
-# View logs
+# View logs (live)
-journalctl --user -u sensorpajen -f
+sudo journalctl -u sensorpajen -f
-journalctl --user -u sensorpajen -n 100
+
+# View last 50 log lines
+sudo journalctl -u sensorpajen -n 50
+
+# Uninstall
+sudo dpkg -r sensorpajen
+# Note: Configuration is preserved in /etc/sensorpajen/
+# To remove config: sudo rm -rf /etc/sensorpajen/
 ```
 
+### Development Installation
+
 ## Flashing New Thermometers
 
 **Important**: Flash only one thermometer at a time!
@@ -158,27 +192,40 @@ sensorpajen/
 
 ## Troubleshooting
 
-See [INSTALL.md](INSTALL.md#troubleshooting) for detailed troubleshooting steps.
+### System Installation (Debian Package)
 
-### Quick Checks
+**Service won't start:**
-
-**Permission errors:**
 ```bash
-sudo setcap 'cap_net_raw,cap_net_admin+eip' $(readlink -f ~/sensorpajen/.venv/bin/python3)
+# Check what's wrong
-systemctl --user restart sensorpajen
+sudo journalctl -u sensorpajen -n 50
+
+# Check configuration is valid
+sudo cat /etc/sensorpajen/sensorpajen.env
+
+# Manually test the application
+sudo /opt/sensorpajen/venv/bin/python -m sensorpajen.main
 ```
 
-**Service status:**
+**MQTT connection issues:**
 ```bash
-systemctl --user status sensorpajen
+# Verify MQTT settings in the log
-journalctl --user -u sensorpajen -f
+sudo journalctl -u sensorpajen | grep MQTT
-```
 
-**MQTT test:**
+# Test MQTT connection manually
-```bash
 mosquitto_sub -h <MQTT_HOST> -u <USER> -P <PASSWORD> -t "MiTemperature2/#" -v
 ```
 
+**Sensor not found:**
+```bash
+# Run sensor discovery
+sudo sensorpajen approve-sensors
+
+# Check discovered sensors
+sudo cat /var/lib/sensorpajen/discovered_sensors.json | jq '.'
+```
+
+### Development Installation
+
 ## Development
 
 ```bash

requirements.txt

@@ -1,2 +1,3 @@
+pybluez
 bluepy
 paho-mqtt

scripts/approve-sensors.sh

@@ -1,23 +1,48 @@
 #!/bin/bash
-# Wrapper script for approve-sensors that sets minimal required env vars
+# Wrapper script for approve-sensors that works in both dev and system mode
 
-# Get script directory
+# Detect installation type
-SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+if [ -d "/opt/sensorpajen" ]; then
-PROJECT_ROOT="$( cd "$SCRIPT_DIR/.." && pwd )"
+    # System installation
+    PROJECT_ROOT="/opt/sensorpajen"
+    VENV_PATH="/opt/sensorpajen/venv"
     
-# Set minimal required environment variables
+    # Load config from system location
-export MQTT_HOST="${MQTT_HOST:-localhost}"
+    if [ -f "/etc/sensorpajen/sensorpajen.env" ]; then
-export MQTT_PORT="${MQTT_PORT:-1883}"
+        set -a
+        source /etc/sensorpajen/sensorpajen.env
+        set +a
+    else
+        echo "Warning: /etc/sensorpajen/sensorpajen.env not found"
+        # Set minimal defaults
+        export MQTT_HOST="${MQTT_HOST:-localhost}"
+        export MQTT_PORT="${MQTT_PORT:-1883}"
+    fi
+else
+    # Development installation
+    SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+    PROJECT_ROOT="$( cd "$SCRIPT_DIR/.." && pwd )"
+    VENV_PATH="$PROJECT_ROOT/.venv"
     
-# Load actual config if it exists (will override defaults)
+    # Set minimal required environment variables
-if [ -f "$PROJECT_ROOT/config/sensorpajen.env" ]; then
+    export MQTT_HOST="${MQTT_HOST:-localhost}"
+    export MQTT_PORT="${MQTT_PORT:-1883}"
+
+    # Load actual config if it exists (will override defaults)
+    if [ -f "$PROJECT_ROOT/config/sensorpajen.env" ]; then
         set -a
         source "$PROJECT_ROOT/config/sensorpajen.env"
         set +a
+    fi
 fi
 
 # Activate virtual environment
-source "$PROJECT_ROOT/.venv/bin/activate"
+if [ -f "$VENV_PATH/bin/activate" ]; then
+    source "$VENV_PATH/bin/activate"
+else
+    echo "Error: Virtual environment not found at $VENV_PATH"
+    exit 1
+fi
 
 # Run the approve-sensors command
 python -m sensorpajen.approve_sensors "$@"

scripts/verify-deb.sh

@@ -0,0 +1,184 @@
+#!/bin/bash
+# Automated verification script for Debian package
+
+set -e
+
+# Colors for output
+GREEN='\033[0;32m'
+RED='\033[0;31m'
+YELLOW='\033[1;33m'
+NC='\033[0m' # No Color
+
+echo "======================================================================"
+echo "  Sensorpajen Debian Package Verification"
+echo "======================================================================"
+echo ""
+
+# Check dependencies
+echo -n "Checking for dpkg-deb... "
+if command -v dpkg-deb >/dev/null 2>&1; then
+    echo -e "${GREEN}OK${NC}"
+else
+    echo -e "${RED}MISSING${NC}"
+    echo "Install with: sudo apt install dpkg-dev"
+    exit 1
+fi
+
+echo -n "Checking for lintian... "
+if command -v lintian >/dev/null 2>&1; then
+    echo -e "${GREEN}OK${NC}"
+else
+    echo -e "${YELLOW}MISSING${NC}"
+    echo "Install with: sudo apt install lintian"
+    echo "Continuing without lintian checks..."
+    SKIP_LINTIAN=1
+fi
+
+echo -n "Checking for debhelper... "
+if dpkg -l debhelper >/dev/null 2>&1; then
+    echo -e "${GREEN}OK${NC}"
+else
+    echo -e "${YELLOW}MISSING${NC}"
+    echo "Install with: sudo apt install debhelper"
+fi
+
+echo ""
+
+# Get project root
+SCRIPT_DIR="$( cd "$( dirname "${BASH_SOURCE[0]}" )" && pwd )"
+PROJECT_ROOT="$( cd "$SCRIPT_DIR/.." && pwd )"
+
+cd "$PROJECT_ROOT"
+
+# Check required files exist
+echo "Checking required files..."
+REQUIRED_FILES=(
+    "debian/control"
+    "debian/rules"
+    "debian/install"
+    "debian/changelog"
+    "debian/postinst"
+    "debian/prerm"
+    "debian/postrm"
+    "debian/sensorpajen.service"
+    "src/sensorpajen/main.py"
+    "pyproject.toml"
+)
+
+# Optional files (debian/compat is now optional - use Build-Depends instead)
+OPTIONAL_FILES=(
+    "debian/compat"
+)
+
+ALL_FILES_OK=1
+for file in "${REQUIRED_FILES[@]}"; do
+    echo -n "  $file... "
+    if [ -f "$file" ]; then
+        echo -e "${GREEN}OK${NC}"
+    else
+        echo -e "${RED}MISSING${NC}"
+        ALL_FILES_OK=0
+    fi
+done
+
+# Check optional files
+for file in "${OPTIONAL_FILES[@]}"; do
+    echo -n "  $file... "
+    if [ -f "$file" ]; then
+        echo -e "${GREEN}OK${NC}"
+    else
+        echo -e "${YELLOW}OPTIONAL${NC}"
+    fi
+done
+
+if [ $ALL_FILES_OK -eq 0 ]; then
+    echo -e "${RED}Some required files are missing!${NC}"
+    exit 1
+fi
+
+echo ""
+
+# Extract version from pyproject.toml
+VERSION=$(grep '^version = ' pyproject.toml | sed 's/version = "\(.*\)"/\1/')
+echo "Package version: $VERSION"
+echo ""
+
+# Clean previous builds
+echo "Cleaning previous builds..."
+rm -f ../*.deb ../*.build ../*.buildinfo ../*.changes
+rm -rf debian/.debhelper debian/sensorpajen debian/files
+
+# Build the package with gzip compression (for compatibility)
+echo "Building Debian package..."
+echo "======================================================================"
+dpkg-buildpackage -us -uc -b -Zgzip
+
+if [ $? -ne 0 ]; then
+    echo -e "${RED}Build failed!${NC}"
+    exit 1
+fi
+
+echo ""
+echo -e "${GREEN}Build successful!${NC}"
+echo ""
+
+# Find the built package
+DEB_FILE=$(ls -t ../*.deb 2>/dev/null | head -1)
+
+if [ -z "$DEB_FILE" ]; then
+    echo -e "${RED}No .deb file found!${NC}"
+    exit 1
+fi
+
+echo "Package: $DEB_FILE"
+echo ""
+
+# Show package contents
+echo "Package contents:"
+echo "======================================================================"
+dpkg-deb -c "$DEB_FILE" | head -20
+TOTAL_FILES=$(dpkg-deb -c "$DEB_FILE" | wc -l)
+if [ $TOTAL_FILES -gt 20 ]; then
+    echo "... and $(($TOTAL_FILES - 20)) more files"
+fi
+echo ""
+
+# Show package info
+echo "Package information:"
+echo "======================================================================"
+dpkg-deb -I "$DEB_FILE"
+echo ""
+
+# Run lintian if available
+if [ -z "$SKIP_LINTIAN" ]; then
+    echo "Running lintian checks..."
+    echo "======================================================================"
+    
+    # Run lintian - allow warnings but fail on errors
+    if lintian "$DEB_FILE"; then
+        echo -e "${GREEN}Lintian passed!${NC}"
+    else
+        LINTIAN_EXIT=$?
+        echo -e "${YELLOW}Lintian found issues (exit code: $LINTIAN_EXIT)${NC}"
+        echo "Review the output above. Warnings are acceptable, errors should be fixed."
+    fi
+    echo ""
+fi
+
+# Final summary
+echo "======================================================================"
+echo -e "${GREEN}Package verification complete!${NC}"
+echo "======================================================================"
+echo ""
+echo "Package location: $DEB_FILE"
+echo ""
+echo "To install on a Raspberry Pi:"
+echo "  scp $DEB_FILE pi@raspberrypi:~/"
+echo "  ssh pi@raspberrypi"
+echo "  sudo apt install ./$(basename $DEB_FILE)"
+echo ""
+echo "To test locally (not recommended, will modify /opt and /etc):"
+echo "  sudo apt install $DEB_FILE"
+echo ""
+
+exit 0

src/sensorpajen/approve_sensors.py

@@ -153,8 +153,10 @@ def approve_sensor(sensor: DiscoveredSensor, manager: DiscoveryManager):
         print(f"   Name: {name}")
         print(f"   Configuration will be reloaded automatically within 15 minutes")
         
-        # Mark as approved in discovery manager
+        # Mark as approved in discovery manager and save
+        print(f"\nUpdating discovery status...")
         manager.approve(sensor.mac)
+        print(f"✅ Marked as approved in discovered_sensors.json")
         
     except Exception as e:
         print(f"\n❌ Error saving to sensors.json: {e}")
@@ -172,7 +174,7 @@ def ignore_sensor(sensor: DiscoveredSensor, manager: DiscoveryManager):
     
     manager.ignore(sensor.mac, reason if reason else None)
     
-    print(f"\n✅ Sensor ignored")
+    print(f"\n✅ Sensor ignored and marked in discovered_sensors.json")
     if reason:
         print(f"   Reason: {reason}")
 

src/sensorpajen/config.py

@@ -13,8 +13,21 @@ from typing import Dict, List
 
 logger = logging.getLogger(__name__)
 
-# Determine project root (3 levels up from this file: src/sensorpajen/config.py)
+# Determine project root and config directory
-PROJECT_ROOT = Path(__file__).parent.parent.parent
+# Check if running from system installation (/opt/sensorpajen) or development
+_opt_sensorpajen_exists = Path('/opt/sensorpajen').exists()
+_var_lib_exists = Path('/var/lib/sensorpajen').exists()
+
+if _opt_sensorpajen_exists:
+    # System installation
+    PROJECT_ROOT = Path('/opt/sensorpajen')
+    CONFIG_DIR = Path('/etc/sensorpajen')
+    STATE_DIR = Path('/var/lib/sensorpajen')
+else:
+    # Development installation (3 levels up from this file: src/sensorpajen/config.py)
+    PROJECT_ROOT = Path(__file__).parent.parent.parent
+    CONFIG_DIR = PROJECT_ROOT / "config"
+    STATE_DIR = CONFIG_DIR
 
 # MQTT Configuration from environment
 MQTT_HOST = os.environ.get("MQTT_HOST")
@@ -31,10 +44,10 @@ if not MQTT_HOST:
         "Please configure config/sensorpajen.env"
     )
 
-# Sensor configuration file (relative to project root)
+# Sensor configuration file
 SENSOR_CONFIG_FILE = os.environ.get(
     "SENSOR_CONFIG_FILE",
-    str(PROJECT_ROOT / "config/sensors.json")
+    str(CONFIG_DIR / "sensors.json")
 )
 
 # Application settings
@@ -55,7 +68,7 @@ NTFY_TOKEN = os.environ.get("NTFY_TOKEN", "")
 # Discovery settings
 DISCOVERED_SENSORS_FILE = os.environ.get(
     "DISCOVERED_SENSORS_FILE",
-    str(PROJECT_ROOT / "config/discovered_sensors.json")
+    str(STATE_DIR / "discovered_sensors.json")
 )
 CONFIG_RELOAD_INTERVAL = int(os.environ.get("CONFIG_RELOAD_INTERVAL", "900"))  # 15 minutes
 
@@ -77,11 +90,11 @@ class SensorConfig:
     def load(self):
         """Load sensor configuration from JSON file."""
         if not self.config_file.exists():
-            raise FileNotFoundError(
+            logger.warning(
                 f"Sensor configuration file not found: {self.config_file}\n"
-                f"Please copy config/sensors.json.example to config/sensors.json "
+                f"Starting with no sensors - use discovery to add sensors"
-                f"and configure your sensors."
             )
+            return
         
         try:
             with open(self.config_file, 'r') as f:
@@ -125,7 +138,12 @@ def validate_config():
     Validate configuration and log settings.
     Should be called at application startup.
     """
+    install_type = "System" if Path('/opt/sensorpajen').exists() else "Development"
     logger.info("=== Sensorpajen Configuration ===")
+    logger.info(f"Installation Type: {install_type}")
+    logger.info(f"Project Root: {PROJECT_ROOT}")
+    logger.info(f"Config Directory: {CONFIG_DIR}")
+    logger.info(f"State Directory: {STATE_DIR}")
     logger.info(f"MQTT Host: {MQTT_HOST}:{MQTT_PORT}")
     logger.info(f"MQTT User: {MQTT_USER}")
     logger.info(f"MQTT Client ID: {MQTT_CLIENT_ID}")

src/sensorpajen/main.py

@@ -125,9 +125,9 @@ class Sensorpajen:
             self.sensor_config = config.SensorConfig()
             
             if len(self.sensor_config.sensors) == 0:
-                self.logger.error("No sensors configured!")
+                self.logger.warning("No sensors configured")
-                self.logger.error("Please configure sensors in config/sensors.json")
+                self.logger.warning("Starting in discovery-only mode")
-                sys.exit(1)
+                self.logger.warning("Use 'sensorpajen approve-sensors' to add sensors")
             
             # Initialize discovery manager
             self.logger.info("Initializing discovery manager...")