feat(admin): manage repeaters remotely: status, neighbours, settings and access list

AGENTS.md

@@ -159,7 +159,7 @@ All commands below assume you are inside `nix develop`.
 | `MESHCORE_GPS_DEVICE` | GPS serial port; overrides auto-detection and gpsd (also in Settings > GPS Device) |
 | `MESHCORE_GPIO_CHIP` | `/dev/gpiochipN` number (default: 0; also in Settings > Hardware) |
 | `MESHCORE_USE_GPIOD_BACKEND=1` | Poll for IRQ edges instead of using kernel edge interrupts |
-| `MESHCORE_EN_PINS` | Comma-separated GPIO pins driven HIGH at init to power the radio (HG AIOv2: `27`) |
+| `MESHCORE_EN_PINS` | Comma-separated GPIO pins driven HIGH at init to power the radio (HG AIOv2: `16`) |
 
 Every hardware variable above overrides the matching value in Settings >
 Hardware. `_HARDWARE_ENV_OVERRIDES` in `meshcore/config.py` holds the whole
@@ -183,7 +183,8 @@ configured chip and lists what the host actually has:
 `HARDWARE_PRESETS` in `meshcore/settings.py` owns the per-board pinout,
 including `en_pins`: the LoRa power-enable line belongs to the board, so every
 preset states it, and a switch between boards clears a stale pin. The
-`hg-aiov2` preset is the uConsole pinout plus enable pin 27.
+`hg-aiov2` preset is the uConsole pinout plus LoRa enable pin 16 (27 is the
+AIOv2's GPS rail).
 
 `gpio_chip` is deliberately *not* in any preset. It follows the SoC and the
 kernel (CM4 vs CM5), not the radio board, so a preset must never clobber it.

README.md

@@ -153,9 +153,9 @@ command line. Notable radio bring-up flags:
 - `MESHCORE_GPIO_CHIP=15` — which `/dev/gpiochipN` carries the 40-pin header.
   It is 0 on CM4, but 15 on CM5 and Pi 5 kernels, where the header hangs off
   the RP1. `doctor` lists the chips your host actually has.
-- `MESHCORE_EN_PINS=27` — GPIO pins driven HIGH at init to power the radio.
-  The HackerGadgets AIOv2 enable pin is 27; the **uConsole HG AIOv2** board
-  preset sets this for you.
+- `MESHCORE_EN_PINS=16` — GPIO pins driven HIGH at init to power the radio.
+  The HackerGadgets AIOv2 LoRa enable pin is 16 (27 is its GPS rail); the
+  **uConsole HG AIOv2** board preset sets this for you.
 - `MESHCORE_USE_GPIOD_BACKEND=1` — poll for IRQ edges instead of asking the
   kernel for edge interrupts. Try this if the radio connects but receives
   nothing, which happens on kernels that reject the edge request.

src/meshcore_console/core/map_view.py

@@ -0,0 +1,61 @@
+"""Where the map opens: the last view, else this device, else the known peers."""
+
+from __future__ import annotations
+
+import math
+
+View = tuple[float, float, float]  # latitude, longitude, zoom level
+
+DEVICE_ZOOM = 12.0  # streets around this device
+WORLD: View = (20.0, 0.0, 2.0)
+MAX_ZOOM = 19.0
+
+
+def encode_view(lat: float, lon: float, zoom: float) -> str:
+    return f"{lat:.6f},{lon:.6f},{zoom:.2f}"
+
+
+def decode_view(raw: str | None) -> View | None:
+    """A stored view, or None if missing or not a sane view."""
+    try:
+        lat, lon, zoom = (float(part) for part in (raw or "").split(","))
+    except ValueError:
+        return None
+    if not (-90 <= lat <= 90 and -180 <= lon <= 180 and 0 <= zoom <= MAX_ZOOM):
+        return None
+    return lat, lon, zoom
+
+
+def fit_view(points: list[tuple[float, float]], width_px: int = 600, height_px: int = 400) -> View:
+    """Centre and zoom showing every point on a map about this size
+    (256-pixel tiles, Web Mercator; ignores the antimeridian)."""
+    if len(points) == 1:
+        return points[0][0], points[0][1], DEVICE_ZOOM
+    lats = [p[0] for p in points]
+    lons = [p[1] for p in points]
+    lat, lon = (min(lats) + max(lats)) / 2, (min(lons) + max(lons)) / 2
+    lat_span = max(max(lats) - min(lats), 1e-4)
+    lon_span = max(max(lons) - min(lons), 1e-4)
+    zoom_lon = math.log2(width_px * 360 / (256 * lon_span))
+    zoom_lat = math.log2(height_px * 360 * math.cos(math.radians(lat)) / (256 * lat_span))
+    return lat, lon, float(max(2, min(14, math.floor(min(zoom_lon, zoom_lat)))))
+
+
+def initial_view(
+    *,
+    gps_fix: tuple[float, float] | None,
+    saved: View | None,
+    device: tuple[float, float] | None,
+    peers: list[tuple[float, float]],
+) -> tuple[View, str]:
+    """The opening view and where it came from: "gps", "saved", "device"
+    (the fixed position from Settings), "peers" or "world"."""
+    if gps_fix is not None:
+        return (gps_fix[0], gps_fix[1], DEVICE_ZOOM), "gps"
+    if saved is not None:
+        return saved, "saved"
+    if device is not None:
+        return (device[0], device[1], DEVICE_ZOOM), "device"
+    if peers:
+        return fit_view(peers), "peers"
+    return WORLD, "world"

src/meshcore_console/core/models.py

@@ -2,6 +2,18 @@
 from datetime import UTC, datetime
 
 
+# DM threads live in their own channel-id namespace.  They used to share it with
+# group channels (both were the lowercased name), so a DM from "Test" landed in
+# #test and the reply was broadcast there, and "Message" on a node named
+# "Public" posted to the Public channel.
+DM_PREFIX = "dm:"
+
+
+def dm_channel_id(peer_name: str) -> str:
+    """The channel id of the DM thread with ``peer_name``."""
+    return DM_PREFIX + peer_name.lower()
+
+
 @dataclass(slots=True)
 class DeviceStatus:
     node_id: str
@@ -40,6 +52,8 @@ class Message:
     path_hops: list[str] = field(default_factory=list)
     snr: float | None = None
     rssi: int | None = None
+    # Outgoing DMs: True once ACKed, False if no ACK came; None otherwise (not stored).
+    delivered: bool | None = None
 
 
 @dataclass(slots=True)

src/meshcore_console/core/services.py

@@ -55,10 +55,22 @@ def list_messages_for_channel(self, channel_id: str, limit: int = 50) -> list[Me
 
     def send_message(self, peer_id: str, body: str) -> Message: ...
 
+    def is_private_channel(self, channel_id: str) -> bool:
+        """True for a group channel joined with its own (non-derivable) key."""
+        ...
+
+    def ensure_dm_channel(self, peer_name: str) -> Channel:
+        """The DM thread with ``peer_name`` (channel id ``dm:<name>``), created if needed."""
+        ...
+
     def send_advert(
         self, name: str | None = None, *, route_type: str = "flood"
     ) -> SendResultDict: ...
 
+    def discover_nodes(self) -> list[dict]:
+        """Zero-hop discover of nearby repeaters/sensors; blocks for the answer window."""
+        ...
+
     def poll_events(self, limit: int = 50) -> list[MeshEventDict]: ...
 
     def list_stored_packets(self, limit: int = 100) -> list[MeshEventDict]:
@@ -73,6 +85,12 @@ def update_settings(self, settings: MeshcoreSettings) -> None: ...
 
     def get_device_location(self) -> tuple[float, float] | None: ...
 
+    def get_map_view(self) -> tuple[float, float, float] | None:
+        """The map's last view (latitude, longitude, zoom), if one was saved."""
+        ...
+
+    def save_map_view(self, lat: float, lon: float, zoom: float) -> None: ...
+
     def is_mock_mode(self) -> bool:
         """Return True if running in mock mode."""
         ...
@@ -124,6 +142,22 @@ def logout_from_repeater(self, peer_name: str) -> None: ...
 
     def send_repeater_command(self, peer_name: str, command: str) -> dict: ...
 
+    def get_repeater_status(self, peer_name: str) -> dict | None:
+        """Repeater counters (battery, uptime, airtime, noise floor, packets); None on no reply."""
+        ...
+
+    def get_repeater_owner_info(self, peer_name: str) -> dict | None:
+        """{"version", "name", "owner_info"} from the repeater; None on no reply."""
+        ...
+
+    def get_repeater_neighbours(self, peer_name: str) -> list[dict] | None:
+        """[{"pubkey" (6-byte prefix), "name" or None, "secs_ago", "snr"}], newest first."""
+        ...
+
+    def get_repeater_access_list(self, peer_name: str) -> list[dict] | None:
+        """[{"key" (6-byte prefix), "role", "name" or None}]; admin login only."""
+        ...
+
     def get_repeater_login_state(self, peer_name: str) -> RepeaterLoginState | None: ...
 
     def list_logged_in_repeaters(self) -> list[str]: ...

src/meshcore_console/main.py

@@ -1,12 +1,16 @@
 from __future__ import annotations
 
 import argparse
+import os
 import asyncio
 import importlib.metadata
 import traceback
 
 
 def main() -> int:
+    # Everything the app writes is private: identity seed, database (channel
+    # secrets, repeater passwords, messages), logs and log exports.
+    os.umask(0o077)
     parser = argparse.ArgumentParser(
         prog="meshcore-console",
         description="MeshCore console — GUI and headless CLI",