ZeroComm_nodeSetup.py

#!/usr/bin/env python3
"""
══════════════════════════════════════════════════════════════════════════════
  MESHTASTIC BLE ADMIN TOOL
  ZeroComm Fleet Configuration Utility
══════════════════════════════════════════════════════════════════════════════

  Uses the official Meshtastic protobuf schemas (via the meshtastic PyPI
  package) for all encoding and decoding. No manual protobuf parsing.

  Requirements:
    pip install bleak meshtastic

══════════════════════════════════════════════════════════════════════════════
"""

import asyncio
import argparse
import base64
import hashlib
import json
import os
import random
import signal
import struct
import sys
import time
from dataclasses import dataclass, field
from datetime import datetime
from typing import Optional, List, Dict, Any

# ════════════════════════════════════════════════════════════════════════════
# PROTOBUF IMPORTS (official Meshtastic schemas)
# ════════════════════════════════════════════════════════════════════════════

from meshtastic.protobuf import (
    mesh_pb2,
    config_pb2,
    channel_pb2,
    admin_pb2,
    portnums_pb2,
    module_config_pb2,
)

from bleak import BleakClient, BleakScanner

# ════════════════════════════════════════════════════════════════════════════
# DEBUG CONFIGURATION
# ════════════════════════════════════════════════════════════════════════════

DEBUG_BLE   = True
DEBUG_PROTO = True
DEBUG_DRAIN = True
DEBUG_ADMIN = True

def _ts():
    return datetime.now().strftime("%H:%M:%S.%f")[:-3]

def debug_ble(msg):
    if DEBUG_BLE:   print(f"  [{_ts()}] [BLE]   {msg}")

def debug_proto(msg):
    if DEBUG_PROTO: print(f"  [{_ts()}] [PROTO] {msg}")

def debug_drain(msg):
    if DEBUG_DRAIN: print(f"  [{_ts()}] [DRAIN] {msg}")

def debug_admin(msg):
    if DEBUG_ADMIN: print(f"  [{_ts()}] [ADMIN] {msg}")

def info(msg):
    print(f"  {msg}")

def ok(msg):
    print(f"  ✓ {msg}")

def err(msg):
    print(f"  ✗ {msg}")

def warn(msg):
    print(f"  ⚠ {msg}")

def section(title):
    print(f"\n{'═'*60}")
    print(f"  {title}")
    print(f"{'═'*60}")

def subsection(title):
    print(f"\n  ── {title} ──")


# ════════════════════════════════════════════════════════════════════════════
# BLE UUIDS
# ════════════════════════════════════════════════════════════════════════════

MESHTASTIC_SERVICE_UUID = "6ba1b218-15a8-461f-9fa8-5dcae273eafd"
TORADIO_UUID            = "f75c76d2-129e-4dad-a1dd-7866124401e7"
FROMRADIO_UUID          = "2c55e69e-4993-11ed-b878-0242ac120002"
FROMNUM_UUID            = "ed9da18c-a800-4f66-a670-aa7547e34453"

# ════════════════════════════════════════════════════════════════════════════
# TIMING CONSTANTS
# ════════════════════════════════════════════════════════════════════════════

SCAN_TIMEOUT      = 10
CONNECT_TIMEOUT   = 30
DRAIN_TIMEOUT     = 45
REBOOT_WAIT       = 7
RECONNECT_DELAY   = 5
POST_WRITE_DELAY  = 0.5

# ════════════════════════════════════════════════════════════════════════════
# ENUM LOOKUPS
# ════════════════════════════════════════════════════════════════════════════

REGION_NAMES = {v.number: v.name
                for v in config_pb2.Config.LoRaConfig.RegionCode.DESCRIPTOR.values}

MODEM_PRESET_NAMES = {v.number: v.name
                      for v in config_pb2.Config.LoRaConfig.ModemPreset.DESCRIPTOR.values}

DEVICE_ROLE_NAMES = {v.number: v.name
                     for v in config_pb2.Config.DeviceConfig.Role.DESCRIPTOR.values}

GPS_MODE_NAMES = {v.number: v.name
                  for v in config_pb2.Config.PositionConfig.GpsMode.DESCRIPTOR.values}

BT_MODE_NAMES = {v.number: v.name
                 for v in config_pb2.Config.BluetoothConfig.PairingMode.DESCRIPTOR.values}

CHANNEL_ROLE_NAMES = {v.number: v.name
                      for v in channel_pb2.Channel.Role.DESCRIPTOR.values}

HW_MODEL_NAMES = {v.number: v.name
                  for v in mesh_pb2.HardwareModel.DESCRIPTOR.values}

# Reverse lookups
REGION_CODES   = {v.name: v.number for v in config_pb2.Config.LoRaConfig.RegionCode.DESCRIPTOR.values}
MODEM_PRESETS  = {v.name: v.number for v in config_pb2.Config.LoRaConfig.ModemPreset.DESCRIPTOR.values}
DEVICE_ROLES   = {v.name: v.number for v in config_pb2.Config.DeviceConfig.Role.DESCRIPTOR.values}
GPS_MODES      = {v.name: v.number for v in config_pb2.Config.PositionConfig.GpsMode.DESCRIPTOR.values}
BT_MODES       = {v.name: v.number for v in config_pb2.Config.BluetoothConfig.PairingMode.DESCRIPTOR.values}
CHANNEL_ROLES  = {v.name: v.number for v in channel_pb2.Channel.Role.DESCRIPTOR.values}


# ════════════════════════════════════════════════════════════════════════════
# PSK HELPERS
# ════════════════════════════════════════════════════════════════════════════

PUBLIC_PSK = bytes([0x01])   # Meshtastic public mesh shorthand

def derive_channel_psk(name: str, passphrase: str) -> bytes:
    """Derive 32-byte PSK: SHA-256("{name}{passphrase}{name}")."""
    return hashlib.sha256(f"{name}{passphrase}{name}".encode()).digest()

def psk_fingerprint(psk: bytes) -> str:
    return hashlib.sha256(psk).hexdigest()[:8]

def psk_display(psk: bytes) -> str:
    if psk == PUBLIC_PSK:
        return "PUBLIC (AQ==)"
    if len(psk) == 32:
        return f"AES-256 ({psk_fingerprint(psk)})"
    if len(psk) == 16:
        return f"AES-128 ({psk_fingerprint(psk)})"
    if len(psk) == 0:
        return "NONE"
    return f"{len(psk)}B ({psk_fingerprint(psk)})"

def psk_to_b64(psk: bytes) -> str:
    return base64.b64encode(psk).decode()

def psk_from_b64(s: str) -> bytes:
    return base64.b64decode(s)


# ════════════════════════════════════════════════════════════════════════════
# ZEROCOMM DEFAULTS
# ════════════════════════════════════════════════════════════════════════════

ZEROCOMM_DEFAULTS: Dict[str, Any] = {
    "region":                    "US",
    "modem_preset":              "MEDIUM_FAST",
    "tx_power":                  20,
    "hop_limit":                 3,
    "tx_enabled":                True,
    "sx126x_rx_boosted_gain":    True,
    "ignore_mqtt":               True,
    "role":                      "CLIENT",
    "node_info_broadcast_secs":  10800,
    "gps_mode":                  "ENABLED",
    "gps_update_interval":       60,
    "position_broadcast_secs":   3600,
    "smart_enabled":             True,
    "smart_min_secs":            30,
    "smart_min_dist":            50,
    "position_flags":            769,
    "bt_enabled":                True,
    "bt_mode":                   "RANDOM_PIN",
}


# ════════════════════════════════════════════════════════════════════════════
# DEVICE STATE — populated from config drain
# ════════════════════════════════════════════════════════════════════════════

@dataclass
class DeviceState:
    my_node_num:      int = 0
    node_id:          str = ""
    firmware_version: str = ""
    hw_model:         int = 0
    owner_long:       str = ""
    owner_short:      str = ""

    config_device:    Optional[config_pb2.Config.DeviceConfig]    = None
    config_position:  Optional[config_pb2.Config.PositionConfig]  = None
    config_power:     Optional[config_pb2.Config.PowerConfig]     = None
    config_network:   Optional[config_pb2.Config.NetworkConfig]   = None
    config_display:   Optional[config_pb2.Config.DisplayConfig]   = None
    config_lora:      Optional[config_pb2.Config.LoRaConfig]      = None
    config_bluetooth: Optional[config_pb2.Config.BluetoothConfig] = None
    config_security:  Optional[config_pb2.Config.SecurityConfig]  = None

    channels: List[channel_pb2.Channel] = field(default_factory=list)

    connected:       bool = False
    config_complete: bool = False

    def active_channels(self) -> List[channel_pb2.Channel]:
        return [ch for ch in self.channels if ch.role != channel_pb2.Channel.DISABLED]

    def print_config(self):
        section("CURRENT DEVICE CONFIGURATION")

        subsection("IDENTITY")
        info(f"Node ID:      {self.node_id}")
        info(f"Long Name:    {self.owner_long or '(not set)'}")
        info(f"Short Name:   {self.owner_short or '(not set)'}")
        info(f"Hardware:     {HW_MODEL_NAMES.get(self.hw_model, f'Model {self.hw_model}')}")
        info(f"Firmware:     {self.firmware_version or '(unknown)'}")

        subsection("DEVICE")
        d = self.config_device
        if d:
            info(f"Role:              {DEVICE_ROLE_NAMES.get(d.role, d.role)}")
            info(f"NodeInfo Interval: {d.node_info_broadcast_secs}s")
        else:
            info("(not received)")

        subsection("LORA RADIO")
        l = self.config_lora
        if l:
            info(f"Region:       {REGION_NAMES.get(l.region, str(l.region))}")
            info(f"Modem Preset: {MODEM_PRESET_NAMES.get(l.modem_preset, str(l.modem_preset))}")
            info(f"Use Preset:   {l.use_preset}")
            info(f"TX Power:     {l.tx_power} dBm")
            info(f"Hop Limit:    {l.hop_limit}")
            info(f"TX Enabled:   {l.tx_enabled}")
            info(f"RX Boosted:   {l.sx126x_rx_boosted_gain}")
            info(f"Ignore MQTT:  {l.ignore_mqtt}")
        else:
            info("(not received)")

        subsection("GPS / POSITION")
        p = self.config_position
        if p:
            info(f"GPS Mode:          {GPS_MODE_NAMES.get(p.gps_mode, str(p.gps_mode))}")
            info(f"GPS Interval:      {p.gps_update_interval}s")
            info(f"Broadcast Secs:    {p.position_broadcast_secs}s")
            info(f"Smart Positioning: {p.position_broadcast_smart_enabled}")
            if p.position_broadcast_smart_enabled:
                info(f"  Min Interval:    {p.broadcast_smart_minimum_interval_secs}s")
                info(f"  Min Distance:    {p.broadcast_smart_minimum_distance}m")
        else:
            info("(not received)")

        subsection("BLUETOOTH")
        b = self.config_bluetooth
        if b:
            info(f"Enabled: {b.enabled}")
            info(f"Mode:    {BT_MODE_NAMES.get(b.mode, str(b.mode))}")
        else:
            info("(not received)")

        subsection("CHANNELS")
        active = self.active_channels()
        if active:
            for ch in active:
                role = CHANNEL_ROLE_NAMES.get(ch.role, str(ch.role))
                name = ch.settings.name or "(default)"
                psk  = psk_display(ch.settings.psk)
                pp   = ch.settings.module_settings.position_precision if ch.settings.HasField("module_settings") else 0
                info(f"CH{ch.index} {role:<10} {name:<12} psk={psk:<22} pp={pp}")
        else:
            info("(no channels configured)")
        print()


# ════════════════════════════════════════════════════════════════════════════
# BLE CLIENT
# ════════════════════════════════════════════════════════════════════════════

class MeshtasticBLE:

    def __init__(self, address: str):
        self.address = address
        self.client: Optional[BleakClient] = None
        self.state = DeviceState()
        self.fromnum_value = 0
        self.fromnum_changed = asyncio.Event()
        self._config_id = 0

    async def connect(self, timeout: float = CONNECT_TIMEOUT) -> bool:
        debug_ble(f"Connecting to {self.address}...")
        try:
            self.client = BleakClient(self.address, timeout=timeout)
            await self.client.connect()
            debug_ble(f"Connected! MTU = {self.client.mtu_size}")

            debug_ble("Enumerating services...")
            meshtastic_service = None
            for service in self.client.services:
                debug_ble(f"  Service: {service.uuid}")
                for char in service.characteristics:
                    debug_ble(f"    Char: {char.uuid} [{','.join(char.properties)}]")
                if service.uuid.lower() == MESHTASTIC_SERVICE_UUID.lower():
                    meshtastic_service = service

            if not meshtastic_service:
                err("Meshtastic service not found")
                return False
            debug_ble(f"Found Meshtastic service")

            await self._subscribe_fromnum()
            self._config_id = random.randint(1, 0xFFFFFFFF)
            await self._request_config(self._config_id)
            await self._drain_config(self._config_id)

            self.state.connected = True
            return True

        except Exception as e:
            debug_ble(f"Connection failed: {e}")
            import traceback; traceback.print_exc()
            return False

    async def disconnect(self):
        if self.client and self.client.is_connected:
            debug_ble("Disconnecting...")
            try:
                await self.client.disconnect()
            except Exception as e:
                debug_ble(f"Disconnect error (ignored): {e}")
        self.state.connected = False
        debug_ble("Disconnected")

    async def _subscribe_fromnum(self):
        debug_ble(f"Subscribing to FROMNUM ({FROMNUM_UUID})...")

        def callback(sender, data):
            if len(data) >= 4:
                new_val = struct.unpack('<I', data[:4])[0]
                old_val = self.fromnum_value
                self.fromnum_value = new_val
                if old_val > 0 and new_val < old_val and self.state.config_complete:
                    debug_ble(f"⚠ REBOOT DETECTED: FROMNUM {old_val} → {new_val}")
                else:
                    debug_ble(f"FROMNUM notify: {new_val}")
                self.fromnum_changed.set()

        await self.client.start_notify(FROMNUM_UUID, callback)
        debug_ble("FROMNUM notify subscription started")
        try:
            data = await self.client.read_gatt_char(FROMNUM_UUID)
            if data and len(data) >= 4:
                self.fromnum_value = struct.unpack('<I', data[:4])[0]
                debug_ble(f"Initial FROMNUM: {self.fromnum_value}")
        except Exception as e:
            debug_ble(f"FROMNUM read error: {e}")
        await asyncio.sleep(0.1)

    async def _request_config(self, config_id: int):
        debug_ble(f"Requesting config (id=0x{config_id:08x})...")
        to_radio = mesh_pb2.ToRadio()
        to_radio.want_config_id = config_id
        msg = to_radio.SerializeToString()
        debug_proto(f"ToRadio.want_config_id = {config_id} (0x{config_id:08x})")
        debug_proto(f"  encoded: {msg.hex()}")
        await self.client.write_gatt_char(TORADIO_UUID, msg, response=True)
        debug_ble(f"Config request sent ({len(msg)} bytes)")
        await asyncio.sleep(0.3)
        debug_ble("Waiting for device response...")
        try:
            await asyncio.wait_for(self.fromnum_changed.wait(), timeout=2.0)
            self.fromnum_changed.clear()
        except asyncio.TimeoutError:
            debug_ble("No FROMNUM notification received, proceeding with drain anyway")

    async def _drain_config(self, expected_config_id: int):
        debug_drain(f"Starting config drain (expecting id=0x{expected_config_id:08x})...")
        print("  Reading device configuration...", end="", flush=True)

        start_time  = time.time()
        msg_count   = 0
        empty_streak = 0

        while True:
            elapsed = time.time() - start_time
            if elapsed > DRAIN_TIMEOUT:
                debug_drain(f"⚠ Drain timeout after {elapsed:.1f}s ({msg_count} messages)")
                print(f" timeout ({msg_count} msgs)")
                break

            try:
                data = await self.client.read_gatt_char(FROMRADIO_UUID)
            except Exception as e:
                debug_drain(f"Read error: {e}")
                await asyncio.sleep(0.1)
                continue

            if not data or len(data) == 0:
                empty_streak += 1
                if self.state.config_complete and empty_streak >= 3:
                    print(f" done ({msg_count} msgs)")
                    break
                if msg_count == 0 and empty_streak >= 10:
                    print(f" no response")
                    break
                if msg_count > 0 and empty_streak >= 3:
                    print(f" done ({msg_count} msgs)")
                    break
                await asyncio.sleep(0.05)
                continue

            empty_streak = 0
            msg_count += 1
            if msg_count % 5 == 0:
                print(".", end="", flush=True)

            from_radio = mesh_pb2.FromRadio()
            try:
                from_radio.ParseFromString(data)
            except Exception as e:
                debug_drain(f"Parse error: {e}")
                debug_proto(f"  raw hex: {data.hex()}")
                continue

            variant = from_radio.WhichOneof("payload_variant")
            debug_drain(f"FromRadio #{msg_count}: {variant} ({len(data)} bytes)")

            if variant == "my_info":
                info_ = from_radio.my_info
                self.state.my_node_num = info_.my_node_num
                self.state.node_id = f"!{info_.my_node_num:08x}"
                debug_drain(f"  my_node_num = {info_.my_node_num} ({self.state.node_id})")

            elif variant == "node_info":
                ni = from_radio.node_info
                if ni.num == self.state.my_node_num and ni.HasField("user"):
                    u = ni.user
                    self.state.owner_long  = u.long_name
                    self.state.owner_short = u.short_name
                    self.state.hw_model    = u.hw_model
                    debug_drain(f"  owner: {u.long_name} ({u.short_name})")
                    debug_drain(f"  hw_model: {HW_MODEL_NAMES.get(u.hw_model, u.hw_model)}")

            elif variant == "config":
                cfg = from_radio.config
                cv  = cfg.WhichOneof("payload_variant")
                debug_drain(f"  Config section: {cv}")
                if cv == "device":
                    self.state.config_device = config_pb2.Config.DeviceConfig(); self.state.config_device.CopyFrom(cfg.device)
                elif cv == "position":
                    self.state.config_position = config_pb2.Config.PositionConfig(); self.state.config_position.CopyFrom(cfg.position)
                elif cv == "power":
                    self.state.config_power = config_pb2.Config.PowerConfig(); self.state.config_power.CopyFrom(cfg.power)
                elif cv == "network":
                    self.state.config_network = config_pb2.Config.NetworkConfig(); self.state.config_network.CopyFrom(cfg.network)
                elif cv == "display":
                    self.state.config_display = config_pb2.Config.DisplayConfig(); self.state.config_display.CopyFrom(cfg.display)
                elif cv == "lora":
                    self.state.config_lora = config_pb2.Config.LoRaConfig(); self.state.config_lora.CopyFrom(cfg.lora)
                elif cv == "bluetooth":
                    self.state.config_bluetooth = config_pb2.Config.BluetoothConfig(); self.state.config_bluetooth.CopyFrom(cfg.bluetooth)
                elif cv == "security":
                    self.state.config_security = config_pb2.Config.SecurityConfig(); self.state.config_security.CopyFrom(cfg.security)

            elif variant == "channel":
                ch = from_radio.channel
                while len(self.state.channels) <= ch.index:
                    empty_ch = channel_pb2.Channel()
                    empty_ch.index = len(self.state.channels)
                    self.state.channels.append(empty_ch)
                self.state.channels[ch.index].CopyFrom(ch)
                rn = CHANNEL_ROLE_NAMES.get(ch.role, str(ch.role))
                debug_drain(f"  Channel[{ch.index}]: {ch.settings.name or '(default)'} role={rn}")

            elif variant == "moduleConfig":
                mc = from_radio.moduleConfig
                debug_drain(f"  ModuleConfig: {mc.WhichOneof('payload_variant')}")

            elif variant == "config_complete_id":
                cid = from_radio.config_complete_id
                if cid == expected_config_id:
                    debug_drain(f"✓ Config complete! ({msg_count} messages in {elapsed:.1f}s)")
                    self.state.config_complete = True
                else:
                    debug_drain(f"⚠ Unexpected config_complete_id: 0x{cid:08x}")

            elif variant == "metadata":
                md = from_radio.metadata
                self.state.firmware_version = md.firmware_version
                debug_drain(f"  firmware: {md.firmware_version}")

            elif variant == "packet":
                debug_drain(f"  MeshPacket (id=0x{from_radio.packet.id:08x})")

            elif variant:
                debug_drain(f"  (skipping {variant})")

            await asyncio.sleep(0.01)

    async def write_admin(self, admin_msg: admin_pb2.AdminMessage,
                          expect_reboot: bool = False) -> bool:
        if not self.client or not self.client.is_connected:
            debug_admin("ERROR: Not connected")
            return False

        data = mesh_pb2.Data()
        data.portnum = portnums_pb2.ADMIN_APP
        data.payload = admin_msg.SerializeToString()

        mesh_packet = mesh_pb2.MeshPacket()
        mesh_packet.to       = self.state.my_node_num
        mesh_packet.id       = random.randint(1, 0xFFFFFFFF)
        mesh_packet.hop_limit = 3
        mesh_packet.decoded.CopyFrom(data)

        to_radio = mesh_pb2.ToRadio()
        to_radio.packet.CopyFrom(mesh_packet)

        payload = to_radio.SerializeToString()
        debug_admin(f"Sending admin message ({len(payload)} bytes)...")
        debug_proto(f"  hex: {payload.hex()[:80]}...")

        try:
            await self.client.write_gatt_char(TORADIO_UUID, payload, response=True)
            debug_admin("✓ Write complete")
            if expect_reboot:
                await asyncio.sleep(POST_WRITE_DELAY)
            return True
        except Exception as e:
            debug_admin(f"Write error: {e}")
            return False


# ════════════════════════════════════════════════════════════════════════════
# ADMIN MESSAGE BUILDERS
# ════════════════════════════════════════════════════════════════════════════

def build_set_owner(long_name: str, short_name: str,
                    is_licensed: bool = False) -> admin_pb2.AdminMessage:
    admin = admin_pb2.AdminMessage()
    admin.set_owner.long_name  = long_name
    admin.set_owner.short_name = short_name[:4]
    admin.set_owner.is_licensed = is_licensed
    debug_admin(f"set_owner: long='{long_name}' short='{short_name[:4]}'")
    return admin

def build_set_channel(index: int, name: str, psk: bytes,
                      role: int, position_precision: int = 0) -> admin_pb2.AdminMessage:
    admin = admin_pb2.AdminMessage()
    ch = admin.set_channel
    ch.index    = index
    ch.role     = role
    ch.settings.psk  = psk
    if name:
        ch.settings.name = name
    if position_precision > 0:
        ch.settings.module_settings.position_precision = position_precision
    debug_admin(f"set_channel[{index}]: name='{name}' role={CHANNEL_ROLE_NAMES.get(role, role)} psk={psk_display(psk)}")
    return admin

def build_set_config_lora(region: int, modem_preset: int, tx_power: int,
                          hop_limit: int, tx_enabled: bool = True,
                          use_preset: bool = True,
                          sx126x_rx_boosted_gain: bool = True,
                          ignore_mqtt: bool = True) -> admin_pb2.AdminMessage:
    admin = admin_pb2.AdminMessage()
    lora = admin.set_config.lora
    lora.use_preset            = use_preset
    lora.modem_preset          = modem_preset
    lora.region                = region
    lora.hop_limit             = hop_limit
    lora.tx_enabled            = tx_enabled
    lora.tx_power              = tx_power
    lora.sx126x_rx_boosted_gain = sx126x_rx_boosted_gain
    lora.ignore_mqtt           = ignore_mqtt
    debug_admin(f"set_config(lora): region={REGION_NAMES.get(region, region)} "
                f"preset={MODEM_PRESET_NAMES.get(modem_preset, modem_preset)} "
                f"tx={tx_power}dBm hops={hop_limit}")
    return admin

def build_set_config_device(role: int,
                            node_info_broadcast_secs: int = 10800) -> admin_pb2.AdminMessage:
    admin = admin_pb2.AdminMessage()
    dev = admin.set_config.device
    dev.role                    = role
    dev.node_info_broadcast_secs = node_info_broadcast_secs
    debug_admin(f"set_config(device): role={DEVICE_ROLE_NAMES.get(role, role)} "
                f"nodeinfo={node_info_broadcast_secs}s")
    return admin

def build_set_config_position(gps_mode: int, gps_update_interval: int = 60,
                              position_broadcast_secs: int = 3600,
                              smart_enabled: bool = True,
                              smart_min_secs: int = 30,
                              smart_min_dist: int = 50,
                              position_flags: int = 769) -> admin_pb2.AdminMessage:
    admin = admin_pb2.AdminMessage()
    pos = admin.set_config.position
    pos.gps_mode                           = gps_mode
    pos.gps_update_interval                = gps_update_interval
    pos.position_broadcast_secs            = position_broadcast_secs
    pos.position_broadcast_smart_enabled   = smart_enabled
    pos.broadcast_smart_minimum_interval_secs = smart_min_secs
    pos.broadcast_smart_minimum_distance   = smart_min_dist
    pos.position_flags                     = position_flags
    debug_admin(f"set_config(position): gps={GPS_MODE_NAMES.get(gps_mode, gps_mode)} "
                f"interval={gps_update_interval}s broadcast={position_broadcast_secs}s")
    return admin

def build_set_config_bluetooth(enabled: bool = True, mode: int = 0) -> admin_pb2.AdminMessage:
    admin = admin_pb2.AdminMessage()
    bt = admin.set_config.bluetooth
    bt.enabled = enabled
    bt.mode    = mode
    debug_admin(f"set_config(bluetooth): enabled={enabled} mode={BT_MODE_NAMES.get(mode, mode)}")
    return admin

def build_set_config_security(public_key: bytes, private_key: bytes,
                              admin_key: bytes = b"") -> admin_pb2.AdminMessage:
    admin = admin_pb2.AdminMessage()
    sec = admin.set_config.security
    sec.public_key  = public_key
    sec.private_key = private_key
    if admin_key:
        sec.admin_key = admin_key
    debug_admin(f"set_config(security): pub={public_key.hex()[:16]}... "
                f"priv=<{len(private_key)}B redacted>")
    return admin

def build_factory_reset(full: bool = False) -> admin_pb2.AdminMessage:
    admin = admin_pb2.AdminMessage()
    if full:
        admin.factory_reset_device = 1
        debug_admin("factory_reset_device = 1 (FULL WIPE including BLE keys)")
    else:
        admin.factory_reset_config = 1
        debug_admin("factory_reset_config = 1 (config only, preserves keys)")
    return admin

def build_reboot(seconds: int = 3) -> admin_pb2.AdminMessage:
    admin = admin_pb2.AdminMessage()
    admin.reboot_seconds = seconds
    debug_admin(f"reboot_seconds = {seconds}")
    return admin


# ════════════════════════════════════════════════════════════════════════════
# CONFIG FILE — SAVE / LOAD (human + machine readable JSON)
# ════════════════════════════════════════════════════════════════════════════

def state_to_config_dict(state: DeviceState, include_keys: bool = False) -> Dict[str, Any]:
    """Serialize DeviceState to a plain dict suitable for JSON."""
    d: Dict[str, Any] = {
        "_meta": {
            "tool":    "meshtastic_admin",
            "version": "2",
            "saved":   datetime.now().isoformat(),
            "node_id": state.node_id,
            "include_keys": include_keys,
        },
        "identity": {
            "node_id":          state.node_id,
            "long_name":        state.owner_long,
            "short_name":       state.owner_short,
            "hw_model":         HW_MODEL_NAMES.get(state.hw_model, str(state.hw_model)),
            "firmware_version": state.firmware_version,
        },
    }

    if state.config_lora:
        l = state.config_lora
        d["lora"] = {
            "region":               REGION_NAMES.get(l.region, str(l.region)),
            "modem_preset":         MODEM_PRESET_NAMES.get(l.modem_preset, str(l.modem_preset)),
            "use_preset":           l.use_preset,
            "tx_power":             l.tx_power,
            "hop_limit":            l.hop_limit,
            "tx_enabled":           l.tx_enabled,
            "sx126x_rx_boosted_gain": l.sx126x_rx_boosted_gain,
            "ignore_mqtt":          l.ignore_mqtt,
        }

    if state.config_device:
        dv = state.config_device
        d["device"] = {
            "role":                    DEVICE_ROLE_NAMES.get(dv.role, str(dv.role)),
            "node_info_broadcast_secs": dv.node_info_broadcast_secs,
        }

    if state.config_position:
        p = state.config_position
        d["position"] = {
            "gps_mode":              GPS_MODE_NAMES.get(p.gps_mode, str(p.gps_mode)),
            "gps_update_interval":   p.gps_update_interval,
            "position_broadcast_secs": p.position_broadcast_secs,
            "position_broadcast_smart_enabled": p.position_broadcast_smart_enabled,
            "broadcast_smart_minimum_interval_secs": p.broadcast_smart_minimum_interval_secs,
            "broadcast_smart_minimum_distance": p.broadcast_smart_minimum_distance,
            "position_flags":        p.position_flags,
        }

    if state.config_bluetooth:
        b = state.config_bluetooth
        d["bluetooth"] = {
            "enabled": b.enabled,
            "mode":    BT_MODE_NAMES.get(b.mode, str(b.mode)),
        }

    # Channels — include PSK as base64
    ch_list = []
    for ch in state.active_channels():
        pp = ch.settings.module_settings.position_precision if ch.settings.HasField("module_settings") else 0
        ch_list.append({
            "index":              ch.index,
            "name":               ch.settings.name,
            "role":               CHANNEL_ROLE_NAMES.get(ch.role, str(ch.role)),
            "psk_b64":            psk_to_b64(ch.settings.psk),
            "psk_display":        psk_display(ch.settings.psk),
            "position_precision": pp,
        })
    d["channels"] = ch_list

    # Keys — only if explicitly requested
    if include_keys and state.config_security:
        sec = state.config_security
        d["security"] = {
            "_warning": "PRIVATE KEY — keep this file secure",
            "public_key_b64":  base64.b64encode(sec.public_key).decode()  if sec.public_key  else "",
            "private_key_b64": base64.b64encode(sec.private_key).decode() if sec.private_key else "",
            "admin_key_b64":   base64.b64encode(sec.admin_key).decode()   if sec.admin_key   else "",
        }

    return d


def save_config_file(state: DeviceState, include_keys: bool = False) -> str:
    """Write config to JSON file. Returns filename."""
    ts   = datetime.now().strftime("%Y%m%d_%H%M%S")
    name = state.owner_long.replace(" ", "_") or state.node_id.replace("!", "")
    suffix = "_keys" if include_keys else "_config"
    fname  = f"{name}{suffix}_{ts}.json"

    d = state_to_config_dict(state, include_keys=include_keys)
    with open(fname, "w") as f:
        json.dump(d, f, indent=2)

    return fname


def load_config_file(path: str) -> Dict[str, Any]:
    """Load and validate a config JSON file."""
    with open(path) as f:
        d = json.load(f)
    if "_meta" not in d:
        raise ValueError("Not a valid meshtastic_admin config file (missing _meta)")
    return d


def pick_file(label: str = "Select file", keys_only: bool = False) -> Optional[str]:
    """
    Interactive file browser.
    Lists .json files in current dir (and optionally another dir).
    Returns selected path or None if cancelled.
    """
    def _list_json(directory: str) -> List[str]:
        try:
            files = sorted(
                f for f in os.listdir(directory)
                if f.endswith(".json")
                and (not keys_only or "_keys_" in f)
            )
            return files
        except PermissionError:
            return []

    current_dir = os.getcwd()

    while True:
        files = _list_json(current_dir)

        print(f"\n  {label}")
        print(f"  Directory: {current_dir}")
        print()

        if not files:
            print("  (no .json files here)")
        else:
            for i, fname in enumerate(files, 1):
                fpath = os.path.join(current_dir, fname)
                try:
                    sz   = os.path.getsize(fpath)
                    mtime = datetime.fromtimestamp(os.path.getmtime(fpath)).strftime("%Y-%m-%d %H:%M")
                except OSError:
                    sz, mtime = 0, "?"
                # Try to peek at node_id + saved from _meta
                tag = ""
                try:
                    with open(fpath) as f:
                        peek = json.load(f)
                    meta = peek.get("_meta", {})
                    node = meta.get("node_id", "")
                    saved = meta.get("saved", "")[:16]
                    has_keys = "🔑" if meta.get("include_keys") else ""
                    tag = f"  {node} {saved} {has_keys}".rstrip()
                except Exception:
                    pass
                print(f"    {i:>2}) {fname:<50} {sz:>6}B  {mtime}{tag}")

        print()
        print("  Enter number, path, or 'd <path>' to change directory  (q=cancel)")
        raw = input("  > ").strip()

        if not raw or raw.lower() == "q":
            return None

        if raw.lower().startswith("d "):
            new_dir = raw[2:].strip().rstrip("/") or "/"
            new_dir = os.path.expanduser(new_dir)
            if os.path.isdir(new_dir):
                current_dir = os.path.abspath(new_dir)
            else:
                warn(f"Not a directory: {new_dir}")
            continue

        # Numeric selection
        try:
            idx = int(raw) - 1
            if 0 <= idx < len(files):
                return os.path.join(current_dir, files[idx])
            else:
                warn("Number out of range")
                continue
        except ValueError:
            pass

        # Direct path
        path = os.path.expanduser(raw)
        if os.path.isfile(path):
            return path
        # Maybe they typed a bare filename in current dir
        candidate = os.path.join(current_dir, path)
        if os.path.isfile(candidate):
            return candidate
        warn(f"File not found: {raw}")


# ════════════════════════════════════════════════════════════════════════════
# BLE SCAN
# ════════════════════════════════════════════════════════════════════════════

async def scan_for_devices(timeout: float = SCAN_TIMEOUT) -> List[tuple]:
    info(f"Scanning for Meshtastic devices ({timeout}s)...")
    devices = []
    seen    = set()

    def detection_callback(device, advertisement_data):
        if device.address in seen: return
        seen.add(device.address)
        name = device.name or advertisement_data.local_name or "Unknown"
        rssi = advertisement_data.rssi if advertisement_data.rssi else -999
        service_uuids = advertisement_data.service_uuids or []
        is_meshtastic = any(MESHTASTIC_SERVICE_UUID.lower() in u.lower() for u in service_uuids)
        if is_meshtastic or ("_" in name and len(name) >= 4):
            devices.append((device.address, name, rssi))
            debug_ble(f"Found: {name} ({device.address}) RSSI={rssi}")

    try:
        scanner = BleakScanner(detection_callback=detection_callback,
                               service_uuids=[MESHTASTIC_SERVICE_UUID])
        await scanner.start()
        await asyncio.sleep(timeout)
        await scanner.stop()
    except Exception:
        seen.clear(); devices.clear()
        scanner = BleakScanner(detection_callback=detection_callback)
        await scanner.start()
        await asyncio.sleep(timeout)
        await scanner.stop()

    devices.sort(key=lambda x: x[2], reverse=True)
    return devices


def rssi_bar(rssi: int) -> str:
    bars = 5 if rssi >= -50 else 4 if rssi >= -60 else 3 if rssi >= -70 else 2 if rssi >= -80 else 1
    return "█" * bars + "░" * (5 - bars)


async def pick_device() -> Optional[str]:
    devices = await scan_for_devices()
    if not devices:
        err("No devices found.")
        return None
    print(f"\n  Found {len(devices)} device(s):\n")
    for i, (addr, name, rssi) in enumerate(devices, 1):
        print(f"    {i}) {name:<20} {addr}  {rssi:>4} dBm {rssi_bar(rssi)}")
    print()
    if len(devices) == 1:
        if input("  Connect? [Y/n]: ").strip().lower() in ("n", "no"):
            return None
        return devices[0][0]
    sel = input(f"  Select [1-{len(devices)}]: ").strip()
    try:
        idx = int(sel) - 1
        if 0 <= idx < len(devices):
            return devices[idx][0]
    except ValueError:
        pass
    err("Invalid selection")
    return None


# ════════════════════════════════════════════════════════════════════════════
# VERIFICATION — reconnect and compare
# ════════════════════════════════════════════════════════════════════════════

async def reconnect_and_verify(ble: MeshtasticBLE, reboot_wait: bool = False) -> bool:
    """Disconnect, optionally wait for reboot, reconnect, drain, return success."""
    debug_ble("Disconnecting before verify reconnect...")
    await ble.disconnect()

    if reboot_wait:
        info(f"Waiting {REBOOT_WAIT}s for device reboot...")
        await asyncio.sleep(REBOOT_WAIT)

    info(f"Waiting {RECONNECT_DELAY}s before reconnect...")
    await asyncio.sleep(RECONNECT_DELAY)

    info("Reconnecting for verification...")
    ble.state = DeviceState()   # reset state — fresh drain
    ble.fromnum_value = 0
    ble.fromnum_changed.clear()

    if not await ble.connect():
        err("Reconnect failed")
        return False
    ok("Reconnected and drained successfully")
    return True


def verify_owner(state: DeviceState, expected_long: str, expected_short: str) -> bool:
    ok_ = True
    info(f"[verify owner]  long_name:  {state.owner_long!r} (expected {expected_long!r})")
    if state.owner_long != expected_long:
        warn(f"  MISMATCH: long_name"); ok_ = False
    info(f"[verify owner]  short_name: {state.owner_short!r} (expected {expected_short!r})")
    if state.owner_short != expected_short:
        warn(f"  MISMATCH: short_name"); ok_ = False
    return ok_


def verify_channels(state: DeviceState, expected: List[Dict]) -> bool:
    ok_ = True
    for exp in expected:
        idx  = exp["index"]
        matches = [ch for ch in state.channels if ch.index == idx]
        if not matches:
            warn(f"  CH{idx}: not found in drain"); ok_ = False; continue
        ch = matches[0]
        info(f"[verify CH{idx}]  name={ch.settings.name!r} role={CHANNEL_ROLE_NAMES.get(ch.role,'?')} "
             f"psk={psk_display(ch.settings.psk)}")
        if ch.settings.name != exp.get("name", ""):
            warn(f"  CH{idx}: name MISMATCH (got {ch.settings.name!r}, expected {exp['name']!r})"); ok_ = False
        exp_psk = exp.get("psk", b"")
        if ch.settings.psk != exp_psk:
            warn(f"  CH{idx}: PSK MISMATCH"); ok_ = False
        exp_role = exp.get("role", channel_pb2.Channel.DISABLED)
        if ch.role != exp_role:
            warn(f"  CH{idx}: role MISMATCH"); ok_ = False
    return ok_


def verify_lora(state: DeviceState, region: int, modem_preset: int,
                tx_power: int, hop_limit: int) -> bool:
    l = state.config_lora
    if not l:
        warn("[verify lora] config_lora not received"); return False
    ok_ = True
    checks = [
        ("region",       l.region,       region,       REGION_NAMES),
        ("modem_preset", l.modem_preset, modem_preset, MODEM_PRESET_NAMES),
        ("tx_power",     l.tx_power,     tx_power,     None),
        ("hop_limit",    l.hop_limit,    hop_limit,    None),
    ]
    for label, got, exp, names in checks:
        got_s = names.get(got, str(got)) if names else str(got)
        exp_s = names.get(exp, str(exp)) if names else str(exp)
        info(f"[verify lora]  {label}: {got_s} (expected {exp_s})")
        if got != exp:
            warn(f"  MISMATCH: {label}"); ok_ = False
    return ok_


def verify_device(state: DeviceState, role: int, node_info_broadcast_secs: int) -> bool:
    d = state.config_device
    if not d:
        warn("[verify device] config_device not received"); return False
    ok_ = True
    info(f"[verify device]  role: {DEVICE_ROLE_NAMES.get(d.role,'?')} (expected {DEVICE_ROLE_NAMES.get(role,'?')})")
    if d.role != role: warn("  MISMATCH: role"); ok_ = False
    info(f"[verify device]  nodeinfo_interval: {d.node_info_broadcast_secs}s (expected {node_info_broadcast_secs}s)")
    if d.node_info_broadcast_secs != node_info_broadcast_secs:
        warn("  MISMATCH: node_info_broadcast_secs"); ok_ = False
    return ok_


def verify_position(state: DeviceState, gps_mode: int, gps_update_interval: int,
                    position_broadcast_secs: int, smart_enabled: bool,
                    smart_min_secs: int, smart_min_dist: int) -> bool:
    p = state.config_position
    if not p:
        warn("[verify position] config_position not received"); return False
    ok_ = True
    info(f"[verify position]  gps_mode: {GPS_MODE_NAMES.get(p.gps_mode,'?')} (expected {GPS_MODE_NAMES.get(gps_mode,'?')})")
    if p.gps_mode != gps_mode: warn("  MISMATCH: gps_mode"); ok_ = False
    info(f"[verify position]  gps_interval: {p.gps_update_interval}s (expected {gps_update_interval}s)")
    if p.gps_update_interval != gps_update_interval: warn("  MISMATCH: gps_update_interval"); ok_ = False
    info(f"[verify position]  broadcast_secs: {p.position_broadcast_secs}s (expected {position_broadcast_secs}s)")
    if p.position_broadcast_secs != position_broadcast_secs: warn("  MISMATCH: position_broadcast_secs"); ok_ = False
    info(f"[verify position]  smart_enabled: {p.position_broadcast_smart_enabled} (expected {smart_enabled})")
    if p.position_broadcast_smart_enabled != smart_enabled: warn("  MISMATCH: smart_enabled"); ok_ = False
    if smart_enabled:
        info(f"[verify position]  smart_min_secs: {p.broadcast_smart_minimum_interval_secs}s (expected {smart_min_secs}s)")
        if p.broadcast_smart_minimum_interval_secs != smart_min_secs: warn("  MISMATCH: smart_min_secs"); ok_ = False
        info(f"[verify position]  smart_min_dist: {p.broadcast_smart_minimum_distance}m (expected {smart_min_dist}m)")
        if p.broadcast_smart_minimum_distance != smart_min_dist: warn("  MISMATCH: smart_min_dist"); ok_ = False
    return ok_


def verify_bluetooth(state: DeviceState, enabled: bool, mode: int) -> bool:
    b = state.config_bluetooth
    if not b:
        warn("[verify bluetooth] config_bluetooth not received"); return False
    ok_ = True
    info(f"[verify bluetooth]  enabled: {b.enabled} (expected {enabled})")
    if b.enabled != enabled: warn("  MISMATCH: enabled"); ok_ = False
    info(f"[verify bluetooth]  mode: {BT_MODE_NAMES.get(b.mode,'?')} (expected {BT_MODE_NAMES.get(mode,'?')})")
    if b.mode != mode: warn("  MISMATCH: mode"); ok_ = False
    return ok_


# ════════════════════════════════════════════════════════════════════════════
# PROMPT HELPERS
# ════════════════════════════════════════════════════════════════════════════

def prompt(label: str, current, options: Optional[List[str]] = None,
           transform=None) -> str:
    """Show current value, prompt for new. Return new value or current if blank."""
    curr_s = str(current) if current is not None else ""
    if options:
        opts_s = " / ".join(options)
        raw = input(f"  {label} [{curr_s}] ({opts_s}): ").strip()
    else:
        raw = input(f"  {label} [{curr_s}]: ").strip()
    result = raw if raw else curr_s
    if transform:
        result = transform(result)
    return result


def prompt_int(label: str, current: int) -> int:
    raw = input(f"  {label} [{current}]: ").strip()
    if not raw: return current
    try:
        return int(raw)
    except ValueError:
        warn(f"Invalid integer, keeping {current}")
        return current


def prompt_bool(label: str, current: bool) -> bool:
    curr_s = "Y" if current else "N"
    raw = input(f"  {label} [{curr_s}] (y/n): ").strip().lower()
    if not raw: return current
    return raw in ("y", "yes", "1", "true")


# ════════════════════════════════════════════════════════════════════════════
# CHANNEL PSK PROMPTING
# ════════════════════════════════════════════════════════════════════════════

def prompt_ch0_psk(current_psk: bytes) -> bytes:
    """Channel 0 PSK: public (AQ==) or private passphrase."""
    info("Channel 0 (PRIMARY) PSK:")
    info("  1) PUBLIC MESH  (AQ== — open, no encryption)")
    info("  2) PRIVATE      (derive from passphrase)")
    curr_display = "1" if current_psk == PUBLIC_PSK else "2"
    choice = input(f"  Type [{curr_display}]: ").strip()
    if not choice: choice = curr_display

    if choice == "1":
        return PUBLIC_PSK
    else:
        while True:
            pp = input("  Passphrase (min 4 chars): ").strip()
            if len(pp) >= 4: break
            warn("Too short")
        ch_name = input("  Channel name (used in PSK derivation) [General]: ").strip() or "General"
        psk = derive_channel_psk(ch_name, pp)
        info(f"  → PSK fingerprint: {psk_fingerprint(psk)}")
        return psk


def prompt_channel_psk(ch_index: int, ch_name: str, current_psk: bytes,
                        shared_pass: Optional[str] = None) -> bytes:
    """Secondary channel PSK."""
    info(f"  Channel {ch_index} ({ch_name}) PSK:")
    info(f"    Current: {psk_display(current_psk)}")
    info("    1) Derive from shared passphrase")
    info("    2) Derive from custom passphrase")
    info("    3) PUBLIC (AQ==)")
    info("    Enter = keep current")

    choice = input("    Choice: ").strip()
    if not choice:
        return current_psk

    if choice == "1":
        if shared_pass is None:
            shared_pass = input("    Shared passphrase: ").strip()
        return derive_channel_psk(ch_name, shared_pass)
    elif choice == "2":
        while True:
            pp = input("    Passphrase (min 4): ").strip()
            if len(pp) >= 4: break
            warn("Too short")
        return derive_channel_psk(ch_name, pp)
    elif choice == "3":
        return PUBLIC_PSK
    else:
        return current_psk


# ════════════════════════════════════════════════════════════════════════════
# INDIVIDUAL MENU ACTIONS
# ════════════════════════════════════════════════════════════════════════════

# ── 1. Read config → file ──────────────────────────────────────────────────

async def menu_read_config(address: str):
    section("READ CONFIG → FILE")
    ble = MeshtasticBLE(address)
    if not await ble.connect(): err("Connection failed"); return
    ble.state.print_config()
    fname = save_config_file(ble.state, include_keys=False)
    ok(f"Config saved to: {fname}")
    await ble.disconnect()


# ── 2. Default setup (full interactive walk-through) ──────────────────────

async def menu_default_setup(address: str):
    section("DEFAULT SETUP — FULL CONFIGURATION")
    D = ZEROCOMM_DEFAULTS

    # Connect only long enough to drain config, then disconnect before prompting.
    # Prompts can take minutes; holding BLE open risks a silent drop.
    ble = MeshtasticBLE(address)
    if not await ble.connect(): err("Connection failed"); return
    ble.state.print_config()
    curr = ble.state
    await ble.disconnect()
    info("Disconnected — collecting settings offline")

    # ── Identity ──
    subsection("IDENTITY")
    long_name  = prompt("Long name",  curr.owner_long)
    if not long_name: err("Long name required"); return
    short_name = prompt("Short name (4 max)", curr.owner_short)
    short_name = short_name[:4]
    if not short_name: err("Short name required"); return

    # ── Channels ──
    subsection("CHANNELS")
    raw = input(f"  Number of active channels [1-8] [{len(curr.active_channels()) or 4}]: ").strip()
    try:
        num_ch = int(raw) if raw else (len(curr.active_channels()) or 4)
        num_ch = max(1, min(8, num_ch))
    except ValueError:
        num_ch = 4

    # Collect shared passphrase upfront (optional)
    shared_pass: Optional[str] = None
    if num_ch > 1:
        sp = input("  Shared passphrase for secondary channels (Enter to skip/per-channel): ").strip()
        if len(sp) >= 4:
            shared_pass = sp

    channels_cfg: List[Dict] = []

    for i in range(num_ch):
        existing = next((ch for ch in curr.channels if ch.index == i), None)
        curr_name = existing.settings.name if existing else ["General","Priority","Immediate","waypoints","Extra4","Extra5","Extra6","Extra7"][i] if i < 8 else f"CH{i}"
        curr_role = existing.role if existing else (channel_pb2.Channel.PRIMARY if i == 0 else channel_pb2.Channel.SECONDARY)
        curr_psk  = existing.settings.psk if existing else b""
        curr_pp   = (existing.settings.module_settings.position_precision
                     if existing and existing.settings.HasField("module_settings") else (32 if i == 0 else 0))

        info(f"\n  ── Channel {i} {'(PRIMARY)' if i==0 else '(SECONDARY)'} ──")
        ch_name = prompt(f"  CH{i} name", curr_name).strip() or curr_name

        if i == 0:
            # CH0: public or private
            if curr_psk == PUBLIC_PSK:
                curr_psk_choice = "1"
            else:
                curr_psk_choice = "2"
            info(f"  Current PSK: {psk_display(curr_psk)}")
            info("  1) PUBLIC MESH (AQ==)  2) PRIVATE (passphrase)")
            psk_choice = input(f"  Type [{curr_psk_choice}]: ").strip() or curr_psk_choice
            if psk_choice == "1":
                new_psk = PUBLIC_PSK
                ch_name_for_psk = ch_name
            else:
                pp_input = input("  Passphrase (Enter = keep current, min 4): ").strip()
                if pp_input and len(pp_input) >= 4:
                    new_psk = derive_channel_psk(ch_name, pp_input)
                    if shared_pass is None and num_ch > 1:
                        use_as_shared = input("  Use as shared passphrase for other channels? [y/N]: ").strip().lower()
                        if use_as_shared in ("y", "yes"):
                            shared_pass = pp_input
                elif not pp_input and len(curr_psk) > 0:
                    new_psk = curr_psk   # keep current
                else:
                    warn("Invalid passphrase, keeping current")
                    new_psk = curr_psk
        else:
            # CH1+
            info(f"  Current PSK: {psk_display(curr_psk)}")
            info("  1) Derive from shared passphrase  2) Custom passphrase  3) PUBLIC  Enter=keep")
            psk_ch = input("  Choice: ").strip()
            if psk_ch == "1" and shared_pass:
                new_psk = derive_channel_psk(ch_name, shared_pass)
            elif psk_ch == "2":
                while True:
                    pp_input = input("  Passphrase (min 4): ").strip()
                    if len(pp_input) >= 4: break
                    warn("Too short")
                new_psk = derive_channel_psk(ch_name, pp_input)
            elif psk_ch == "3":
                new_psk = PUBLIC_PSK
            else:
                new_psk = curr_psk

        new_pp = prompt_int(f"  CH{i} position precision", curr_pp)
        role   = channel_pb2.Channel.PRIMARY if i == 0 else channel_pb2.Channel.SECONDARY

        info(f"  → CH{i} {ch_name}  psk={psk_display(new_psk)}  pp={new_pp}")
        channels_cfg.append({
            "index": i,
            "name":  ch_name,
            "psk":   new_psk,
            "role":  role,
            "pp":    new_pp,
        })

    # ── LoRa ──
    subsection("LORA RADIO")
    curr_region = REGION_NAMES.get(curr.config_lora.region, "US") if curr.config_lora else D["region"]
    curr_preset = MODEM_PRESET_NAMES.get(curr.config_lora.modem_preset, D["modem_preset"]) if curr.config_lora else D["modem_preset"]
    curr_tx     = curr.config_lora.tx_power if curr.config_lora else D["tx_power"]
    curr_hops   = curr.config_lora.hop_limit if curr.config_lora else D["hop_limit"]

    region_str  = prompt("Region", curr_region, list(REGION_CODES.keys())[:6] + ["..."])
    region_str  = region_str.upper()
    if region_str not in REGION_CODES:
        warn(f"Unknown region '{region_str}', using {curr_region}")
        region_str = curr_region

    preset_str  = prompt("Modem preset", curr_preset)
    preset_str  = preset_str.upper()
    if preset_str not in MODEM_PRESETS:
        warn(f"Unknown preset '{preset_str}', using {curr_preset}")
        preset_str = curr_preset

    tx_power    = prompt_int("TX power (dBm)", curr_tx)
    hop_limit   = prompt_int("Hop limit", curr_hops)

    region_int  = REGION_CODES[region_str]
    preset_int  = MODEM_PRESETS[preset_str]

    # ── Device ──
    subsection("DEVICE")
    curr_role = DEVICE_ROLE_NAMES.get(curr.config_device.role, D["role"]) if curr.config_device else D["role"]
    curr_nodeinfo = curr.config_device.node_info_broadcast_secs if curr.config_device else D["node_info_broadcast_secs"]
    role_str = prompt("Role", curr_role, list(DEVICE_ROLES.keys())[:4])
    role_str = role_str.upper()
    if role_str not in DEVICE_ROLES: role_str = curr_role
    node_info_secs = prompt_int("NodeInfo broadcast interval (s)", curr_nodeinfo)
    role_int = DEVICE_ROLES[role_str]

    # ── Position ──
    subsection("GPS / POSITION")
    curr_gps_mode  = GPS_MODE_NAMES.get(curr.config_position.gps_mode, D["gps_mode"]) if curr.config_position else D["gps_mode"]
    curr_gps_int   = curr.config_position.gps_update_interval if curr.config_position else D["gps_update_interval"]
    curr_bcast     = curr.config_position.position_broadcast_secs if curr.config_position else D["position_broadcast_secs"]
    curr_smart     = curr.config_position.position_broadcast_smart_enabled if curr.config_position else D["smart_enabled"]
    curr_smin_s    = curr.config_position.broadcast_smart_minimum_interval_secs if curr.config_position else D["smart_min_secs"]
    curr_smin_d    = curr.config_position.broadcast_smart_minimum_distance if curr.config_position else D["smart_min_dist"]

    gps_mode_str   = prompt("GPS mode", curr_gps_mode, ["ENABLED", "DISABLED", "NOT_PRESENT"])
    gps_mode_str   = gps_mode_str.upper()
    if gps_mode_str not in GPS_MODES: gps_mode_str = curr_gps_mode
    gps_mode_int   = GPS_MODES[gps_mode_str]
    gps_interval   = prompt_int("GPS update interval (s)", curr_gps_int)
    bcast_secs     = prompt_int("Position broadcast interval (s)", curr_bcast)
    smart_enabled  = prompt_bool("Smart positioning", curr_smart)
    smart_min_secs = prompt_int("Smart min interval (s)", curr_smin_s) if smart_enabled else curr_smin_s
    smart_min_dist = prompt_int("Smart min distance (m)", curr_smin_d) if smart_enabled else curr_smin_d

    # ── Bluetooth ──
    subsection("BLUETOOTH")
    curr_bt_en   = curr.config_bluetooth.enabled if curr.config_bluetooth else D["bt_enabled"]
    curr_bt_mode = BT_MODE_NAMES.get(curr.config_bluetooth.mode, D["bt_mode"]) if curr.config_bluetooth else D["bt_mode"]
    bt_enabled = prompt_bool("Bluetooth enabled", curr_bt_en)
    bt_mode_str = prompt("Pairing mode", curr_bt_mode, ["RANDOM_PIN", "FIXED_PIN", "NO_PIN"])
    bt_mode_str = bt_mode_str.upper()
    if bt_mode_str not in BT_MODES: bt_mode_str = curr_bt_mode
    bt_mode_int = BT_MODES[bt_mode_str]

    # ── Summary ──
    subsection("SUMMARY")
    info(f"Identity:   {long_name} ({short_name})")
    for ch in channels_cfg:
        info(f"CH{ch['index']} {CHANNEL_ROLE_NAMES.get(ch['role'],'?'):<10} {ch['name']:<12} psk={psk_display(ch['psk'])}  pp={ch['pp']}")
    info(f"LoRa:       region={region_str} preset={preset_str} tx={tx_power}dBm hops={hop_limit}")
    info(f"Device:     role={role_str} nodeinfo={node_info_secs}s")
    info(f"Position:   gps={gps_mode_str} interval={gps_interval}s broadcast={bcast_secs}s smart={smart_enabled}")
    info(f"Bluetooth:  enabled={bt_enabled} mode={bt_mode_str}")

    if input("\n  Proceed? [y/N]: ").strip().lower() not in ("y", "yes"):
        return

    # Reconnect fresh for writes — BLE was dropped after drain
    info("Reconnecting for write phase...")
    ble = MeshtasticBLE(address)
    if not await ble.connect(): err("Reconnect failed"); return

    # ── Write — optimal order with skip-if-no-change ──
    await _do_full_setup(
        ble=ble, address=address,
        long_name=long_name, short_name=short_name,
        channels_cfg=channels_cfg,
        region_int=region_int, preset_int=preset_int,
        tx_power=tx_power, hop_limit=hop_limit,
        role_int=role_int, node_info_secs=node_info_secs,
        gps_mode_int=gps_mode_int, gps_interval=gps_interval,
        bcast_secs=bcast_secs, smart_enabled=smart_enabled,
        smart_min_secs=smart_min_secs, smart_min_dist=smart_min_dist,
        bt_enabled=bt_enabled, bt_mode_int=bt_mode_int,
        curr=curr,
    )


# ── 3. Quick setup from file ───────────────────────────────────────────────

async def menu_setup_from_file(address: str):
    section("QUICK SETUP FROM FILE")

    # Load file first (no BLE needed)
    path = pick_file(label="SELECT CONFIG FILE", keys_only=False)
    if path is None:
        info("Cancelled"); return
    if not os.path.exists(path):
        err(f"File not found: {path}"); return

    try:
        d = load_config_file(path)
    except Exception as e:
        err(f"Could not load file: {e}"); return

    ok(f"Loaded: {path}")
    meta     = d.get("_meta", {})
    identity = d.get("identity", {})
    file_long  = identity.get("long_name", "")
    file_short = identity.get("short_name", "")
    info(f"  Saved: {meta.get('saved','?')}  from node: {meta.get('node_id','?')}")

    # Connect to radio and drain — show both identities side by side
    info("\nConnecting to read current device identity...")
    ble_tmp = MeshtasticBLE(address)
    if not await ble_tmp.connect():
        err("Connection failed"); return
    radio_long  = ble_tmp.state.owner_long
    radio_short = ble_tmp.state.owner_short
    radio_id    = ble_tmp.state.node_id
    curr = ble_tmp.state
    await ble_tmp.disconnect()

    subsection("IDENTITY COMPARISON")
    info(f"  {'':20}  {'RADIO':<24}  FILE")
    info(f"  {'Node ID':<20}  {radio_id:<24}  {meta.get('node_id','?')}")
    info(f"  {'Long name':<20}  {radio_long:<24}  {file_long}")
    info(f"  {'Short name':<20}  {radio_short:<24}  {file_short}")
    print()

    new_long  = (input(f"  Long name to apply  [{file_long}]: ").strip() or file_long)
    new_short = (input(f"  Short name to apply [{file_short}]: ").strip() or file_short)[:4]
    if not new_long or not new_short:
        err("Names required"); return

    # Channels
    ch_file = d.get("channels", [])
    info(f"\n  Channels in file: {len(ch_file)}")
    for ch in ch_file:
        info(f"  CH{ch['index']} {ch['role']:<10} {ch['name']:<12} psk={ch['psk_display']}")

    channels_cfg: List[Dict] = []
    for ch in ch_file:
        psk = psk_from_b64(ch["psk_b64"])
        role_int = CHANNEL_ROLES.get(ch["role"], channel_pb2.Channel.DISABLED)
        channels_cfg.append({
            "index": ch["index"],
            "name":  ch["name"],
            "psk":   psk,
            "role":  role_int,
            "pp":    ch.get("position_precision", 0),
        })

    # LoRa
    lora = d.get("lora", {})
    region_str  = lora.get("region", ZEROCOMM_DEFAULTS["region"])
    preset_str  = lora.get("modem_preset", ZEROCOMM_DEFAULTS["modem_preset"])
    tx_power    = lora.get("tx_power", ZEROCOMM_DEFAULTS["tx_power"])
    hop_limit   = lora.get("hop_limit", ZEROCOMM_DEFAULTS["hop_limit"])
    if region_str not in REGION_CODES: region_str = ZEROCOMM_DEFAULTS["region"]
    if preset_str not in MODEM_PRESETS: preset_str = ZEROCOMM_DEFAULTS["modem_preset"]

    # Device
    dev = d.get("device", {})
    role_str       = dev.get("role", ZEROCOMM_DEFAULTS["role"])
    node_info_secs = dev.get("node_info_broadcast_secs", ZEROCOMM_DEFAULTS["node_info_broadcast_secs"])
    if role_str not in DEVICE_ROLES: role_str = ZEROCOMM_DEFAULTS["role"]

    # Position
    pos = d.get("position", {})
    gps_mode_str   = pos.get("gps_mode", ZEROCOMM_DEFAULTS["gps_mode"])
    gps_interval   = pos.get("gps_update_interval", ZEROCOMM_DEFAULTS["gps_update_interval"])
    bcast_secs     = pos.get("position_broadcast_secs", ZEROCOMM_DEFAULTS["position_broadcast_secs"])
    smart_enabled  = pos.get("position_broadcast_smart_enabled", ZEROCOMM_DEFAULTS["smart_enabled"])
    smart_min_secs = pos.get("broadcast_smart_minimum_interval_secs", ZEROCOMM_DEFAULTS["smart_min_secs"])
    smart_min_dist = pos.get("broadcast_smart_minimum_distance", ZEROCOMM_DEFAULTS["smart_min_dist"])
    if gps_mode_str not in GPS_MODES: gps_mode_str = ZEROCOMM_DEFAULTS["gps_mode"]

    # Bluetooth
    bt_d       = d.get("bluetooth", {})
    bt_enabled = bt_d.get("enabled", ZEROCOMM_DEFAULTS["bt_enabled"])
    bt_mode_str = bt_d.get("mode", ZEROCOMM_DEFAULTS["bt_mode"])
    if bt_mode_str not in BT_MODES: bt_mode_str = ZEROCOMM_DEFAULTS["bt_mode"]

    region_int  = REGION_CODES[region_str]
    preset_int  = MODEM_PRESETS[preset_str]
    role_int    = DEVICE_ROLES[role_str]
    gps_mode_int = GPS_MODES[gps_mode_str]
    bt_mode_int  = BT_MODES[bt_mode_str]

    # Summary
    subsection("WILL APPLY")
    info(f"Identity:   {new_long} ({new_short})")
    for ch in channels_cfg:
        info(f"CH{ch['index']} {CHANNEL_ROLE_NAMES.get(ch['role'],'?'):<10} {ch['name']:<12} psk={psk_display(ch['psk'])}  pp={ch['pp']}")
    info(f"LoRa:       region={region_str} preset={preset_str} tx={tx_power}dBm hops={hop_limit}")
    info(f"Device:     role={role_str} nodeinfo={node_info_secs}s")
    info(f"Position:   gps={gps_mode_str} interval={gps_interval}s broadcast={bcast_secs}s smart={smart_enabled}")
    info(f"Bluetooth:  enabled={bt_enabled} mode={bt_mode_str}")

    if input("\n  Proceed? [y/N]: ").strip().lower() not in ("y", "yes"):
        return

    ble = MeshtasticBLE(address)
    if not await ble.connect(): err("Connection failed"); return

    curr = ble.state

    await _do_full_setup(
        ble=ble, address=address,
        long_name=new_long, short_name=new_short,
        channels_cfg=channels_cfg,
        region_int=region_int, preset_int=preset_int,
        tx_power=tx_power, hop_limit=hop_limit,
        role_int=role_int, node_info_secs=node_info_secs,
        gps_mode_int=gps_mode_int, gps_interval=gps_interval,
        bcast_secs=bcast_secs, smart_enabled=smart_enabled,
        smart_min_secs=smart_min_secs, smart_min_dist=smart_min_dist,
        bt_enabled=bt_enabled, bt_mode_int=bt_mode_int,
        curr=curr,
    )


# ── _do_full_setup — shared write engine ──────────────────────────────────

async def _do_full_setup(
    ble: MeshtasticBLE, address: str,
    long_name: str, short_name: str,
    channels_cfg: List[Dict],
    region_int: int, preset_int: int, tx_power: int, hop_limit: int,
    role_int: int, node_info_secs: int,
    gps_mode_int: int, gps_interval: int, bcast_secs: int,
    smart_enabled: bool, smart_min_secs: int, smart_min_dist: int,
    bt_enabled: bool, bt_mode_int: int,
    curr: DeviceState,
):
    D = ZEROCOMM_DEFAULTS
    total_steps = 0
    step = 0

    # Pre-compute what needs writing
    write_owner    = (long_name != curr.owner_long or short_name != curr.owner_short)
    write_channels = _channels_changed(channels_cfg, curr)

    curr_lora = curr.config_lora
    write_lora = (not curr_lora
                  or curr_lora.region       != region_int
                  or curr_lora.modem_preset != preset_int
                  or curr_lora.tx_power     != tx_power
                  or curr_lora.hop_limit    != hop_limit)

    curr_dev = curr.config_device
    write_device = (not curr_dev
                    or curr_dev.role != role_int
                    or curr_dev.node_info_broadcast_secs != node_info_secs)

    curr_pos = curr.config_position
    write_position = (not curr_pos
                      or curr_pos.gps_mode                           != gps_mode_int
                      or curr_pos.gps_update_interval                != gps_interval
                      or curr_pos.position_broadcast_secs            != bcast_secs
                      or curr_pos.position_broadcast_smart_enabled   != smart_enabled
                      or curr_pos.broadcast_smart_minimum_interval_secs != smart_min_secs
                      or curr_pos.broadcast_smart_minimum_distance   != smart_min_dist)

    curr_bt = curr.config_bluetooth
    write_bt = (not curr_bt
                or curr_bt.enabled != bt_enabled
                or curr_bt.mode    != bt_mode_int)

    total_steps = (int(write_owner) + int(bool(write_channels)) +
                   int(write_device) + int(write_position) +
                   int(write_bt) + int(write_lora))

    if total_steps == 0:
        ok("No changes required — device already matches desired configuration")
        await ble.disconnect()
        return

    info(f"\n  {total_steps} section(s) will be written.")

    # ── owner (no reboot) ──
    if write_owner:
        step += 1
        subsection(f"Step {step}/{total_steps}: set_owner")
        ok_w = await ble.write_admin(build_set_owner(long_name, short_name))
        if not ok_w: err("Write failed"); await ble.disconnect(); return
        ok("Owner written")
        await asyncio.sleep(POST_WRITE_DELAY)
    else:
        info("Owner: no change, skipping")

    # ── channels (no reboot) ──
    if write_channels:
        step += 1
        subsection(f"Step {step}/{total_steps}: set_channel × {len(write_channels)}")
        for ch in write_channels:
            ok_w = await ble.write_admin(build_set_channel(
                ch["index"], ch["name"], ch["psk"], ch["role"], ch["pp"]))
            if not ok_w: err(f"Channel {ch['index']} write failed"); await ble.disconnect(); return
            ok(f"Channel {ch['index']} ({ch['name']}) written")
            await asyncio.sleep(0.3)
    else:
        info("Channels: no change, skipping")

    # ── device config (reboot) ──
    if write_device:
        step += 1
        subsection(f"Step {step}/{total_steps}: set_config(device) → REBOOT")
        ok_w = await ble.write_admin(
            build_set_config_device(role_int, node_info_secs), expect_reboot=True)
        if not ok_w: err("Write failed"); await ble.disconnect(); return
        ok("Device config written — rebooting...")
        if not await reconnect_and_verify(ble, reboot_wait=True):
            await ble.disconnect(); return
        v = verify_device(ble.state, role_int, node_info_secs)
        ok("Device config verified") if v else warn("Device config verification failed")
    else:
        info("Device config: no change, skipping")

    # ── position config (reboot) ──
    if write_position:
        step += 1
        subsection(f"Step {step}/{total_steps}: set_config(position) → REBOOT")
        ok_w = await ble.write_admin(
            build_set_config_position(gps_mode_int, gps_interval, bcast_secs,
                                      smart_enabled, smart_min_secs, smart_min_dist,
                                      D["position_flags"]), expect_reboot=True)
        if not ok_w: err("Write failed"); await ble.disconnect(); return
        ok("Position config written — rebooting...")
        if not await reconnect_and_verify(ble, reboot_wait=True):
            await ble.disconnect(); return
        v = verify_position(ble.state, gps_mode_int, gps_interval, bcast_secs,
                            smart_enabled, smart_min_secs, smart_min_dist)
        ok("Position config verified") if v else warn("Position config verification failed")
    else:
        info("Position config: no change, skipping")

    # ── bluetooth config (reboot) ──
    if write_bt:
        step += 1
        subsection(f"Step {step}/{total_steps}: set_config(bluetooth) → REBOOT")
        ok_w = await ble.write_admin(
            build_set_config_bluetooth(bt_enabled, bt_mode_int), expect_reboot=True)
        if not ok_w: err("Write failed"); await ble.disconnect(); return
        ok("Bluetooth config written — rebooting...")
        if not await reconnect_and_verify(ble, reboot_wait=True):
            await ble.disconnect(); return
        v = verify_bluetooth(ble.state, bt_enabled, bt_mode_int)
        ok("Bluetooth config verified") if v else warn("Bluetooth config verification failed")
    else:
        info("Bluetooth config: no change, skipping")

    # ── lora config (reboot — always last) ──
    if write_lora:
        step += 1
        subsection(f"Step {step}/{total_steps}: set_config(lora) → REBOOT (final)")
        ok_w = await ble.write_admin(
            build_set_config_lora(region_int, preset_int, tx_power, hop_limit),
            expect_reboot=True)
        if not ok_w: err("Write failed"); await ble.disconnect(); return
        ok("LoRa config written — final reboot...")
        if not await reconnect_and_verify(ble, reboot_wait=True):
            await ble.disconnect(); return
        v = verify_lora(ble.state, region_int, preset_int, tx_power, hop_limit)
        ok("LoRa config verified") if v else warn("LoRa config verification failed")
    else:
        info("LoRa config: no change, skipping")

    # ── final owner + channel verification (always) ──
    subsection("FINAL VERIFICATION")
    if write_owner:
        v = verify_owner(ble.state, long_name, short_name)
        ok("Owner verified") if v else warn("Owner verification failed")

    if write_channels:
        exp = [{"index": c["index"], "name": c["name"], "psk": c["psk"], "role": c["role"]}
               for c in channels_cfg]
        v = verify_channels(ble.state, exp)
        ok("Channels verified") if v else warn("Channel verification failed")

    ble.state.print_config()
    ok("Setup complete")
    await ble.disconnect()


def _channels_changed(desired: List[Dict], curr: DeviceState) -> List[Dict]:
    """Return list of channels that differ from current state (need writing)."""
    changed = []
    for ch in desired:
        idx = ch["index"]
        existing = next((c for c in curr.channels if c.index == idx), None)
        if existing is None:
            changed.append(ch); continue
        curr_pp = (existing.settings.module_settings.position_precision
                   if existing.settings.HasField("module_settings") else 0)
        if (existing.settings.name != ch["name"]
                or existing.settings.psk  != ch["psk"]
                or existing.role          != ch["role"]
                or curr_pp                != ch["pp"]):
            changed.append(ch)
    return changed


# ── 4. Set owner only ─────────────────────────────────────────────────────

async def menu_set_owner(address: str):
    section("SET OWNER")
    ble = MeshtasticBLE(address)
    if not await ble.connect(): err("Connection failed"); return

    curr = ble.state
    info(f"  Current: {curr.owner_long} ({curr.owner_short})")
    long_name  = input(f"  Long name [{curr.owner_long}]: ").strip() or curr.owner_long
    short_name = (input(f"  Short name [{curr.owner_short}]: ").strip() or curr.owner_short)[:4]

    if long_name == curr.owner_long and short_name == curr.owner_short:
        ok("No change — skipping"); await ble.disconnect(); return

    ok_w = await ble.write_admin(build_set_owner(long_name, short_name))
    if not ok_w: err("Write failed"); await ble.disconnect(); return
    ok("Owner written")

    await asyncio.sleep(POST_WRITE_DELAY)
    if not await reconnect_and_verify(ble, reboot_wait=False):
        return
    v = verify_owner(ble.state, long_name, short_name)
    ok("Owner verified") if v else warn("Owner verification failed — check device")
    await ble.disconnect()


# ── 5. Set channels only ──────────────────────────────────────────────────

async def menu_set_channels(address: str):
    section("SET CHANNELS")
    ble = MeshtasticBLE(address)
    if not await ble.connect(): err("Connection failed"); return

    curr = ble.state
    info("Current channels:")
    for ch in curr.active_channels():
        info(f"  CH{ch.index} {CHANNEL_ROLE_NAMES.get(ch.role,'?'):<10} {ch.settings.name:<12} {psk_display(ch.settings.psk)}")

    info("\nEnter channel index to edit (or blank to finish):")
    channels_cfg: List[Dict] = []
    shared_pass: Optional[str] = None

    while True:
        raw = input("  Channel index (0-7, blank=done): ").strip()
        if not raw: break
        try:
            idx = int(raw)
            if not (0 <= idx <= 7): raise ValueError
        except ValueError:
            warn("Invalid index"); continue

        existing = next((ch for ch in curr.channels if ch.index == idx), None)
        curr_name = existing.settings.name if existing else ("General" if idx == 0 else f"CH{idx}")
        curr_psk  = existing.settings.psk if existing else b""
        curr_role = existing.role if existing else (channel_pb2.Channel.PRIMARY if idx == 0 else channel_pb2.Channel.SECONDARY)
        curr_pp   = (existing.settings.module_settings.position_precision
                     if existing and existing.settings.HasField("module_settings") else 0)

        ch_name = (input(f"  CH{idx} name [{curr_name}]: ").strip() or curr_name)

        if idx == 0:
            info(f"  Current PSK: {psk_display(curr_psk)}")
            info("  1) PUBLIC (AQ==)  2) PRIVATE  Enter=keep")
            psk_ch = input("  Choice: ").strip()
            if psk_ch == "1":
                new_psk = PUBLIC_PSK
            elif psk_ch == "2":
                while True:
                    pp_i = input("  Passphrase (min 4): ").strip()
                    if len(pp_i) >= 4: break
                    warn("Too short")
                new_psk = derive_channel_psk(ch_name, pp_i)
            else:
                new_psk = curr_psk
        else:
            info(f"  Current PSK: {psk_display(curr_psk)}")
            info("  1) Shared passphrase  2) Custom  3) PUBLIC  Enter=keep")
            psk_ch = input("  Choice: ").strip()
            if psk_ch == "1":
                if shared_pass is None:
                    shared_pass = input("  Shared passphrase: ").strip()
                new_psk = derive_channel_psk(ch_name, shared_pass)
            elif psk_ch == "2":
                while True:
                    pp_i = input("  Passphrase (min 4): ").strip()
                    if len(pp_i) >= 4: break
                    warn("Too short")
                new_psk = derive_channel_psk(ch_name, pp_i)
            elif psk_ch == "3":
                new_psk = PUBLIC_PSK
            else:
                new_psk = curr_psk

        new_pp = prompt_int(f"  CH{idx} position precision", curr_pp)
        role   = channel_pb2.Channel.PRIMARY if idx == 0 else channel_pb2.Channel.SECONDARY

        info(f"  → CH{idx} {ch_name}  {psk_display(new_psk)}  pp={new_pp}")
        channels_cfg.append({"index": idx, "name": ch_name, "psk": new_psk, "role": role, "pp": new_pp})

    if not channels_cfg:
        info("No channels selected"); await ble.disconnect(); return

    changed = _channels_changed(channels_cfg, curr)
    if not changed:
        ok("No changes — skipping"); await ble.disconnect(); return

    info(f"\n  Writing {len(changed)} channel(s)...")
    for ch in changed:
        ok_w = await ble.write_admin(build_set_channel(
            ch["index"], ch["name"], ch["psk"], ch["role"], ch["pp"]))
        if not ok_w: err(f"CH{ch['index']} write failed"); await ble.disconnect(); return
        ok(f"Channel {ch['index']} written")
        await asyncio.sleep(0.3)

    if not await reconnect_and_verify(ble, reboot_wait=False):
        return
    exp = [{"index": c["index"], "name": c["name"], "psk": c["psk"], "role": c["role"]}
           for c in changed]
    v = verify_channels(ble.state, exp)
    ok("Channels verified") if v else warn("Channel verification failed")
    await ble.disconnect()


# ── 6. Set device config ──────────────────────────────────────────────────

async def menu_set_device(address: str):
    section("SET DEVICE CONFIG")
    ble = MeshtasticBLE(address)
    if not await ble.connect(): err("Connection failed"); return

    curr = ble.state.config_device
    curr_role     = DEVICE_ROLE_NAMES.get(curr.role, "CLIENT") if curr else "CLIENT"
    curr_nodeinfo = curr.node_info_broadcast_secs if curr else ZEROCOMM_DEFAULTS["node_info_broadcast_secs"]

    role_str = prompt("Role", curr_role, list(DEVICE_ROLES.keys())[:4]).upper()
    if role_str not in DEVICE_ROLES: role_str = curr_role
    role_int = DEVICE_ROLES[role_str]
    node_info_secs = prompt_int("NodeInfo broadcast interval (s)", curr_nodeinfo)

    if curr and curr.role == role_int and curr.node_info_broadcast_secs == node_info_secs:
        ok("No change — skipping"); await ble.disconnect(); return

    ok_w = await ble.write_admin(build_set_config_device(role_int, node_info_secs), expect_reboot=True)
    if not ok_w: err("Write failed"); await ble.disconnect(); return
    ok("Device config written — rebooting...")
    if not await reconnect_and_verify(ble, reboot_wait=True): return
    v = verify_device(ble.state, role_int, node_info_secs)
    ok("Device config verified") if v else warn("Verification failed")
    await ble.disconnect()


# ── 7. Set position config ────────────────────────────────────────────────

async def menu_set_position(address: str):
    section("SET POSITION CONFIG")
    D = ZEROCOMM_DEFAULTS
    ble = MeshtasticBLE(address)
    if not await ble.connect(): err("Connection failed"); return

    p = ble.state.config_position
    curr_gps_mode  = GPS_MODE_NAMES.get(p.gps_mode, D["gps_mode"]) if p else D["gps_mode"]
    curr_gps_int   = p.gps_update_interval if p else D["gps_update_interval"]
    curr_bcast     = p.position_broadcast_secs if p else D["position_broadcast_secs"]
    curr_smart     = p.position_broadcast_smart_enabled if p else D["smart_enabled"]
    curr_smin_s    = p.broadcast_smart_minimum_interval_secs if p else D["smart_min_secs"]
    curr_smin_d    = p.broadcast_smart_minimum_distance if p else D["smart_min_dist"]

    gps_mode_str  = prompt("GPS mode", curr_gps_mode, ["ENABLED", "DISABLED", "NOT_PRESENT"]).upper()
    if gps_mode_str not in GPS_MODES: gps_mode_str = curr_gps_mode
    gps_mode_int  = GPS_MODES[gps_mode_str]
    gps_interval  = prompt_int("GPS update interval (s)", curr_gps_int)
    bcast_secs    = prompt_int("Position broadcast interval (s)", curr_bcast)
    smart_enabled = prompt_bool("Smart positioning", curr_smart)
    smart_min_secs = prompt_int("Smart min interval (s)", curr_smin_s) if smart_enabled else curr_smin_s
    smart_min_dist = prompt_int("Smart min distance (m)", curr_smin_d) if smart_enabled else curr_smin_d

    if (p and p.gps_mode == gps_mode_int
            and p.gps_update_interval == gps_interval
            and p.position_broadcast_secs == bcast_secs
            and p.position_broadcast_smart_enabled == smart_enabled
            and p.broadcast_smart_minimum_interval_secs == smart_min_secs
            and p.broadcast_smart_minimum_distance == smart_min_dist):
        ok("No change — skipping"); await ble.disconnect(); return

    ok_w = await ble.write_admin(build_set_config_position(
        gps_mode_int, gps_interval, bcast_secs,
        smart_enabled, smart_min_secs, smart_min_dist, D["position_flags"]), expect_reboot=True)
    if not ok_w: err("Write failed"); await ble.disconnect(); return
    ok("Position config written — rebooting...")
    if not await reconnect_and_verify(ble, reboot_wait=True): return
    v = verify_position(ble.state, gps_mode_int, gps_interval, bcast_secs,
                        smart_enabled, smart_min_secs, smart_min_dist)
    ok("Position config verified") if v else warn("Verification failed")
    await ble.disconnect()


# ── 8. Set bluetooth + lora ───────────────────────────────────────────────

async def menu_set_bt_lora(address: str):
    section("SET BLUETOOTH + LORA CONFIG")
    D = ZEROCOMM_DEFAULTS
    ble = MeshtasticBLE(address)
    if not await ble.connect(): err("Connection failed"); return

    # Bluetooth
    b = ble.state.config_bluetooth
    curr_bt_en   = b.enabled if b else D["bt_enabled"]
    curr_bt_mode = BT_MODE_NAMES.get(b.mode, D["bt_mode"]) if b else D["bt_mode"]
    subsection("BLUETOOTH")
    bt_enabled  = prompt_bool("Bluetooth enabled", curr_bt_en)
    bt_mode_str = prompt("Pairing mode", curr_bt_mode, ["RANDOM_PIN", "FIXED_PIN", "NO_PIN"]).upper()
    if bt_mode_str not in BT_MODES: bt_mode_str = curr_bt_mode
    bt_mode_int = BT_MODES[bt_mode_str]

    # LoRa
    l = ble.state.config_lora
    curr_region = REGION_NAMES.get(l.region, D["region"]) if l else D["region"]
    curr_preset = MODEM_PRESET_NAMES.get(l.modem_preset, D["modem_preset"]) if l else D["modem_preset"]
    curr_tx     = l.tx_power if l else D["tx_power"]
    curr_hops   = l.hop_limit if l else D["hop_limit"]
    subsection("LORA RADIO")
    region_str  = prompt("Region", curr_region).upper()
    if region_str not in REGION_CODES: region_str = curr_region
    preset_str  = prompt("Modem preset", curr_preset).upper()
    if preset_str not in MODEM_PRESETS: preset_str = curr_preset
    tx_power    = prompt_int("TX power (dBm)", curr_tx)
    hop_limit   = prompt_int("Hop limit", curr_hops)
    region_int  = REGION_CODES[region_str]
    preset_int  = MODEM_PRESETS[preset_str]

    write_bt  = (not b or b.enabled != bt_enabled or b.mode != bt_mode_int)
    write_lora = (not l or l.region != region_int or l.modem_preset != preset_int
                  or l.tx_power != tx_power or l.hop_limit != hop_limit)

    if not write_bt and not write_lora:
        ok("No changes — skipping"); await ble.disconnect(); return

    if write_bt:
        subsection("Writing bluetooth → REBOOT")
        ok_w = await ble.write_admin(build_set_config_bluetooth(bt_enabled, bt_mode_int), expect_reboot=True)
        if not ok_w: err("Write failed"); await ble.disconnect(); return
        ok("Bluetooth written — rebooting...")
        if not await reconnect_and_verify(ble, reboot_wait=True): return
        v = verify_bluetooth(ble.state, bt_enabled, bt_mode_int)
        ok("Bluetooth verified") if v else warn("Verification failed")
    else:
        info("Bluetooth: no change, skipping")

    if write_lora:
        subsection("Writing lora → REBOOT")
        ok_w = await ble.write_admin(
            build_set_config_lora(region_int, preset_int, tx_power, hop_limit), expect_reboot=True)
        if not ok_w: err("Write failed"); await ble.disconnect(); return
        ok("LoRa written — rebooting...")
        if not await reconnect_and_verify(ble, reboot_wait=True): return
        v = verify_lora(ble.state, region_int, preset_int, tx_power, hop_limit)
        ok("LoRa verified") if v else warn("Verification failed")
    else:
        info("LoRa: no change, skipping")

    await ble.disconnect()


# ── 9. Read node keys → file ──────────────────────────────────────────────

async def menu_read_keys(address: str):
    section("READ NODE KEYS → FILE")
    warn("This saves your PRIVATE KEY to disk. Protect the file.")
    if input("  Continue? [y/N]: ").strip().lower() not in ("y", "yes"):
        return

    ble = MeshtasticBLE(address)
    if not await ble.connect(): err("Connection failed"); return

    sec = ble.state.config_security
    if not sec:
        err("Security config not received — cannot save keys")
        await ble.disconnect(); return

    fname = save_config_file(ble.state, include_keys=True)
    ok(f"Keys saved to: {fname}")
    info(f"  Public key:  {sec.public_key.hex()[:32]}...")
    info(f"  Private key: <{len(sec.private_key)} bytes — redacted in terminal>")
    if sec.admin_key:
        info(f"  Admin key:   {sec.admin_key.hex()[:32]}...")
    await ble.disconnect()


# ── 10. Write node keys from file ─────────────────────────────────────────

async def menu_write_keys(address: str):
    section("WRITE NODE KEYS FROM FILE")
    warn("Writing keys will overwrite the device's cryptographic identity.")
    warn("This cannot be undone without another backup.")

    path = pick_file(label="SELECT KEYS FILE", keys_only=True)
    if path is None:
        info("Cancelled"); return
    if not os.path.exists(path):
        err(f"File not found: {path}"); return

    try:
        d = load_config_file(path)
    except Exception as e:
        err(f"Could not load file: {e}"); return

    if not d.get("_meta", {}).get("include_keys"):
        err("This file does not contain keys (include_keys=false)"); return

    sec = d.get("security", {})
    pub_b64  = sec.get("public_key_b64", "")
    priv_b64 = sec.get("private_key_b64", "")
    admin_b64 = sec.get("admin_key_b64", "")

    if not pub_b64 or not priv_b64:
        err("File is missing public or private key"); return

    pub_key  = psk_from_b64(pub_b64)
    priv_key = psk_from_b64(priv_b64)
    admin_key = psk_from_b64(admin_b64) if admin_b64 else b""

    info(f"  Source node: {d.get('_meta',{}).get('node_id','?')}")
    info(f"  Public key:  {pub_key.hex()[:32]}...")
    info(f"  Private key: <{len(priv_key)} bytes>")
    if admin_key:
        info(f"  Admin key:   {admin_key.hex()[:32]}...")
    if input("  Write these keys to the device? [y/N]: ").strip().lower() not in ("y", "yes"):
        return

    ble = MeshtasticBLE(address)
    if not await ble.connect(): err("Connection failed"); return

    curr_sec = ble.state.config_security
    if curr_sec:
        if (curr_sec.public_key == pub_key
                and curr_sec.private_key == priv_key
                and curr_sec.admin_key == admin_key):
            ok("Keys already match — no change needed")
            await ble.disconnect(); return

    ok_w = await ble.write_admin(
        build_set_config_security(pub_key, priv_key, admin_key), expect_reboot=True)
    if not ok_w: err("Write failed"); await ble.disconnect(); return
    ok("Keys written — rebooting...")
    if not await reconnect_and_verify(ble, reboot_wait=True): return

    # Verify
    new_sec = ble.state.config_security
    if new_sec:
        info(f"[verify keys]  public_key: {new_sec.public_key.hex()[:32]}...")
        if new_sec.public_key != pub_key:
            warn("  MISMATCH: public_key")
        else:
            ok("Keys verified")
    else:
        warn("Could not verify — security config not received after reconnect")
    await ble.disconnect()


# ── 11. Factory reset config ──────────────────────────────────────────────

async def menu_factory_reset_config(address: str):
    section("FACTORY RESET — CONFIG ONLY")
    info("Resets all configuration to firmware defaults.")
    info("Preserves BLE pairing keys and node crypto keys.")
    if input("  Type 'RESET' to confirm: ").strip() != "RESET":
        info("Cancelled"); return

    ble = MeshtasticBLE(address)
    if not await ble.connect(): err("Connection failed"); return
    ok_w = await ble.write_admin(build_factory_reset(full=False), expect_reboot=True)
    if ok_w:
        ok("Factory reset (config) sent — device rebooting")
    else:
        err("Write failed")
    await ble.disconnect()


# ── 12. Factory reset full ────────────────────────────────────────────────

async def menu_factory_reset_full(address: str):
    section("FACTORY RESET — FULL (INCLUDING BLE + KEYS)")
    warn("This WIPES ALL DATA including node keys and BLE pairing.")
    warn("The device will become a new, unconfigured node.")
    if input("  Type 'WIPE' to confirm: ").strip() != "WIPE":
        info("Cancelled"); return

    ble = MeshtasticBLE(address)
    if not await ble.connect(): err("Connection failed"); return
    ok_w = await ble.write_admin(build_factory_reset(full=True), expect_reboot=True)
    if ok_w:
        ok("Full factory reset sent — device rebooting")
        warn("Re-pair BLE and reconfigure before use")
    else:
        err("Write failed")
    await ble.disconnect()


# ════════════════════════════════════════════════════════════════════════════
# MAIN MENU
# ════════════════════════════════════════════════════════════════════════════

async def main_menu(address: str):
    """12-item main menu."""
    while True:
        section("MESHTASTIC BLE ADMIN — MAIN MENU")
        print("   1)  Read config → file")
        print("   2)  Default setup (full interactive)")
        print("   3)  Quick setup from file")
        print("   4)  Set owner only")
        print("   5)  Set channels only")
        print("   6)  Set device config")
        print("   7)  Set position config")
        print("   8)  Set bluetooth + lora")
        print("   9)  Read node keys → file")
        print("  10)  Write node keys from file")
        print("  11)  Factory reset config (preserves keys)")
        print("  12)  Factory reset full (wipes everything)")
        print("   q)  Quit")
        print()

        choice = input("  Select: ").strip().lower()

        dispatch = {
            "1":  menu_read_config,
            "2":  menu_default_setup,
            "3":  menu_setup_from_file,
            "4":  menu_set_owner,
            "5":  menu_set_channels,
            "6":  menu_set_device,
            "7":  menu_set_position,
            "8":  menu_set_bt_lora,
            "9":  menu_read_keys,
            "10": menu_write_keys,
            "11": menu_factory_reset_config,
            "12": menu_factory_reset_full,
        }

        if choice in ("q", "quit", "exit", ""):
            print("  Goodbye!")
            break
        elif choice in dispatch:
            try:
                await dispatch[choice](address)
            except Exception as e:
                err(f"Error: {e}")
                import traceback; traceback.print_exc()
        else:
            warn("Invalid choice")


# ════════════════════════════════════════════════════════════════════════════
# ENTRYPOINT
# ════════════════════════════════════════════════════════════════════════════

async def main():
    parser = argparse.ArgumentParser(description="Meshtastic BLE Admin Tool")
    parser.add_argument("--addr", "-a", help="BLE address (skip scan)")
    parser.add_argument("--scan", "-s", action="store_true", help="Scan and exit")
    parser.add_argument("--debug", "-d", action="store_true", help="Full debug output")
    args = parser.parse_args()

    if not args.debug:
        global DEBUG_BLE, DEBUG_PROTO, DEBUG_DRAIN, DEBUG_ADMIN
        DEBUG_BLE   = False
        DEBUG_PROTO = False
        DEBUG_DRAIN = False
        DEBUG_ADMIN = True

    section("MESHTASTIC BLE ADMIN TOOL — ZeroComm Fleet Configuration")

    if args.addr:
        address = args.addr
    else:
        devices = await scan_for_devices()
        if not devices:
            err("No devices found."); return
        print(f"\n  Found {len(devices)} device(s):\n")
        for i, (addr, name, rssi) in enumerate(devices, 1):
            print(f"    {i}) {name:<20} {addr}  {rssi:>4} dBm {rssi_bar(rssi)}")

        if args.scan:
            return

        print()
        if len(devices) == 1:
            if input("  Connect? [Y/n]: ").strip().lower() in ("n", "no"):
                return
            address = devices[0][0]
        else:
            sel = input(f"  Select [1-{len(devices)}]: ").strip()
            try:
                idx = int(sel) - 1
                if 0 <= idx < len(devices):
                    address = devices[idx][0]
                else:
                    err("Invalid selection"); return
            except ValueError:
                err("Invalid selection"); return

    await main_menu(address)


# ════════════════════════════════════════════════════════════════════════════
# SIGNAL HANDLING + CLEANUP
# ════════════════════════════════════════════════════════════════════════════

if __name__ == "__main__":
    import atexit

    _active_ble: Optional[MeshtasticBLE] = None
    _cleanup_done = False

    def _sync_cleanup():
        global _cleanup_done, _active_ble
        if _cleanup_done:
            return
        _cleanup_done = True

        ble = _active_ble
        if ble is None:
            return

        print("\n  [CLEANUP] BLE cleanup requested...", flush=True)

        if ble.client is None:
            print("  [CLEANUP] No BLE client — nothing to close", flush=True)
            return

        loop = asyncio.new_event_loop()
        print("  [CLEANUP] Opening cleanup event loop...", flush=True)

        async def _do_disconnect():
            try:
                if ble.client and ble.client.is_connected:
                    print("  [CLEANUP] Sending BLE disconnect...", flush=True)
                    await asyncio.wait_for(ble.client.disconnect(), timeout=3.0)
                    print("  [CLEANUP] BLE disconnected cleanly", flush=True)
                else:
                    print("  [CLEANUP] BLE client not connected — nothing to disconnect", flush=True)
            except asyncio.TimeoutError:
                print("  [CLEANUP] BLE disconnect timed out (3s)", flush=True)
            except Exception as e:
                print(f"  [CLEANUP] BLE disconnect error: {type(e).__name__}: {e}", flush=True)

        try:
            loop.run_until_complete(_do_disconnect())
        except Exception as e:
            print(f"  [CLEANUP] Loop error: {type(e).__name__}: {e}", flush=True)
        finally:
            try:
                loop.close()
                print("  [CLEANUP] Event loop closed", flush=True)
            except Exception as e:
                print(f"  [CLEANUP] Loop close error: {e}", flush=True)

    def _signal_handler(signum, frame):
        sig_name = signal.Signals(signum).name
        print(f"\n  [SIGNAL] Received {sig_name} — shutting down...", flush=True)
        _sync_cleanup()
        import os
        os._exit(128 + signum)

    atexit.register(_sync_cleanup)
    signal.signal(signal.SIGINT,  _signal_handler)
    signal.signal(signal.SIGTERM, _signal_handler)

    # Track active BLE connection for cleanup
    _orig_connect    = MeshtasticBLE.connect
    _orig_disconnect = MeshtasticBLE.disconnect

    async def _tracked_connect(self, timeout=CONNECT_TIMEOUT):
        global _active_ble
        result = await _orig_connect(self, timeout)
        if result:
            _active_ble = self
        return result

    async def _tracked_disconnect(self):
        global _active_ble
        if _active_ble is self:
            _active_ble = None
        await _orig_disconnect(self)

    MeshtasticBLE.connect    = _tracked_connect
    MeshtasticBLE.disconnect = _tracked_disconnect

    exit_code = 0
    try:
        asyncio.run(main())
    except KeyboardInterrupt:
        print("\n  Interrupted.")
        exit_code = 130
    except Exception as e:
        print(f"\n  ERROR: {e}")
        import traceback; traceback.print_exc()
        exit_code = 1
    finally:
        _sync_cleanup()

    import os
    os._exit(exit_code)