Merge branch 'develop' into macos

fix: ensure null-termination in getSerialString() and handle len==0
2026-10-06 04:02:47 +10:00 · 2026-04-26 21:05:17 -05:00 · 2026-04-26 20:45:50 -05:00 · 2026-04-27 01:43:53 +00:00 · 2026-04-26 20:42:22 -05:00 · 2026-04-26 20:08:13 -05:00
39 changed files with 70 additions and 2507 deletions
@@ -13,7 +13,6 @@ Meshtastic is an open-source LoRa mesh networking project for long-range, low-po
 - **RP2040/RP2350** - Raspberry Pi Pico variants
 - **STM32WL** - STM32 with integrated LoRa
 - **Linux/Portduino** - Native Linux builds (Raspberry Pi, etc.)
- **macOS native** - Headless `meshtasticd` on Apple Silicon / x86_64; see `variants/native/portduino/platformio.ini` for Homebrew prereqs + CH341 LoRa setup

 ### Supported Radio Chips

@@ -370,7 +369,7 @@ To reduce avoidable agent mistakes, assume these tools are available (or install
 - **Required CLI basics**: `bash`, `git`, `find`, `grep`, `sed`, `awk`, `xargs`
 - **Strongly recommended**: `rg` (ripgrep) for fast file/text search, `jq` for JSON processing
 - **Build/test tools**: `python3`, `pip`, virtualenv (`python3 -m venv`), `platformio` (`pio`)
- **Containerized native testing**: `docker` (fallback for non-Linux hosts; macOS can also build natively via `pio run -e native-macos`)
+- **Containerized native testing**: `docker` (especially important on macOS / non-Linux hosts)

 Fallback expectations for agents:

@@ -389,7 +388,6 @@ Build commands:
 pio run -e tbeam              # Build specific target
 pio run -e tbeam -t upload    # Build and upload
 pio run -e native             # Build native/Linux version
-pio run -e native-macos       # Build headless macOS meshtasticd (Homebrew prereqs in variants/native/portduino/platformio.ini)
 ```

 ### Build Manifest
@@ -1,51 +0,0 @@
-name: Build MacOS Binary
-
-on:
-  workflow_call:
-    inputs:
-      macos_ver:
-        required: false
-        default: "26" # ARM64
-        type: string
-
-permissions:
-  contents: read
-
-jobs:
-  build-MacOS:
-    runs-on: macos-${{ inputs.macos_ver }}
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v6
-        with:
-          submodules: recursive
-
-      - name: Install deps
-        shell: bash
-        run: |
-          brew update
-          brew install platformio yaml-cpp libuv openssl@3 libusb argp-standalone pkg-config
-
-      - name: Get release version string
-        run: |
-          echo "long=$(./bin/buildinfo.py long)" >> $GITHUB_OUTPUT
-        id: version
-
-      - name: Build for MacOS
-        run: |
-          platformio run -e native-macos
-        env:
-          PKG_VERSION: ${{ steps.version.outputs.long }}
-        # Errors in this step should not fail the entire workflow while MacOS support is in development.
-        continue-on-error: true
-
-      - name: List output files
-        run: ls -lah .pio/build/native-macos/
-
-      - name: Store binaries as an artifact
-        uses: actions/upload-artifact@v7
-        with:
-          name: firmware-macos-${{ inputs.macos_ver }}-${{ steps.version.outputs.long }}
-          overwrite: true
-          path: |
-            .pio/build/native-macos/meshtasticd
@@ -73,9 +73,7 @@ jobs:
      - name: Sanitize platform string
        id: sanitize_platform
        # Replace slashes with underscores
-        env:
-          plat: ${{ inputs.platform }}
-        run: echo "cleaned_platform=${plat}" | sed 's/\//_/g' >> $GITHUB_OUTPUT
+        run: echo "cleaned_platform=${{ inputs.platform }}" | sed 's/\//_/g' >> $GITHUB_OUTPUT

      - name: Docker login
        if: ${{ inputs.push }}
@@ -43,15 +43,6 @@ jobs:
      push: true
    secrets: inherit

-  docker-debian-riscv64:
-    uses: ./.github/workflows/docker_build.yml
-    with:
-      distro: debian
-      platform: linux/riscv64
-      runs-on: ubuntu-24.04-arm
-      push: true
-    secrets: inherit
-
  docker-alpine-amd64:
    uses: ./.github/workflows/docker_build.yml
    with:
@@ -79,27 +70,16 @@ jobs:
      push: true
    secrets: inherit

-  docker-alpine-riscv64:
-    uses: ./.github/workflows/docker_build.yml
-    with:
-      distro: alpine
-      platform: linux/riscv64
-      runs-on: ubuntu-24.04-arm
-      push: true
-    secrets: inherit
-
  docker-manifest:
    needs:
      # Debian
      - docker-debian-amd64
      - docker-debian-arm64
      - docker-debian-armv7
-      - docker-debian-riscv64
      # Alpine
      - docker-alpine-amd64
      - docker-alpine-arm64
      - docker-alpine-armv7
-      - docker-alpine-riscv64
    runs-on: ubuntu-24.04
    steps:
      - name: Checkout code
@@ -182,7 +162,6 @@ jobs:
            meshtastic/meshtasticd@${{ needs.docker-debian-amd64.outputs.digest }}
            meshtastic/meshtasticd@${{ needs.docker-debian-arm64.outputs.digest }}
            meshtastic/meshtasticd@${{ needs.docker-debian-armv7.outputs.digest }}
-            meshtastic/meshtasticd@${{ needs.docker-debian-riscv64.outputs.digest }}

      - name: Docker meta (Alpine)
        id: meta_alpine
@@ -203,4 +182,3 @@ jobs:
            meshtastic/meshtasticd@${{ needs.docker-alpine-amd64.outputs.digest }}
            meshtastic/meshtasticd@${{ needs.docker-alpine-arm64.outputs.digest }}
            meshtastic/meshtasticd@${{ needs.docker-alpine-armv7.outputs.digest }}
-            meshtastic/meshtasticd@${{ needs.docker-alpine-riscv64.outputs.digest }}
@@ -116,20 +116,6 @@ jobs:
      build_location: local
    secrets: inherit

-  MacOS:
-    strategy:
-      fail-fast: false
-      matrix:
-        macos_ver:
-          - "26" # ARM64
-          # - '26-intel' # x86_64
-          - "15" # ARM64
-          # - '15-intel' # x86_64
-    uses: ./.github/workflows/build_macos_bin.yml
-    with:
-      macos_ver: ${{ matrix.macos_ver }}
-    # secrets: inherit
-
  package-pio-deps-native-tft:
    if: ${{ github.repository == 'meshtastic/firmware' && github.event_name == 'workflow_dispatch' }}
    uses: ./.github/workflows/package_pio_deps.yml
@@ -300,7 +286,6 @@ jobs:
      - gather-artifacts
      - build-debian-src
      - package-pio-deps-native-tft
-      # - MacOS
    steps:
      - name: Checkout
        uses: actions/checkout@v6
@@ -4,19 +4,19 @@ cli:
 plugins:
  sources:
    - id: trunk
-      ref: v1.8.0
+      ref: v1.7.6
      uri: https://github.com/trunk-io/plugins
 lint:
  enabled:
-    - checkov@3.2.525
-    - renovate@43.150.0
+    - checkov@3.2.524
+    - renovate@43.141.0
    - prettier@3.8.3
    - trufflehog@3.95.2
    - yamllint@1.38.0
    - bandit@1.9.4
    - trivy@0.70.0
    - taplo@0.10.0
-    - ruff@0.15.12
+    - ruff@0.15.11
    - isort@8.0.1
    - markdownlint@0.48.0
    - oxipng@10.1.1
@@ -36,7 +36,7 @@ lint:
        - bin/**
 runtimes:
  enabled:
-    - python@3.14.4
+    - python@3.10.8
    - go@1.21.0
    - node@22.16.0
 actions:
@@ -10,18 +10,17 @@ This file (`AGENTS.md`) is a short pointer + quick reference for agents that don

 ## Quick command reference

-| Action                           | Command                                                                                                       |
-| -------------------------------- | ------------------------------------------------------------------------------------------------------------- |
-| Build a firmware variant         | `pio run -e <env>` (e.g. `pio run -e rak4631`, `pio run -e heltec-v3`)                                        |
-| Build native macOS host binary   | `pio run -e native-macos` (Homebrew prereqs + CH341 LoRa setup in `variants/native/portduino/platformio.ini`) |
-| Clean + rebuild                  | `pio run -e <env> -t clean && pio run -e <env>`                                                               |
-| Flash a device                   | `pio run -e <env> -t upload --upload-port <port>` (or use the `pio_flash` MCP tool)                           |
-| Run firmware unit tests (native) | `pio test -e native`                                                                                          |
-| Run MCP hardware tests           | `./mcp-server/run-tests.sh`                                                                                   |
-| Live TUI test runner             | `mcp-server/.venv/bin/meshtastic-mcp-test-tui`                                                                |
-| Format before commit             | `trunk fmt`                                                                                                   |
-| Regenerate protobuf bindings     | `bin/regen-protos.sh`                                                                                         |
-| Generate CI matrix               | `./bin/generate_ci_matrix.py all [--level pr]`                                                                |
+| Action                           | Command                                                                             |
+| -------------------------------- | ----------------------------------------------------------------------------------- |
+| Build a firmware variant         | `pio run -e <env>` (e.g. `pio run -e rak4631`, `pio run -e heltec-v3`)              |
+| Clean + rebuild                  | `pio run -e <env> -t clean && pio run -e <env>`                                     |
+| Flash a device                   | `pio run -e <env> -t upload --upload-port <port>` (or use the `pio_flash` MCP tool) |
+| Run firmware unit tests (native) | `pio test -e native`                                                                |
+| Run MCP hardware tests           | `./mcp-server/run-tests.sh`                                                         |
+| Live TUI test runner             | `mcp-server/.venv/bin/meshtastic-mcp-test-tui`                                      |
+| Format before commit             | `trunk fmt`                                                                         |
+| Regenerate protobuf bindings     | `bin/regen-protos.sh`                                                               |
+| Generate CI matrix               | `./bin/generate_ci_matrix.py all [--level pr]`                                      |

 ## MCP server (device + test automation)

@@ -122,7 +121,6 @@ Sequence these; don't parallelize on the same port.
 - **Device fully wedged (no DFU)?** `mcp__meshtastic__uhubctl_cycle(role="nrf52", confirm=True)` hard-power-cycles it via USB hub PPPS. Needs `uhubctl` installed (`brew install uhubctl` / `apt install uhubctl`); on Linux without udev rules, permission errors fail fast, so use `sudo uhubctl` yourself or configure udev access.
 - **Port busy?** `lsof <port>` to find the holder. Usually a stale `pio device monitor` or zombie `meshtastic_mcp` process. Kill it.
 - **Multiple MCP servers running?** `ps aux | grep meshtastic_mcp` — zombies hold ports. Kill all but the one your host spawned.
- **macOS: `LIBUSB_ERROR_BUSY` on a CH341 LoRa adapter?** A third-party WCH `CH34xVCPDriver` is claiming interface 0. Find the bundle ID with `ioreg -p IOUSB -l -w 0 | grep -B2 -A30 0x5512`, then `sudo kmutil unload -b <bundleID>`. Apple's bundled CH34x kext targets the CH340 UART (PID 0x7523), not the SPI bridge — it's never the culprit.

 ## Environment variables (test harness)

@@ -3,8 +3,7 @@
 # trunk-ignore-all(hadolint/DL3018): Do not pin apk package versions
 # trunk-ignore-all(hadolint/DL3013): Do not pin pip package versions

-# Ensure the Alpine version is updated in both stages of the container!
-FROM python:3.14-alpine3.23 AS builder
+FROM python:3.14-alpine3.22 AS builder
 ARG PIO_ENV=native
 ENV PIP_ROOT_USER_ACTION=ignore

@@ -61,4 +60,4 @@ EXPOSE 4403

 CMD [ "sh",  "-cx", "meshtasticd --fsdir=/var/lib/meshtasticd" ]

-HEALTHCHECK NONE
+HEALTHCHECK NONE
@@ -1,941 +0,0 @@
-#!/usr/bin/env python3
-
-import argparse
-import os
-import queue
-import random
-import shutil
-import socket
-import select
-import subprocess
-import sys
-import tempfile
-import termios
-import threading
-import time
-import tty
-from collections import deque
-from dataclasses import dataclass, field
-from pathlib import Path
-from typing import Optional, TextIO
-
-
-START1 = 0x94
-START2 = 0xC3
-HEADER_LEN = 4
-DEFAULT_API_PORT = 4403
-DEFAULT_HOP_LIMIT = 0
-LOCAL_ESCAPE_BYTE = b"\x1d"  # Ctrl+]
-MISSING_SEQ_RETRY_INTERVAL_SEC = 1.0
-INPUT_BATCH_WINDOW_SEC = .5
-INPUT_BATCH_MAX_BYTES = 64
-HEARTBEAT_IDLE_DELAY_SEC = 5.0
-HEARTBEAT_REPEAT_SEC = 15.0
-HEARTBEAT_POLL_INTERVAL_SEC = 0.25
-
-
-def parse_args() -> argparse.Namespace:
-    parser = argparse.ArgumentParser(
-        description="Tiny DMShell client for Meshtastic native TCP API",
-        epilog=(
-            "Examples:\n"
-            "  bin/dmshell_client.py --to !170896f7\n"
-            "  bin/dmshell_client.py --to 0x170896f7 --command 'uname -a' --command 'id'"
-        ),
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-    )
-    parser.add_argument("--host", default="127.0.0.1", help="meshtasticd API host")
-    parser.add_argument("--port", type=int, default=DEFAULT_API_PORT, help="meshtasticd API port")
-    parser.add_argument(
-        "--serial",
-        nargs="?",
-        const="auto",
-        default=None,
-        help="use USB serial transport (optionally provide device path, default: auto-detect)",
-    )
-    parser.add_argument("--baud", type=int, default=115200, help="serial baud rate when using --serial")
-    parser.add_argument("--to", required=True, help="destination node number, e.g. !170896f7 or 0x170896f7")
-    parser.add_argument("--channel", type=int, default=0, help="channel index to use")
-    parser.add_argument("--cols", type=int, default=None, help="initial terminal columns (default: detect local terminal)")
-    parser.add_argument("--rows", type=int, default=None, help="initial terminal rows (default: detect local terminal)")
-    parser.add_argument("--command", action="append", default=[], help="send a command line after opening")
-    parser.add_argument("--close-after", type=float, default=2.0, help="seconds to wait before closing in command mode")
-    parser.add_argument("--timeout", type=float, default=10.0, help="seconds to wait for API/session events")
-    parser.add_argument("--verbose", action="store_true", help="print extra protocol events")
-    return parser.parse_args()
-
-
-def repo_root() -> Path:
-    return Path(__file__).resolve().parent.parent
-
-
-def load_proto_modules() -> object:
-    try:
-        import google.protobuf  # noqa: F401
-    except ImportError as exc:
-        raise SystemExit("python package 'protobuf' is required to run this client") from exc
-
-    protoc = shutil.which("protoc")
-    if not protoc:
-        raise SystemExit("'protoc' is required to generate temporary Python protobuf bindings")
-
-    out_dir = Path(tempfile.mkdtemp(prefix="meshtastic_dmshell_proto_"))
-    proto_dir = repo_root() / "protobufs"
-    
-    # Compile all required protos for DMShell client (mesh and dependencies)
-    # Excludes nanopb.proto and other complex build artifacts
-    required_protos = [
-        "mesh.proto",
-        "channel.proto", 
-        "config.proto",
-        "device_ui.proto",
-        "module_config.proto",
-        "atak.proto",
-        "portnums.proto",
-        "telemetry.proto",
-        "xmodem.proto",
-    ]
-    proto_files = [proto_dir / "meshtastic" / name for name in required_protos]
-    for pf in proto_files:
-        if not pf.exists():
-            raise SystemExit(f"could not find required proto file: {pf}")
-
-    # Create __init__.py to make meshtastic a package
-    (out_dir / "meshtastic").mkdir(exist_ok=True)
-    (out_dir / "meshtastic" / "__init__.py").touch()
-
-    # Build protoc command with just the meshtastic proto directory as include path
-    # protoc will use its built-in includes for standard google protobuf types
-    cmd = [protoc, f"-I{proto_dir}", f"--python_out={out_dir}", *[str(path) for path in proto_files]]
-    result = subprocess.run(cmd, capture_output=True, text=True)
-    if result.returncode != 0:
-        print(f"protoc stderr: {result.stderr}", file=sys.stderr)
-        print(f"protoc stdout: {result.stdout}", file=sys.stderr)
-        print(f"protoc command: {' '.join(cmd)}", file=sys.stderr)
-        raise SystemExit(f"protoc failed with return code {result.returncode}")
-
-    # Create _pb2_grpc module stub if not present (protoc 3.20+)
-    mesh_pb2_file = out_dir / "meshtastic" / "mesh_pb2.py"
-    if not mesh_pb2_file.exists():
-        raise SystemExit(f"protoc did not generate mesh_pb2.py in {out_dir / 'meshtastic'}")
-
-    sys.path.insert(0, str(out_dir))
-    try:
-        from meshtastic import mesh_pb2, portnums_pb2  # type: ignore
-    except ImportError as exc:
-        print(f"Failed to import protobuf modules. Output dir contents:", file=sys.stderr)
-        for item in (out_dir / "meshtastic").iterdir():
-            print(f"  {item.name}", file=sys.stderr)
-        raise SystemExit(f"could not import meshtastic proto modules: {exc}") from exc
-
-    # Return an object that has both modules accessible
-    class ProtoModules:
-        pass
-    
-    pb2 = ProtoModules()
-    pb2.mesh = mesh_pb2
-    pb2.portnums = portnums_pb2
-    return pb2
-
-
-def parse_node_num(raw: str) -> int:
-    value = raw.strip()
-    if value.startswith("!"):
-        value = value[1:]
-    if value.lower().startswith("0x"):
-        return int(value, 16)
-    if any(ch in "abcdefABCDEF" for ch in value):
-        return int(value, 16)
-    return int(value, 10)
-
-
-class SerialTransport:
-    def __init__(self, serial_obj):
-        self._serial = serial_obj
-
-    def recv(self, length: int) -> bytes:
-        return self._serial.read(length)
-
-    def sendall(self, data: bytes) -> None:
-        self._serial.write(data)
-        self._serial.flush()
-
-    def close(self) -> None:
-        self._serial.close()
-
-
-def detect_meshtastic_serial_port() -> str:
-    try:
-        from serial.tools import list_ports
-    except ImportError as exc:
-        raise SystemExit("python package 'pyserial' is required for --serial mode") from exc
-
-    ports = list(list_ports.comports())
-    if not ports:
-        raise SystemExit("no serial ports found for --serial mode")
-
-    scored: list[tuple[int, str]] = []
-    for port in ports:
-        text = " ".join(
-            filter(
-                None,
-                [port.device, port.description, port.manufacturer, port.product, port.hwid],
-            )
-        ).lower()
-        score = 0
-        if "meshtastic" in text:
-            score += 100
-        if "lora" in text or "mesh" in text:
-            score += 10
-        if "ttyacm" in (port.device or "").lower() or "ttyusb" in (port.device or "").lower():
-            score += 1
-        scored.append((score, port.device))
-
-    scored.sort(reverse=True)
-    best_score, best_device = scored[0]
-    if best_score <= 0 and len(scored) > 1:
-        raise SystemExit(
-            "could not confidently auto-detect a Meshtastic serial port; pass --serial /dev/ttyXXX explicitly"
-        )
-    return best_device
-
-
-def open_transport(args: argparse.Namespace):
-    if args.serial is None:
-        sock = socket.create_connection((args.host, args.port), timeout=args.timeout)
-        sock.settimeout(None)
-        return sock
-
-    serial_path = args.serial
-    if serial_path == "auto":
-        serial_path = detect_meshtastic_serial_port()
-        print(f"[dmshell] using serial port {serial_path}", file=sys.stderr)
-
-    try:
-        import serial
-    except ImportError as exc:
-        raise SystemExit("python package 'pyserial' is required for --serial mode") from exc
-
-    try:
-        serial_obj = serial.Serial(serial_path, baudrate=args.baud, timeout=None, write_timeout=2)
-    except Exception as exc:
-        raise SystemExit(f"failed to open serial device {serial_path}: {exc}") from exc
-
-    return SerialTransport(serial_obj)
-
-
-def recv_exact(transport, length: int) -> bytes:
-    chunks = bytearray()
-    while len(chunks) < length:
-        piece = transport.recv(length - len(chunks))
-        if not piece:
-            raise ConnectionError("connection closed by transport")
-        chunks.extend(piece)
-    return bytes(chunks)
-
-
-def detect_local_terminal_size() -> tuple[int, int]:
-    size = shutil.get_terminal_size(fallback=(100, 40))
-    cols = max(1, int(size.columns))
-    rows = max(1, int(size.lines))
-    return cols, rows
-
-
-def resolve_initial_terminal_size(cols_override: Optional[int], rows_override: Optional[int]) -> tuple[int, int]:
-    detected_cols, detected_rows = detect_local_terminal_size()
-    cols = detected_cols if cols_override is None else max(1, cols_override)
-    rows = detected_rows if rows_override is None else max(1, rows_override)
-    return cols, rows
-
-
-def recv_stream_frame(transport) -> bytes:
-    while True:
-        start = recv_exact(transport, 1)[0]
-        if start != START1:
-            continue
-        if recv_exact(transport, 1)[0] != START2:
-            continue
-        header = recv_exact(transport, 2)
-        length = (header[0] << 8) | header[1]
-        return recv_exact(transport, length)
-
-
-def send_stream_frame(transport, payload: bytes) -> None:
-    if len(payload) > 0xFFFF:
-        raise ValueError("payload too large for stream API")
-    header = bytes((START1, START2, (len(payload) >> 8) & 0xFF, len(payload) & 0xFF))
-    transport.sendall(header + payload)
-
-
-@dataclass
-class SentShellFrame:
-    op: int
-    session_id: int
-    seq: int
-    ack_seq: int
-    payload: bytes = b""
-    cols: int = 0
-    rows: int = 0
-    flags: int = 0
-    last_tx_seq: int = 0
-    last_rx_seq: int = 0
-
-
-@dataclass
-class SessionState:
-    pb2: object  # ProtoModules with mesh and portnums attributes
-    target: int
-    channel: int
-    verbose: bool
-    session_id: int = field(default_factory=lambda: random.randint(1, 0x7FFFFFFF))
-    next_seq: int = 1
-    last_rx_seq: int = 0
-    next_expected_rx_seq: int = 1
-    highest_seen_rx_seq: int = 0
-    active: bool = False
-    stopped: bool = False
-    opened_event: threading.Event = field(default_factory=threading.Event)
-    closed_event: threading.Event = field(default_factory=threading.Event)
-    event_queue: "queue.Queue[str]" = field(default_factory=queue.Queue)
-    tx_lock: threading.Lock = field(default_factory=threading.Lock)
-    socket_lock: threading.Lock = field(default_factory=threading.Lock)
-    tx_history: deque[SentShellFrame] = field(default_factory=lambda: deque(maxlen=50))
-    pending_rx_frames: dict[int, object] = field(default_factory=dict)
-    last_requested_missing_seq: int = 0
-    last_missing_request_time: float = 0.0
-    requested_missing_seqs: set[int] = field(default_factory=set)
-    replay_log_lock: threading.Lock = field(default_factory=threading.Lock)
-    replay_log_file: Optional[TextIO] = None
-    replay_log_path: Optional[Path] = None
-    last_transport_activity_time: float = field(default_factory=time.monotonic)
-    last_heartbeat_sent_time: float = 0.0
-
-    def alloc_seq(self) -> int:
-        with self.tx_lock:
-            value = self.next_seq
-            self.next_seq += 1
-            return value
-
-    def current_ack_seq(self) -> int:
-        with self.tx_lock:
-            return self.last_rx_seq
-
-    def highest_sent_seq(self) -> int:
-        with self.tx_lock:
-            return max(0, self.next_seq - 1)
-
-    def note_outbound_packet(self, heartbeat: bool = False) -> None:
-        with self.tx_lock:
-            now = time.monotonic()
-            if heartbeat:
-                self.last_heartbeat_sent_time = now
-            else:
-                self.last_transport_activity_time = now
-
-    def note_inbound_packet(self) -> None:
-        with self.tx_lock:
-            self.last_transport_activity_time = time.monotonic()
-
-    def heartbeat_due(self) -> bool:
-        with self.tx_lock:
-            now = time.monotonic()
-            if (now - self.last_transport_activity_time) < HEARTBEAT_IDLE_DELAY_SEC:
-                return False
-            if self.last_heartbeat_sent_time <= self.last_transport_activity_time:
-                return True
-            return (now - self.last_heartbeat_sent_time) >= HEARTBEAT_REPEAT_SEC
-
-    def note_peer_reported_tx_seq(self, seq: int) -> None:
-        with self.tx_lock:
-            if seq > self.highest_seen_rx_seq:
-                self.highest_seen_rx_seq = seq
-
-    def note_received_seq(self, seq: int) -> tuple[str, Optional[int]]:
-        with self.tx_lock:
-            if seq == 0:
-                return ("process", None)
-            if seq < self.next_expected_rx_seq:
-                if self.highest_seen_rx_seq >= self.next_expected_rx_seq:
-                    return ("gap", self.next_expected_rx_seq)
-                return ("duplicate", None)
-            if seq > self.next_expected_rx_seq:
-                if seq > self.highest_seen_rx_seq:
-                    self.highest_seen_rx_seq = seq
-                return ("gap", self.next_expected_rx_seq)
-            self.last_rx_seq = seq
-            self.next_expected_rx_seq = seq + 1
-            if self.last_requested_missing_seq != 0 and self.next_expected_rx_seq > self.last_requested_missing_seq:
-                self.last_requested_missing_seq = 0
-            if seq > self.highest_seen_rx_seq:
-                self.highest_seen_rx_seq = seq
-            if self.highest_seen_rx_seq < self.next_expected_rx_seq:
-                self.highest_seen_rx_seq = 0
-            return ("process", None)
-
-    def remember_out_of_order_frame(self, shell) -> None:
-        with self.tx_lock:
-            if shell.seq <= self.next_expected_rx_seq:
-                return
-            if shell.seq not in self.pending_rx_frames:
-                self.pending_rx_frames[shell.seq] = shell
-            if shell.seq > self.highest_seen_rx_seq:
-                self.highest_seen_rx_seq = shell.seq
-
-    def pop_next_buffered_frame(self):
-        with self.tx_lock:
-            return self.pending_rx_frames.pop(self.next_expected_rx_seq, None)
-
-    def pending_missing_seq(self) -> Optional[int]:
-        with self.tx_lock:
-            if self.highest_seen_rx_seq >= self.next_expected_rx_seq:
-                return self.next_expected_rx_seq
-            return None
-
-    def request_missing_seq_once(self) -> Optional[int]:
-        with self.tx_lock:
-            if self.highest_seen_rx_seq < self.next_expected_rx_seq:
-                return None
-            now = time.monotonic()
-            if (
-                self.last_requested_missing_seq == self.next_expected_rx_seq
-                and (now - self.last_missing_request_time) < MISSING_SEQ_RETRY_INTERVAL_SEC
-            ):
-                return None
-            self.last_requested_missing_seq = self.next_expected_rx_seq
-            self.last_missing_request_time = now
-            return self.last_requested_missing_seq
-
-    def set_receive_cursor(self, seq: int) -> None:
-        with self.tx_lock:
-            self.last_rx_seq = seq
-            self.next_expected_rx_seq = seq + 1
-            self.highest_seen_rx_seq = seq
-
-    def open_replay_log(self, session_id: int) -> None:
-        with self.replay_log_lock:
-            if self.replay_log_file is not None:
-                return
-            path = Path.cwd() / f"{session_id:08x}.log"
-            self.replay_log_file = path.open("a", encoding="utf-8")
-            self.replay_log_path = path
-            self.replay_log_file.write(f"{time.strftime('%Y-%m-%d %H:%M:%S')} session_open session=0x{session_id:08x}\n")
-            self.replay_log_file.flush()
-
-    def log_replay_event(self, event: str, seq: int, detail: str = "") -> None:
-        with self.replay_log_lock:
-            if self.replay_log_file is None:
-                return
-            extra = f" {detail}" if detail else ""
-            self.replay_log_file.write(
-                f"{time.strftime('%Y-%m-%d %H:%M:%S')} {event} seq={seq}{extra}\n"
-            )
-            self.replay_log_file.flush()
-
-    def note_missing_seq_requested(self, seq: int, reason: str) -> None:
-        with self.tx_lock:
-            self.requested_missing_seqs.add(seq)
-        self.log_replay_event("missing_requested", seq, f"reason={reason}")
-
-    def note_replayed_seq_received(self, seq: int) -> None:
-        with self.tx_lock:
-            was_requested = seq in self.requested_missing_seqs
-            if was_requested:
-                self.requested_missing_seqs.remove(seq)
-        if was_requested:
-            self.log_replay_event("replay_received", seq)
-
-    def close_replay_log(self) -> None:
-        with self.replay_log_lock:
-            if self.replay_log_file is None:
-                return
-            self.replay_log_file.write(f"{time.strftime('%Y-%m-%d %H:%M:%S')} session_close\n")
-            self.replay_log_file.flush()
-            self.replay_log_file.close()
-            self.replay_log_file = None
-
-    def remember_sent_frame(self, frame: SentShellFrame) -> None:
-        if frame.seq == 0 or frame.op == self.pb2.mesh.RemoteShell.ACK:
-            return
-        with self.tx_lock:
-            self.tx_history.append(frame)
-
-    def prune_sent_frames(self, ack_seq: int) -> None:
-        if ack_seq <= 0:
-            return
-        with self.tx_lock:
-            self.tx_history = deque((frame for frame in self.tx_history if frame.seq > ack_seq), maxlen=50)
-
-    def replay_frames_from(self, start_seq: int) -> list[SentShellFrame]:
-        with self.tx_lock:
-            return [frame for frame in self.tx_history if frame.seq >= start_seq]
-
-
-def send_toradio(transport, toradio) -> None:
-    send_stream_frame(transport, toradio.SerializeToString())
-
-
-def make_toradio_packet(pb2, state: SessionState, shell_msg) -> object:
-    packet = pb2.mesh.MeshPacket()
-    packet.id = random.randint(1, 0x7FFFFFFF)
-    packet.to = state.target
-    # The 'from' field is a reserved keyword in Python, so use setattr
-    setattr(packet, "from", 0)
-    packet.channel = state.channel
-    packet.hop_limit = DEFAULT_HOP_LIMIT
-    packet.want_ack = False
-    packet.decoded.portnum = pb2.portnums.REMOTE_SHELL_APP
-    packet.decoded.payload = shell_msg.SerializeToString()
-    packet.decoded.want_response = False
-    packet.decoded.dest = state.target
-    packet.decoded.source = 0
-
-    toradio = pb2.mesh.ToRadio()
-    toradio.packet.CopyFrom(packet)
-    return toradio
-
-
-def send_shell_frame(
-    transport,
-    state: SessionState,
-    op: int,
-    payload: bytes = b"",
-    cols: int = 0,
-    rows: int = 0,
-    session_id: Optional[int] = None,
-    ack_seq: Optional[int] = None,
-    seq: Optional[int] = None,
-    flags: int = 0,
-    last_tx_seq: int = 0,
-    last_rx_seq: int = 0,
-    remember: bool = True,
-    heartbeat: bool = False,
-) -> int:
-    if seq is None:
-        seq = 0 if op == state.pb2.mesh.RemoteShell.ACK else state.alloc_seq()
-    if ack_seq is None:
-        ack_seq = state.current_ack_seq()
-    if session_id is None:
-        session_id = state.session_id
-
-    shell = state.pb2.mesh.RemoteShell()
-    shell.op = op
-    shell.session_id = session_id
-    shell.seq = seq
-    shell.ack_seq = ack_seq
-    shell.cols = cols
-    shell.rows = rows
-    shell.flags = flags
-    shell.last_tx_seq = last_tx_seq
-    shell.last_rx_seq = last_rx_seq
-    if payload:
-        shell.payload = payload
-    with state.socket_lock:
-        send_toradio(transport, make_toradio_packet(state.pb2, state, shell))
-    if remember:
-        state.remember_sent_frame(
-            SentShellFrame(
-                op=op,
-                session_id=session_id,
-                seq=seq,
-                ack_seq=ack_seq,
-                payload=payload,
-                cols=cols,
-                rows=rows,
-                flags=flags,
-                last_tx_seq=last_tx_seq,
-                last_rx_seq=last_rx_seq,
-            )
-        )
-    state.note_outbound_packet(heartbeat=heartbeat)
-    return seq
-
-
-def send_ack_frame(transport, state: SessionState, replay_from: Optional[int] = None) -> None:
-    send_shell_frame(
-        transport,
-        state,
-        state.pb2.mesh.RemoteShell.ACK,
-        seq=0,
-        last_rx_seq=0 if replay_from is None else replay_from - 1,
-        remember=False,
-    )
-
-
-def replay_frames_from(transport, state: SessionState, start_seq: int) -> None:
-    frame = next((f for f in state.replay_frames_from(start_seq) if f.seq == start_seq), None)
-    if frame is None:
-        #state.event_queue.put(f"replay unavailable from seq={start_seq}")
-        state.log_replay_event("replay_unavailable", start_seq)
-        return
-    state.log_replay_event("replay_sent", start_seq)
-    #state.event_queue.put(f"replay frame seq={start_seq}")
-    send_shell_frame(
-        transport,
-        state,
-        frame.op,
-        payload=frame.payload,
-        cols=frame.cols,
-        rows=frame.rows,
-        session_id=frame.session_id,
-        ack_seq=frame.ack_seq,
-        seq=frame.seq,
-        flags=frame.flags,
-        last_tx_seq=frame.last_tx_seq,
-        last_rx_seq=frame.last_rx_seq,
-        remember=False,
-    )
-
-
-def wait_for_config_complete(transport, pb2, timeout: float, verbose: bool) -> None:
-    nonce = random.randint(1, 0x7FFFFFFF)
-    toradio = pb2.mesh.ToRadio()
-    toradio.want_config_id = nonce
-    send_toradio(transport, toradio)
-
-    deadline = time.time() + timeout
-    while time.time() < deadline:
-        fromradio = pb2.mesh.FromRadio()
-        fromradio.ParseFromString(recv_stream_frame(transport))
-        variant = fromradio.WhichOneof("payload_variant")
-        if verbose and variant:
-            print(f"[api] fromradio {variant}", file=sys.stderr)
-        if variant == "config_complete_id" and fromradio.config_complete_id == nonce:
-            return
-    raise TimeoutError("timed out waiting for config handshake to complete")
-
-
-def decode_shell_packet(state: SessionState, packet) -> Optional[object]:
-    if packet.WhichOneof("payload_variant") != "decoded":
-        return None
-    if packet.decoded.portnum != state.pb2.portnums.REMOTE_SHELL_APP:
-        return None
-    shell = state.pb2.mesh.RemoteShell()
-    shell.ParseFromString(packet.decoded.payload)
-    return shell
-
-
-def reader_loop(transport, state: SessionState) -> None:
-    def handle_in_order_shell(shell) -> bool:
-        state.note_replayed_seq_received(shell.seq)
-        if shell.op == state.pb2.mesh.RemoteShell.OPEN_OK:
-            state.session_id = shell.session_id
-            state.open_replay_log(state.session_id)
-            state.set_receive_cursor(shell.seq)
-            state.active = True
-            state.opened_event.set()
-            state.event_queue.put(
-                f"opened session=0x{shell.session_id:08x} cols={shell.cols} rows={shell.rows}"
-            )
-            if state.replay_log_path is not None:
-                state.event_queue.put(f"replay log: {state.replay_log_path}")
-        elif shell.op == state.pb2.mesh.RemoteShell.OUTPUT:
-            if shell.payload:
-                sys.stdout.buffer.write(shell.payload)
-                sys.stdout.buffer.flush()
-        elif shell.op == state.pb2.mesh.RemoteShell.ERROR:
-            message = shell.payload.decode("utf-8", errors="replace")
-            if state.replay_log_file is None:
-                state.open_replay_log(shell.session_id or state.session_id)
-            sanitized = message.replace("\n", "\\n")
-            state.log_replay_event("error_received", shell.seq, f"message={sanitized}")
-            state.event_queue.put(f"remote error: {message}")
-        elif shell.op == state.pb2.mesh.RemoteShell.CLOSED:
-            message = shell.payload.decode("utf-8", errors="replace")
-            state.event_queue.put(f"session closed: {message}")
-            state.closed_event.set()
-            state.active = False
-            return True
-        elif shell.op == state.pb2.mesh.RemoteShell.PONG:
-            remote_last_tx_seq = shell.last_tx_seq
-            remote_last_rx_seq = shell.last_rx_seq
-            local_latest_tx_seq = state.highest_sent_seq()
-            if remote_last_rx_seq != 0 and remote_last_rx_seq < local_latest_tx_seq:
-                replay_frames_from(transport, state, remote_last_rx_seq + 1)
-            if remote_last_tx_seq > state.current_ack_seq():
-                state.note_peer_reported_tx_seq(remote_last_tx_seq)
-                req = state.request_missing_seq_once()
-                if req is not None:
-                    state.note_missing_seq_requested(req, "heartbeat_status")
-                    send_ack_frame(transport, state, replay_from=req)
-            #state.event_queue.put("pong")
-        return False
-
-    while not state.stopped:
-        try:
-            fromradio = state.pb2.mesh.FromRadio()
-            fromradio.ParseFromString(recv_stream_frame(transport))
-        except Exception as exc:
-            if not state.stopped:
-                state.event_queue.put(f"connection error: {exc}")
-                state.closed_event.set()
-            return
-
-        variant = fromradio.WhichOneof("payload_variant")
-        if variant == "packet":
-            shell = decode_shell_packet(state, fromradio.packet)
-            if not shell:
-                continue
-            state.note_inbound_packet()
-            #state.prune_sent_frames(shell.ack_seq)
-            if shell.op == state.pb2.mesh.RemoteShell.ACK:
-                #state.event_queue.put("peer requested replay")
-                replay_from = shell.last_rx_seq + 1 if shell.last_rx_seq > 0 else None
-                if replay_from is not None:
-                    #state.event_queue.put(f"peer requested replay from seq={replay_from}")
-                    replay_frames_from(transport, state, replay_from)
-                continue
-
-            action, missing_from = state.note_received_seq(shell.seq)
-            if action == "duplicate":
-                req = state.request_missing_seq_once()
-                if req is not None:
-                    state.note_missing_seq_requested(req, "duplicate")
-                    send_ack_frame(transport, state, replay_from=req)
-                continue
-            if action == "gap":
-                state.remember_out_of_order_frame(shell)
-                req = state.request_missing_seq_once()
-                if req is not None:
-                    state.note_missing_seq_requested(req, "gap")
-                    send_ack_frame(transport, state, replay_from=req)
-                continue
-
-            if handle_in_order_shell(shell):
-                return
-
-            while True:
-                buffered_shell = state.pop_next_buffered_frame()
-                if buffered_shell is None:
-                    break
-                buffered_action, _ = state.note_received_seq(buffered_shell.seq)
-                if buffered_action != "process":
-                    state.remember_out_of_order_frame(buffered_shell)
-                    break
-                if handle_in_order_shell(buffered_shell):
-                    return
-
-            req = state.request_missing_seq_once()
-            if req is not None:
-                state.note_missing_seq_requested(req, "post_process_gap")
-                send_ack_frame(transport, state, replay_from=req)
-        elif state.verbose and variant:
-            state.event_queue.put(f"fromradio {variant}")
-
-
-def drain_events(state: SessionState) -> None:
-    while True:
-        try:
-            event = state.event_queue.get_nowait()
-        except queue.Empty:
-            return
-        print(f"[dmshell] {event}", file=sys.stderr)
-
-
-def heartbeat_loop(transport, state: SessionState) -> None:
-    while not state.stopped and not state.closed_event.is_set():
-        if not state.active:
-            time.sleep(HEARTBEAT_POLL_INTERVAL_SEC)
-            continue
-        if state.heartbeat_due():
-            try:
-                send_shell_frame(
-                    transport,
-                    state,
-                    state.pb2.mesh.RemoteShell.PING,
-                    last_tx_seq=state.highest_sent_seq(),
-                    last_rx_seq=state.current_ack_seq(),
-                    remember=True,
-                    heartbeat=True,
-                )
-            except Exception as exc:
-                if not state.stopped:
-                    state.event_queue.put(f"heartbeat error: {exc}")
-                    state.closed_event.set()
-                    return
-        time.sleep(HEARTBEAT_POLL_INTERVAL_SEC)
-
-
-def run_command_mode(transport, state: SessionState, commands: list[str], close_after: float) -> None:
-    for command in commands:
-        send_shell_frame(transport, state, state.pb2.mesh.RemoteShell.INPUT, (command + "\n").encode("utf-8"))
-    time.sleep(close_after)
-    send_shell_frame(transport, state, state.pb2.mesh.RemoteShell.CLOSE)
-    state.closed_event.wait(timeout=close_after + 5.0)
-
-
-def run_interactive_mode(transport, state: SessionState) -> None:
-    def read_local_command() -> str:
-        prompt = "\r\n[dmshell] local command (resume|close|ping|resize C R): "
-        sys.stderr.write(prompt)
-        sys.stderr.flush()
-        buf = bytearray()
-
-        while True:
-            ch = os.read(sys.stdin.fileno(), 1)
-            if not ch:
-                sys.stderr.write("\r\n")
-                sys.stderr.flush()
-                return "close"
-
-            b = ch[0]
-            if b in (10, 13):
-                sys.stderr.write("\r\n")
-                sys.stderr.flush()
-                return buf.decode("utf-8", errors="replace").strip()
-
-            if b in (8, 127):
-                if buf:
-                    buf.pop()
-                    sys.stderr.write("\b \b")
-                    sys.stderr.flush()
-                continue
-
-            if b < 32:
-                continue
-
-            buf.append(b)
-            sys.stderr.write(chr(b))
-            sys.stderr.flush()
-
-    def handle_local_command(cmd: str) -> bool:
-        if cmd in ("", "resume"):
-            return True
-        if cmd == "close":
-            send_shell_frame(transport, state, state.pb2.mesh.RemoteShell.CLOSE)
-            return False
-        if cmd == "ping":
-            send_shell_frame(transport, state, state.pb2.mesh.RemoteShell.PING)
-            return True
-        if cmd.startswith("resize "):
-            parts = cmd.split()
-            if len(parts) != 3:
-                state.event_queue.put("usage: resize COLS ROWS")
-                return True
-            try:
-                cols = int(parts[1])
-                rows = int(parts[2])
-            except ValueError:
-                state.event_queue.put("usage: resize COLS ROWS")
-                return True
-            send_shell_frame(transport, state, state.pb2.mesh.RemoteShell.RESIZE, cols=cols, rows=rows)
-            return True
-
-        state.event_queue.put(f"unknown local command: {cmd}")
-        return True
-
-    print(
-        "Raw input mode active. All keys (including Ctrl+C/Ctrl+X) are sent to remote. Ctrl+] for local commands.",
-        file=sys.stderr,
-    )
-
-    if not sys.stdin.isatty():
-        # Fallback for non-TTY stdin: still send input as it arrives.
-        while not state.closed_event.is_set():
-            drain_events(state)
-            data = sys.stdin.buffer.read(INPUT_BATCH_MAX_BYTES)
-            if not data:
-                send_shell_frame(transport, state, state.pb2.mesh.RemoteShell.CLOSE)
-                break
-            send_shell_frame(transport, state, state.pb2.mesh.RemoteShell.INPUT, data)
-        return
-
-    fd = sys.stdin.fileno()
-    old_attrs = termios.tcgetattr(fd)
-    try:
-        tty.setraw(fd)
-        while not state.closed_event.is_set():
-            drain_events(state)
-            ready, _, _ = select.select([sys.stdin], [], [], 0.05)
-            if not ready:
-                continue
-
-            data = os.read(fd, 1)
-            if not data:
-                send_shell_frame(transport, state, state.pb2.mesh.RemoteShell.CLOSE)
-                break
-
-            if data == LOCAL_ESCAPE_BYTE:
-                keep_running = handle_local_command(read_local_command())
-                if not keep_running:
-                    break
-                continue
-
-            # Coalesce a short burst of bytes to reduce packet overhead for fast typing.
-            batched = bytearray(data)
-            enter_local_command = False
-            deadline = time.monotonic() + INPUT_BATCH_WINDOW_SEC
-            while len(batched) < INPUT_BATCH_MAX_BYTES:
-                remaining = deadline - time.monotonic()
-                if remaining <= 0:
-                    break
-                more_ready, _, _ = select.select([sys.stdin], [], [], remaining)
-                if not more_ready:
-                    break
-                next_byte = os.read(fd, 1)
-                if not next_byte:
-                    break
-                if next_byte == LOCAL_ESCAPE_BYTE:
-                    enter_local_command = True
-                    break
-                batched.extend(next_byte)
-                if next_byte == b'\r' or next_byte == b'\t':
-                    break
-                deadline = time.monotonic() + INPUT_BATCH_WINDOW_SEC
-
-            if batched:
-                send_shell_frame(transport, state, state.pb2.mesh.RemoteShell.INPUT, bytes(batched))
-
-            if enter_local_command:
-                keep_running = handle_local_command(read_local_command())
-                if not keep_running:
-                    break
-    finally:
-        termios.tcsetattr(fd, termios.TCSADRAIN, old_attrs)
-
-
-def main() -> int:
-    args = parse_args()
-    pb2 = load_proto_modules()
-
-    state = SessionState(
-            pb2=pb2,
-        target=parse_node_num(args.to),
-        channel=args.channel,
-        verbose=args.verbose,
-    )
-
-    cols, rows = resolve_initial_terminal_size(args.cols, args.rows)
-
-    transport = open_transport(args)
-    try:
-        wait_for_config_complete(transport, pb2, args.timeout, args.verbose)
-
-        reader = threading.Thread(target=reader_loop, args=(transport, state), daemon=True)
-        reader.start()
-
-        send_shell_frame(transport, state, pb2.mesh.RemoteShell.OPEN, cols=cols, rows=rows)
-        if not state.opened_event.wait(timeout=args.timeout):
-            raise SystemExit("timed out waiting for OPEN_OK from remote DMShell")
-
-        heartbeat = threading.Thread(target=heartbeat_loop, args=(transport, state), daemon=True)
-        heartbeat.start()
-
-        drain_events(state)
-        if args.command:
-            run_command_mode(transport, state, args.command, args.close_after)
-        else:
-            run_interactive_mode(transport, state)
-
-        state.stopped = True
-        drain_events(state)
-        reader.join(timeout=1.0)
-        heartbeat.join(timeout=1.0)
-        state.close_replay_log()
-    finally:
-        transport.close()
-
-    return 0
-
-
-if __name__ == "__main__":
-    raise SystemExit(main())
@@ -1,43 +0,0 @@
-{
-  "build": {
-    "arduino": {
-      "ldscript": "esp32s3_out.ld",
-      "partitions": "default_16MB.csv",
-      "memory_type": "qio_opi"
-    },
-    "core": "esp32",
-    "extra_flags": [
-      "-DBOARD_HAS_PSRAM",
-      "-DARDUINO_USB_CDC_ON_BOOT=1",
-      "-DARDUINO_USB_MODE=1",
-      "-DARDUINO_RUNNING_CORE=1",
-      "-DARDUINO_EVENT_RUNNING_CORE=1"
-    ],
-    "f_cpu": "240000000L",
-    "f_flash": "80000000L",
-    "flash_mode": "qio",
-    "psram_type": "opi",
-    "hwids": [["0x303A", "0x1001"]],
-    "mcu": "esp32s3",
-    "variant": "heltec_v4_r8"
-  },
-  "connectivity": ["wifi", "bluetooth", "lora"],
-  "debug": {
-    "default_tool": "esp-builtin",
-    "onboard_tools": ["esp-builtin"],
-    "openocd_target": "esp32s3.cfg"
-  },
-  "frameworks": ["arduino", "espidf"],
-  "name": "heltec_wifi_lora_32 v4 r8 (16 MB FLASH, 8 MB PSRAM)",
-  "upload": {
-    "flash_size": "16MB",
-    "maximum_ram_size": 327680,
-    "maximum_size": 16777216,
-    "use_1200bps_touch": true,
-    "wait_for_upload_port": true,
-    "require_upload_port": true,
-    "speed": 921600
-  },
-  "url": "https://heltec.org/",
-  "vendor": "heltec"
-}
@@ -1,5 +1,4 @@
 #!/usr/bin/bash
-set -e
 export DEBEMAIL="jbennett@incomsystems.biz"
 export PLATFORMIO_LIBDEPS_DIR=pio/libdeps
 export PLATFORMIO_PACKAGES_DIR=pio/packages
@@ -125,7 +125,7 @@ lib_deps =
 [device-ui_base]
 lib_deps =
 	# renovate: datasource=git-refs depName=meshtastic/device-ui packageName=https://github.com/meshtastic/device-ui gitBranch=master
-	https://github.com/meshtastic/device-ui/archive/4bf593a82100b911ff816dddf7158ffdee2114cd.zip
+	https://github.com/meshtastic/device-ui/archive/56e1da4e7d30abcd746a2092a30e422f8cf5fc2b.zip

 ; Common libs for environmental measurements in telemetry module
 [environmental_base]
@@ -162,9 +162,6 @@ along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #elif defined(HELTEC_MESH_NODE_T096)
 #define NUM_PA_POINTS 22
 #define TX_GAIN_LORA 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 13, 13, 13, 12, 11, 10, 9, 8, 7
-#elif defined(HELTEC_V4_R8)
-#define NUM_PA_POINTS 22
-#define TX_GAIN_LORA 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 12, 12, 11, 11, 10, 9, 8, 7
 #else
 // If a board enables USE_KCT8103L_PA but does not match a known variant and has
 // not already provided a PA curve, fail at compile time to avoid unsafe defaults.
@@ -70,25 +70,20 @@ bool GPSUpdateScheduling::isUpdateDue()
 // Have we been searching for a GPS position for too long?
 bool GPSUpdateScheduling::searchedTooLong()
 {
-    constexpr uint32_t oneMinuteMs = 60UL * 1000UL;
-    constexpr uint32_t maxSearchClampMs = 15UL * oneMinuteMs; // Hard cap: 15 minutes is always too long
-    uint32_t elapsed = elapsedSearchMs();
-
-    // Anything over 15 minutes is too long, regardless of the broadcast interval.
-    // TODO: Make a smarter algorithm that backs off the search dwell time when not getting a lock.
-    if (elapsed > maxSearchClampMs)
-        return true;
-
    uint32_t minimumOrConfiguredSecs =
        Default::getConfiguredOrMinimumValue(config.position.position_broadcast_secs, default_broadcast_interval_secs);
    uint32_t maxSearchMs = Default::getConfiguredOrDefaultMs(minimumOrConfiguredSecs, default_broadcast_interval_secs);
+    // If broadcast interval set to max, no such thing as "too long"
+    if (maxSearchMs == UINT32_MAX)
+        return false;

    // If we've been searching longer than our position broadcast interval: that's too long
-    if (elapsed > maxSearchMs)
+    else if (elapsedSearchMs() > maxSearchMs)
        return true;

    // Otherwise, not too long yet!
-    return false;
+    else
+        return false;
 }

 // Updates the predicted time-to-get-lock, by exponentially smoothing the latest observation
@@ -524,11 +524,6 @@ void Screen::handleSetOn(bool on, FrameCallback einkScreensaver)
            delay(100);
 #endif
 #if !ARCH_PORTDUINO
-#if defined(USE_ST7789) && defined(VTFT_CTRL)
-            // Ensure panel power rail is enabled before sending wake commands.
-            pinMode(VTFT_CTRL, OUTPUT);
-            digitalWrite(VTFT_CTRL, LOW);
-#endif
            dispdev->displayOn();
 #endif

@@ -550,6 +545,10 @@ void Screen::handleSetOn(bool on, FrameCallback einkScreensaver)
            ui->init();
 #endif
 #if defined(USE_ST7789) && defined(VTFT_LEDA)
+#ifdef VTFT_CTRL
+            pinMode(VTFT_CTRL, OUTPUT);
+            digitalWrite(VTFT_CTRL, LOW);
+#endif
            ui->init();
 #ifdef ESP_PLATFORM
            analogWrite(VTFT_LEDA, BRIGHTNESS_DEFAULT);
@@ -590,22 +589,23 @@ void Screen::handleSetOn(bool on, FrameCallback einkScreensaver)
 #endif
 #ifdef USE_ST7789
            SPI1.end();
-            // Keep TFT control pins in deterministic states while timed-off.
-            // Floating/default pin states can corrupt panel edge rows on wake.
+#if defined(ARCH_ESP32)
 #ifdef VTFT_LEDA
-            pinMode(VTFT_LEDA, OUTPUT);
-            digitalWrite(VTFT_LEDA, !TFT_BACKLIGHT_ON);
+            pinMode(VTFT_LEDA, ANALOG);
 #endif
 #ifdef VTFT_CTRL
-            pinMode(VTFT_CTRL, OUTPUT);
-            digitalWrite(VTFT_CTRL, HIGH);
+            pinMode(VTFT_CTRL, ANALOG);
+#endif
+            pinMode(ST7789_RESET, ANALOG);
+            pinMode(ST7789_RS, ANALOG);
+            pinMode(ST7789_NSS, ANALOG);
+#else
+            nrf_gpio_cfg_default(VTFT_LEDA);
+            nrf_gpio_cfg_default(VTFT_CTRL);
+            nrf_gpio_cfg_default(ST7789_RESET);
+            nrf_gpio_cfg_default(ST7789_RS);
+            nrf_gpio_cfg_default(ST7789_NSS);
 #endif
-            pinMode(ST7789_RESET, OUTPUT);
-            digitalWrite(ST7789_RESET, HIGH);
-            pinMode(ST7789_RS, OUTPUT);
-            digitalWrite(ST7789_RS, HIGH);
-            pinMode(ST7789_NSS, OUTPUT);
-            digitalWrite(ST7789_NSS, HIGH);
 #endif
 #ifdef USE_ST7796
            SPI1.end();
@@ -422,7 +422,7 @@ static LGFX *tft = nullptr;

 #elif defined(ST7789_CS)
 #include <LovyanGFX.hpp> // Graphics and font library for ST7735 driver chip
-#if defined(HELTEC_V4_TFT) || defined(HELTEC_V4_R8_TFT)
+#ifdef HELTEC_V4_TFT
 #include "chsc6x.h"
 #include "lgfx/v1/Touch.hpp"
 namespace lgfx
@@ -444,11 +444,7 @@ class TOUCH_CHSC6X : public ITouch
    bool init(void) override
    {
        if (chsc6xTouch == nullptr) {
-#if (TOUCH_I2C_PORT == 1)
            chsc6xTouch = new chsc6x(&Wire1, TOUCH_SDA_PIN, TOUCH_SCL_PIN, TOUCH_INT_PIN, TOUCH_RST_PIN);
-#else
-            chsc6xTouch = new chsc6x(&Wire, TOUCH_SDA_PIN, TOUCH_SCL_PIN, TOUCH_INT_PIN, TOUCH_RST_PIN);
-#endif
        }
        chsc6xTouch->chsc6x_init();
        return true;
@@ -485,7 +481,7 @@ class LGFX : public lgfx::LGFX_Device
 #if HAS_TOUCHSCREEN
 #if defined(T_WATCH_S3) || defined(ELECROW)
    lgfx::Touch_FT5x06 _touch_instance;
-#elif defined(HELTEC_V4_TFT) || defined(HELTEC_V4_R8_TFT)
+#elif defined(HELTEC_V4_TFT)
    lgfx::TOUCH_CHSC6X _touch_instance;
 #else
    lgfx::Touch_GT911 _touch_instance;
@@ -504,11 +500,7 @@ class LGFX : public lgfx::LGFX_Device
            cfg.freq_write = SPI_FREQUENCY; // SPI clock for transmission (up to 80MHz, rounded to the value obtained by dividing
                                            // 80MHz by an integer)
            cfg.freq_read = SPI_READ_FREQUENCY; // SPI clock when receiving
-#ifdef SPI_3_WIRE
-            cfg.spi_3wire = SPI_3_WIRE;
-#else
-            cfg.spi_3wire = true;                      // Set to true if reception is done on the MOSI pin
-#endif
+            cfg.spi_3wire = false;
            cfg.use_lock = true;               // Set to true to use transaction locking
            cfg.dma_channel = SPI_DMA_CH_AUTO; // SPI_DMA_CH_AUTO; // Set DMA channel to use (0=not use DMA / 1=1ch / 2=ch /
                                               // SPI_DMA_CH_AUTO=auto setting)
@@ -558,11 +550,8 @@ class LGFX : public lgfx::LGFX_Device
            cfg.rgb_order = false;                        // Set to true if the panel's red and blue are swapped
            cfg.dlen_16bit =
                false;             // Set to true for panels that transmit data length in 16-bit units with 16-bit parallel or SPI
-#if defined(HAS_SDCARD)
            cfg.bus_shared = true; // If the bus is shared with the SD card, set to true (bus control with drawJpgFile etc.)
-#else
-            cfg.bus_shared = false;
-#endif
+
            // Set the following only when the display is shifted with a driver with a variable number of pixels, such as the
            // ST7735 or ILI9163.
            // cfg.memory_width = TFT_WIDTH;   // Maximum width supported by the driver IC
@@ -2,21 +2,18 @@

 #include "meshUtils.h"

-// Convert seconds to ms, clamping at INT32_MAX (~24.86 days)
-static inline uint32_t secondsToMsClamped(uint32_t secs)
-{
-    constexpr uint32_t MAX_MS = static_cast<uint32_t>(INT32_MAX);
-    return (secs > MAX_MS / 1000U) ? MAX_MS : secs * 1000U;
-}
-
 uint32_t Default::getConfiguredOrDefaultMs(uint32_t configuredInterval, uint32_t defaultInterval)
 {
-    return secondsToMsClamped(configuredInterval > 0 ? configuredInterval : defaultInterval);
+    if (configuredInterval > 0)
+        return configuredInterval * 1000;
+    return defaultInterval * 1000;
 }

 uint32_t Default::getConfiguredOrDefaultMs(uint32_t configuredInterval)
 {
-    return secondsToMsClamped(configuredInterval > 0 ? configuredInterval : default_broadcast_interval_secs);
+    if (configuredInterval > 0)
+        return configuredInterval * 1000;
+    return default_broadcast_interval_secs * 1000;
 }

 uint32_t Default::getConfiguredOrDefault(uint32_t configured, uint32_t defaultValue)
@@ -50,14 +47,7 @@ uint32_t Default::getConfiguredOrDefaultMsScaled(uint32_t configured, uint32_t d
                  meshtastic_Config_DeviceConfig_Role_TAK_TRACKER))
        return getConfiguredOrDefaultMs(configured, defaultValue);

-    // Saturate at INT32_MAX to match secondsToMsClamped: float→uint32_t when
-    // out of range is UB, and the result is consumed as an int32_t downstream.
-    constexpr uint32_t MAX_MS = static_cast<uint32_t>(INT32_MAX);
-    uint32_t base = getConfiguredOrDefaultMs(configured, defaultValue);
-    float coef = congestionScalingCoefficient(numOnlineNodes);
-    if (static_cast<double>(base) * static_cast<double>(coef) >= static_cast<double>(MAX_MS))
-        return MAX_MS;
-    return base * coef;
+    return getConfiguredOrDefaultMs(configured, defaultValue) * congestionScalingCoefficient(numOnlineNodes);
 }

 uint32_t Default::getConfiguredOrMinimumValue(uint32_t configured, uint32_t minValue)
@@ -76,4 +66,4 @@ uint8_t Default::getConfiguredOrDefaultHopLimit(uint8_t configured)
 #else
    return (configured >= HOP_MAX) ? HOP_MAX : config.lora.hop_limit;
 #endif
-}
+}
@@ -688,7 +688,7 @@ void NodeDB::installDefaultConfig(bool preserveKey = false)
    strncpy(config.network.ntp_server, "meshtastic.pool.ntp.org", 32);

 #if (defined(T_DECK) || defined(T_WATCH_S3) || defined(UNPHONE) || defined(PICOMPUTER_S3) || defined(SENSECAP_INDICATOR) ||      \
-     defined(ELECROW_PANEL) || defined(HELTEC_V4_TFT) || defined(HELTEC_V4_R8_TFT)) &&                                           \
+     defined(ELECROW_PANEL) || defined(HELTEC_V4_TFT)) &&                                                                        \
    HAS_TFT
    // switch BT off by default; use TFT programming mode or hotkey to enable
    config.bluetooth.enabled = false;
@@ -1205,11 +1205,11 @@ void NodeDB::loadFromDisk()
    spiLock->unlock();
 #endif
 #ifdef FSCom
-#if defined(FACTORY_INSTALL) && !defined(ARCH_PORTDUINO)
+#ifdef FACTORY_INSTALL
    spiLock->lock();
    if (!FSCom.exists("/prefs/" xstr(BUILD_EPOCH))) {
        LOG_WARN("Factory Install Reset!");
-        rmDir("/prefs");
+        FSCom.format();
        FSCom.mkdir("/prefs");
        File f2 = FSCom.open("/prefs/" xstr(BUILD_EPOCH), FILE_O_WRITE);
        if (f2) {
@@ -179,8 +179,6 @@ class RadioLibInterface : public RadioInterface, protected concurrency::Notified
    /** Attempt to find a packet in the TxQueue. Returns true if the packet was found. */
    virtual bool findInTxQueue(NodeNum from, PacketId id) override;

-    uint8_t packetsInTxQueue() { return txQueue.getMaxLen() - txQueue.getFree(); }
-
    /**
     * Request randomness sourced from the LoRa modem, if supported by the active RadioLib interface.
     * @return true if len bytes were produced, false otherwise.
@@ -55,7 +55,7 @@ extern const pb_msgdesc_t meshtastic_ChannelSet_msg;

 /* Maximum encoded size of messages (where known) */
 #define MESHTASTIC_MESHTASTIC_APPONLY_PB_H_MAX_SIZE meshtastic_ChannelSet_size
-#define meshtastic_ChannelSet_size               685
+#define meshtastic_ChannelSet_size               682

 #ifdef __cplusplus
 } /* extern "C" */
@@ -618,8 +618,6 @@ typedef struct _meshtastic_Config_LoRaConfig {
    bool config_ok_to_mqtt;
    /* Set where LORA FEM is enabled, disabled, or not present */
    meshtastic_Config_LoRaConfig_FEM_LNA_Mode fem_lna_mode;
-    /* Don't use radiolib to initialize the radio, instead listen for a serialHal connection */
-    bool serial_hal_only;
 } meshtastic_Config_LoRaConfig;

 typedef struct _meshtastic_Config_BluetoothConfig {
@@ -781,7 +779,7 @@ extern "C" {
 #define meshtastic_Config_NetworkConfig_init_default {0, "", "", "", 0, _meshtastic_Config_NetworkConfig_AddressMode_MIN, false, meshtastic_Config_NetworkConfig_IpV4Config_init_default, "", 0, 0}
 #define meshtastic_Config_NetworkConfig_IpV4Config_init_default {0, 0, 0, 0}
 #define meshtastic_Config_DisplayConfig_init_default {0, _meshtastic_Config_DisplayConfig_DeprecatedGpsCoordinateFormat_MIN, 0, 0, 0, _meshtastic_Config_DisplayConfig_DisplayUnits_MIN, _meshtastic_Config_DisplayConfig_OledType_MIN, _meshtastic_Config_DisplayConfig_DisplayMode_MIN, 0, 0, _meshtastic_Config_DisplayConfig_CompassOrientation_MIN, 0, 0, 0}
-#define meshtastic_Config_LoRaConfig_init_default {0, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, 0, 0, 0, 0, _meshtastic_Config_LoRaConfig_RegionCode_MIN, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0}, 0, 0, _meshtastic_Config_LoRaConfig_FEM_LNA_Mode_MIN, 0}
+#define meshtastic_Config_LoRaConfig_init_default {0, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, 0, 0, 0, 0, _meshtastic_Config_LoRaConfig_RegionCode_MIN, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0}, 0, 0, _meshtastic_Config_LoRaConfig_FEM_LNA_Mode_MIN}
 #define meshtastic_Config_BluetoothConfig_init_default {0, _meshtastic_Config_BluetoothConfig_PairingMode_MIN, 0}
 #define meshtastic_Config_SecurityConfig_init_default {{0, {0}}, {0, {0}}, 0, {{0, {0}}, {0, {0}}, {0, {0}}}, 0, 0, 0, 0}
 #define meshtastic_Config_SessionkeyConfig_init_default {0}
@@ -792,7 +790,7 @@ extern "C" {
 #define meshtastic_Config_NetworkConfig_init_zero {0, "", "", "", 0, _meshtastic_Config_NetworkConfig_AddressMode_MIN, false, meshtastic_Config_NetworkConfig_IpV4Config_init_zero, "", 0, 0}
 #define meshtastic_Config_NetworkConfig_IpV4Config_init_zero {0, 0, 0, 0}
 #define meshtastic_Config_DisplayConfig_init_zero {0, _meshtastic_Config_DisplayConfig_DeprecatedGpsCoordinateFormat_MIN, 0, 0, 0, _meshtastic_Config_DisplayConfig_DisplayUnits_MIN, _meshtastic_Config_DisplayConfig_OledType_MIN, _meshtastic_Config_DisplayConfig_DisplayMode_MIN, 0, 0, _meshtastic_Config_DisplayConfig_CompassOrientation_MIN, 0, 0, 0}
-#define meshtastic_Config_LoRaConfig_init_zero   {0, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, 0, 0, 0, 0, _meshtastic_Config_LoRaConfig_RegionCode_MIN, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0}, 0, 0, _meshtastic_Config_LoRaConfig_FEM_LNA_Mode_MIN, 0}
+#define meshtastic_Config_LoRaConfig_init_zero   {0, _meshtastic_Config_LoRaConfig_ModemPreset_MIN, 0, 0, 0, 0, _meshtastic_Config_LoRaConfig_RegionCode_MIN, 0, 0, 0, 0, 0, 0, 0, 0, 0, {0, 0, 0}, 0, 0, _meshtastic_Config_LoRaConfig_FEM_LNA_Mode_MIN}
 #define meshtastic_Config_BluetoothConfig_init_zero {0, _meshtastic_Config_BluetoothConfig_PairingMode_MIN, 0}
 #define meshtastic_Config_SecurityConfig_init_zero {{0, {0}}, {0, {0}}, 0, {{0, {0}}, {0, {0}}, {0, {0}}}, 0, 0, 0, 0}
 #define meshtastic_Config_SessionkeyConfig_init_zero {0}
@@ -879,7 +877,6 @@ extern "C" {
 #define meshtastic_Config_LoRaConfig_ignore_mqtt_tag 104
 #define meshtastic_Config_LoRaConfig_config_ok_to_mqtt_tag 105
 #define meshtastic_Config_LoRaConfig_fem_lna_mode_tag 106
-#define meshtastic_Config_LoRaConfig_serial_hal_only_tag 107
 #define meshtastic_Config_BluetoothConfig_enabled_tag 1
 #define meshtastic_Config_BluetoothConfig_mode_tag 2
 #define meshtastic_Config_BluetoothConfig_fixed_pin_tag 3
@@ -1032,8 +1029,7 @@ X(a, STATIC,   SINGULAR, BOOL,     pa_fan_disabled,  15) \
 X(a, STATIC,   REPEATED, UINT32,   ignore_incoming, 103) \
 X(a, STATIC,   SINGULAR, BOOL,     ignore_mqtt,     104) \
 X(a, STATIC,   SINGULAR, BOOL,     config_ok_to_mqtt, 105) \
-X(a, STATIC,   SINGULAR, UENUM,    fem_lna_mode,    106) \
-X(a, STATIC,   SINGULAR, BOOL,     serial_hal_only, 107)
+X(a, STATIC,   SINGULAR, UENUM,    fem_lna_mode,    106)
 #define meshtastic_Config_LoRaConfig_CALLBACK NULL
 #define meshtastic_Config_LoRaConfig_DEFAULT NULL

@@ -1090,7 +1086,7 @@ extern const pb_msgdesc_t meshtastic_Config_SessionkeyConfig_msg;
 #define meshtastic_Config_BluetoothConfig_size   10
 #define meshtastic_Config_DeviceConfig_size      100
 #define meshtastic_Config_DisplayConfig_size     36
-#define meshtastic_Config_LoRaConfig_size        91
+#define meshtastic_Config_LoRaConfig_size        88
 #define meshtastic_Config_NetworkConfig_IpV4Config_size 20
 #define meshtastic_Config_NetworkConfig_size     204
 #define meshtastic_Config_PositionConfig_size    62
@@ -361,7 +361,7 @@ extern const pb_msgdesc_t meshtastic_BackupPreferences_msg;
 /* Maximum encoded size of messages (where known) */
 /* meshtastic_NodeDatabase_size depends on runtime parameters */
 #define MESHTASTIC_MESHTASTIC_DEVICEONLY_PB_H_MAX_SIZE meshtastic_BackupPreferences_size
-#define meshtastic_BackupPreferences_size        2432
+#define meshtastic_BackupPreferences_size        2429
 #define meshtastic_ChannelFile_size              718
 #define meshtastic_DeviceState_size              1737
 #define meshtastic_NodeInfoLite_size             196
@@ -205,7 +205,7 @@ extern const pb_msgdesc_t meshtastic_LocalModuleConfig_msg;

 /* Maximum encoded size of messages (where known) */
 #define MESHTASTIC_MESHTASTIC_LOCALONLY_PB_H_MAX_SIZE meshtastic_LocalModuleConfig_size
-#define meshtastic_LocalConfig_size              757
+#define meshtastic_LocalConfig_size              754
 #define meshtastic_LocalModuleConfig_size        820

 #ifdef __cplusplus
@@ -1,19 +0,0 @@
-/* Automatically generated nanopb constant definitions */
-/* Generated by nanopb-0.4.9.1 */
-
-#include "meshtastic/serial_hal.pb.h"
-#if PB_PROTO_HEADER_VERSION != 40
-#error Regenerate this file with the current version of nanopb generator.
-#endif
-
-PB_BIND(meshtastic_SerialHalCommand, meshtastic_SerialHalCommand, 2)
-
-
-PB_BIND(meshtastic_SerialHalResponse, meshtastic_SerialHalResponse, 2)
-
-
-
-
-
-
-
@@ -1,135 +0,0 @@
-/* Automatically generated nanopb header */
-/* Generated by nanopb-0.4.9.1 */
-
-#ifndef PB_MESHTASTIC_MESHTASTIC_SERIAL_HAL_PB_H_INCLUDED
-#define PB_MESHTASTIC_MESHTASTIC_SERIAL_HAL_PB_H_INCLUDED
-#include <pb.h>
-
-#if PB_PROTO_HEADER_VERSION != 40
-#error Regenerate this file with the current version of nanopb generator.
-#endif
-
-/* Enum definitions */
-typedef enum _meshtastic_SerialHalCommand_Type {
-    meshtastic_SerialHalCommand_Type_UNSET = 0,
-    meshtastic_SerialHalCommand_Type_PIN_MODE = 1,
-    meshtastic_SerialHalCommand_Type_DIGITAL_WRITE = 2,
-    meshtastic_SerialHalCommand_Type_DIGITAL_READ = 3,
-    meshtastic_SerialHalCommand_Type_ATTACH_INTERRUPT = 4,
-    meshtastic_SerialHalCommand_Type_DETACH_INTERRUPT = 5,
-    meshtastic_SerialHalCommand_Type_SPI_TRANSFER = 6,
-    meshtastic_SerialHalCommand_Type_NOOP = 7
-} meshtastic_SerialHalCommand_Type;
-
-typedef enum _meshtastic_SerialHalResponse_Result {
-    meshtastic_SerialHalResponse_Result_OK = 0,
-    meshtastic_SerialHalResponse_Result_ERROR = 1,
-    meshtastic_SerialHalResponse_Result_BAD_REQUEST = 2,
-    meshtastic_SerialHalResponse_Result_UNSUPPORTED = 3
-} meshtastic_SerialHalResponse_Result;
-
-/* Struct definitions */
-typedef PB_BYTES_ARRAY_T(512) meshtastic_SerialHalCommand_data_t;
-typedef struct _meshtastic_SerialHalCommand {
-    /* Host-assigned request id. Replies echo this id back in
- SerialHalResponse.transaction_id. */
-    uint32_t transaction_id;
-    meshtastic_SerialHalCommand_Type type;
-    uint32_t pin;
-    uint32_t value;
-    uint32_t mode;
-    meshtastic_SerialHalCommand_data_t data;
-} meshtastic_SerialHalCommand;
-
-typedef PB_BYTES_ARRAY_T(512) meshtastic_SerialHalResponse_data_t;
-typedef struct _meshtastic_SerialHalResponse {
-    /* Matches the originating SerialHalCommand.transaction_id for normal
- request/response traffic.
-
- A value of 0 indicates an unsolicited interrupt notification generated by
- the device. In that case, the host should interpret value as the GPIO pin
- that triggered. */
-    uint32_t transaction_id;
-    meshtastic_SerialHalResponse_Result result;
-    /* Used by DIGITAL_READ replies and interrupt notifications. For interrupt
- notifications (transaction_id == 0), this carries the pin number. */
-    uint32_t value;
-    meshtastic_SerialHalResponse_data_t data;
-    char error[80];
-} meshtastic_SerialHalResponse;
-
-
-#ifdef __cplusplus
-extern "C" {
-#endif
-
-/* Helper constants for enums */
-#define _meshtastic_SerialHalCommand_Type_MIN meshtastic_SerialHalCommand_Type_UNSET
-#define _meshtastic_SerialHalCommand_Type_MAX meshtastic_SerialHalCommand_Type_NOOP
-#define _meshtastic_SerialHalCommand_Type_ARRAYSIZE ((meshtastic_SerialHalCommand_Type)(meshtastic_SerialHalCommand_Type_NOOP+1))
-
-#define _meshtastic_SerialHalResponse_Result_MIN meshtastic_SerialHalResponse_Result_OK
-#define _meshtastic_SerialHalResponse_Result_MAX meshtastic_SerialHalResponse_Result_UNSUPPORTED
-#define _meshtastic_SerialHalResponse_Result_ARRAYSIZE ((meshtastic_SerialHalResponse_Result)(meshtastic_SerialHalResponse_Result_UNSUPPORTED+1))
-
-#define meshtastic_SerialHalCommand_type_ENUMTYPE meshtastic_SerialHalCommand_Type
-
-#define meshtastic_SerialHalResponse_result_ENUMTYPE meshtastic_SerialHalResponse_Result
-
-
-/* Initializer values for message structs */
-#define meshtastic_SerialHalCommand_init_default {0, _meshtastic_SerialHalCommand_Type_MIN, 0, 0, 0, {0, {0}}}
-#define meshtastic_SerialHalResponse_init_default {0, _meshtastic_SerialHalResponse_Result_MIN, 0, {0, {0}}, ""}
-#define meshtastic_SerialHalCommand_init_zero    {0, _meshtastic_SerialHalCommand_Type_MIN, 0, 0, 0, {0, {0}}}
-#define meshtastic_SerialHalResponse_init_zero   {0, _meshtastic_SerialHalResponse_Result_MIN, 0, {0, {0}}, ""}
-
-/* Field tags (for use in manual encoding/decoding) */
-#define meshtastic_SerialHalCommand_transaction_id_tag 1
-#define meshtastic_SerialHalCommand_type_tag     2
-#define meshtastic_SerialHalCommand_pin_tag      3
-#define meshtastic_SerialHalCommand_value_tag    4
-#define meshtastic_SerialHalCommand_mode_tag     5
-#define meshtastic_SerialHalCommand_data_tag     6
-#define meshtastic_SerialHalResponse_transaction_id_tag 1
-#define meshtastic_SerialHalResponse_result_tag  2
-#define meshtastic_SerialHalResponse_value_tag   3
-#define meshtastic_SerialHalResponse_data_tag    4
-#define meshtastic_SerialHalResponse_error_tag   5
-
-/* Struct field encoding specification for nanopb */
-#define meshtastic_SerialHalCommand_FIELDLIST(X, a) \
-X(a, STATIC,   SINGULAR, UINT32,   transaction_id,    1) \
-X(a, STATIC,   SINGULAR, UENUM,    type,              2) \
-X(a, STATIC,   SINGULAR, UINT32,   pin,               3) \
-X(a, STATIC,   SINGULAR, UINT32,   value,             4) \
-X(a, STATIC,   SINGULAR, UINT32,   mode,              5) \
-X(a, STATIC,   SINGULAR, BYTES,    data,              6)
-#define meshtastic_SerialHalCommand_CALLBACK NULL
-#define meshtastic_SerialHalCommand_DEFAULT NULL
-
-#define meshtastic_SerialHalResponse_FIELDLIST(X, a) \
-X(a, STATIC,   SINGULAR, UINT32,   transaction_id,    1) \
-X(a, STATIC,   SINGULAR, UENUM,    result,            2) \
-X(a, STATIC,   SINGULAR, UINT32,   value,             3) \
-X(a, STATIC,   SINGULAR, BYTES,    data,              4) \
-X(a, STATIC,   SINGULAR, STRING,   error,             5)
-#define meshtastic_SerialHalResponse_CALLBACK NULL
-#define meshtastic_SerialHalResponse_DEFAULT NULL
-
-extern const pb_msgdesc_t meshtastic_SerialHalCommand_msg;
-extern const pb_msgdesc_t meshtastic_SerialHalResponse_msg;
-
-/* Defines for backwards compatibility with code written before nanopb-0.4.0 */
-#define meshtastic_SerialHalCommand_fields &meshtastic_SerialHalCommand_msg
-#define meshtastic_SerialHalResponse_fields &meshtastic_SerialHalResponse_msg
-
-/* Maximum encoded size of messages (where known) */
-#define MESHTASTIC_MESHTASTIC_SERIAL_HAL_PB_H_MAX_SIZE meshtastic_SerialHalResponse_size
-#define meshtastic_SerialHalCommand_size         541
-#define meshtastic_SerialHalResponse_size        610
-
-#ifdef __cplusplus
-} /* extern "C" */
-#endif
-
-#endif
@@ -1,604 +0,0 @@
-#include "DMShell.h"
-
-#if defined(ARCH_PORTDUINO)
-
-#include "Channels.h"
-#include "MeshService.h"
-#include "NodeDB.h"
-#include "Throttle.h"
-#include "configuration.h"
-#include "mesh/generated/meshtastic/mesh.pb.h"
-#include "mesh/mesh-pb-constants.h"
-#include "pb_decode.h"
-#include "pb_encode.h"
-#include <errno.h>
-#include <fcntl.h>
-#include <pty.h>
-#include <signal.h>
-#include <stdlib.h>
-#include <string.h>
-#include <sys/ioctl.h>
-#include <sys/types.h>
-#include <sys/wait.h>
-#include <unistd.h>
-
-DMShellModule *dmShellModule;
-
-namespace
-{
-constexpr uint16_t PTY_COLS_DEFAULT = 120;
-constexpr uint16_t PTY_ROWS_DEFAULT = 40;
-constexpr size_t MAX_MESSAGE_SIZE = 200;
-} // namespace
-
-DMShellModule::DMShellModule()
-    : SinglePortModule("DMShellModule", meshtastic_PortNum_REMOTE_SHELL_APP), concurrency::OSThread("DMShell", 100)
-{
-    LOG_WARN("DMShell enabled on Portduino: remote shell access is dangerous and intended for trusted debugging only");
-}
-
-ProcessMessage DMShellModule::handleReceived(const meshtastic_MeshPacket &mp)
-{
-    meshtastic_RemoteShell frame = meshtastic_RemoteShell_init_zero;
-    if (!mp.pki_encrypted) {
-        LOG_WARN("DMShell: ignoring packet without PKI from 0x%x", mp.from);
-        return ProcessMessage::STOP;
-    }
-
-    if (!parseFrame(mp, frame)) {
-        LOG_WARN("DMShell: ignoring malformed frame");
-        return ProcessMessage::STOP;
-    }
-
-    if (frame.op == meshtastic_RemoteShell_OpCode_ACK) {
-        if (session.active && frame.session_id == session.sessionId && getFrom(&mp) == session.peer && frame.last_rx_seq > 0) {
-            resendFramesFrom(frame.last_rx_seq + 1);
-        }
-        return ProcessMessage::CONTINUE;
-    }
-
-    if (frame.op >= 64) {
-        LOG_WARN("DMShell: ignoring frame with op code %d, seq %d", frame.op, frame.seq);
-        return ProcessMessage::CONTINUE;
-    }
-
-    if (!isAuthorizedPacket(mp)) {
-        LOG_WARN("DMShell: unauthorized sender 0x%x, %u", mp.from, frame.op);
-        myReply = allocErrorResponse(meshtastic_Routing_Error_NOT_AUTHORIZED, &mp);
-        return ProcessMessage::STOP;
-    }
-
-    if (frame.op == meshtastic_RemoteShell_OpCode_OPEN) {
-        LOG_WARN("DMShell: received OPEN from 0x%x sessionId=0x%x", mp.from, frame.session_id);
-        if (!openSession(mp, frame)) {
-            sendError("open_failed", getFrom(&mp));
-        }
-        return ProcessMessage::STOP;
-    }
-
-    if (!session.active || frame.session_id != session.sessionId || getFrom(&mp) != session.peer) {
-        if (!session.active) {
-            LOG_WARN("DMShell: no active session, rejecting op %d from 0x%x", frame.op, mp.from);
-        } else {
-            LOG_WARN("DMShell: session ID mismatch (got 0x%x expected 0x%x) or peer mismatch (got 0x%x expected 0x%x), rejecting "
-                     "op %d",
-                     frame.session_id, session.sessionId, mp.from, session.peer, frame.op);
-        }
-        sendError("invalid_session", getFrom(&mp));
-        return ProcessMessage::STOP;
-    }
-
-    if (!shouldProcessIncomingFrame(frame)) {
-        return ProcessMessage::STOP;
-    }
-
-    session.lastActivityMs = millis();
-
-    switch (frame.op) {
-    case meshtastic_RemoteShell_OpCode_INPUT:
-        if (!writeSessionInput(frame)) {
-            sendError("input_write_failed");
-        } else {
-            uint8_t outBuf[MAX_MESSAGE_SIZE];
-            const ssize_t bytesRead = read(session.masterFd, outBuf, sizeof(outBuf));
-            if (bytesRead > 0) {
-                LOG_WARN("DMShell: read %zd bytes from PTY", bytesRead);
-                meshtastic_RemoteShell frame = {
-                    .op = meshtastic_RemoteShell_OpCode_OUTPUT,
-                    .session_id = session.sessionId,
-                    .seq = session.nextTxSeq++,
-                    .ack_seq = session.lastAckedRxSeq,
-                    .cols = 0,
-                    .rows = 0,
-                    .flags = 0,
-                };
-                assert(bytesRead <= sizeof(frame.payload.bytes));
-                memcpy(frame.payload.bytes, outBuf, bytesRead);
-                frame.payload.size = bytesRead;
-                sendFrameToPeer(session.peer, frame, true);
-                session.lastActivityMs = millis();
-            }
-        }
-        break;
-    case meshtastic_RemoteShell_OpCode_RESIZE:
-        if (frame.rows > 0 && frame.cols > 0) {
-            struct winsize ws = {};
-            ws.ws_row = frame.rows;
-            ws.ws_col = frame.cols;
-            if (session.masterFd >= 0) {
-                ioctl(session.masterFd, TIOCSWINSZ, &ws);
-            }
-        }
-        break;
-    case meshtastic_RemoteShell_OpCode_PING: {
-        uint32_t peerLastRxSeq = frame.ack_seq;
-        if (frame.last_rx_seq > 0) {
-            peerLastRxSeq = frame.last_rx_seq;
-        }
-
-        const uint32_t nextMissingForPeer = peerLastRxSeq + 1;
-        if (nextMissingForPeer > 0 && nextMissingForPeer < session.nextTxSeq) {
-            resendFramesFrom(nextMissingForPeer);
-        }
-
-        meshtastic_RemoteShell frame = {
-            .op = meshtastic_RemoteShell_OpCode_PONG,
-            .session_id = session.sessionId,
-            .seq = session.nextTxSeq++,
-            .ack_seq = session.lastAckedRxSeq,
-            .cols = 0,
-            .rows = 0,
-            .flags = 0,
-            .last_tx_seq = session.nextTxSeq > 0 ? session.nextTxSeq - 1 : 0,
-            .last_rx_seq = session.lastAckedRxSeq,
-        };
-        frame.payload.size = 0;
-        sendFrameToPeer(session.peer, frame, true);
-        break;
-    }
-    case meshtastic_RemoteShell_OpCode_CLOSE:
-        closeSession("peer_close", true);
-        break;
-    default:
-        sendError("unsupported_op");
-        break;
-    }
-
-    return ProcessMessage::STOP;
-}
-
-int32_t DMShellModule::runOnce()
-{
-    processPendingChildReap();
-
-    if (!session.active) {
-        return 100;
-    }
-
-    reapChildIfExited();
-    if (!session.active) {
-        return 100;
-    }
-
-    if (Throttle::isWithinTimespanMs(session.lastActivityMs, SESSION_IDLE_TIMEOUT_MS) == false) {
-        closeSession("idle_timeout", true);
-        return 100;
-    }
-
-    if (RadioLibInterface::instance->packetsInTxQueue() > 1) {
-        return 50;
-    }
-
-    uint8_t outBuf[MAX_MESSAGE_SIZE];
-    while (session.masterFd >= 0) {
-        const ssize_t bytesRead = read(session.masterFd, outBuf, sizeof(outBuf));
-        if (bytesRead > 0) {
-            LOG_WARN("DMShell: read %zd bytes from PTY", bytesRead);
-
-            meshtastic_RemoteShell frame = {
-                .op = meshtastic_RemoteShell_OpCode_OUTPUT,
-                .session_id = session.sessionId,
-                .seq = session.nextTxSeq++,
-                .ack_seq = session.lastAckedRxSeq,
-                .cols = 0,
-                .rows = 0,
-                .flags = 0,
-            };
-            assert(bytesRead <= sizeof(frame.payload.bytes));
-            memcpy(frame.payload.bytes, outBuf, bytesRead);
-            frame.payload.size = bytesRead;
-            sendFrameToPeer(session.peer, frame, true);
-
-            session.lastActivityMs = millis();
-            // continue;
-            // do we want to ack every data message, and only send the next on ack?
-            // would require some retry logic. Maybe re-use the wantAck bit
-            return 50;
-        }
-
-        if (bytesRead == 0) {
-            closeSession("pty_eof", true);
-            break;
-        }
-
-        if (errno == EAGAIN || errno == EWOULDBLOCK) {
-            break;
-        }
-
-        LOG_WARN("DMShell: PTY read error errno=%d", errno);
-        closeSession("pty_read_error", true);
-        break;
-    }
-
-    return 100;
-}
-
-bool DMShellModule::parseFrame(const meshtastic_MeshPacket &mp, meshtastic_RemoteShell &outFrame)
-{
-    if (mp.which_payload_variant != meshtastic_MeshPacket_decoded_tag) {
-        return false;
-    }
-
-    if (pb_decode_from_bytes(mp.decoded.payload.bytes, mp.decoded.payload.size, meshtastic_RemoteShell_fields, &outFrame)) {
-        LOG_INFO("Received a DMShell message");
-    } else {
-        LOG_ERROR("Error decoding DMShell message!");
-        return false;
-    }
-
-    return true;
-}
-
-bool DMShellModule::isAuthorizedPacket(const meshtastic_MeshPacket &mp) const
-{
-    if (mp.from == 0) {
-        return !config.security.is_managed;
-    }
-
-    const meshtastic_Channel *ch = &channels.getByIndex(mp.channel);
-    if (strcasecmp(ch->settings.name, Channels::adminChannel) == 0) {
-        return config.security.admin_channel_enabled;
-    }
-
-    if (mp.pki_encrypted) {
-        for (uint8_t i = 0; i < 3; ++i) {
-            if (config.security.admin_key[i].size == 32 &&
-                memcmp(mp.public_key.bytes, config.security.admin_key[i].bytes, 32) == 0) {
-                return true;
-            }
-        }
-    }
-
-    return false;
-}
-
-bool DMShellModule::openSession(const meshtastic_MeshPacket &mp, const meshtastic_RemoteShell &frame)
-{
-    if (session.active) {
-        closeSession("preempted", false);
-    }
-
-    int masterFd = -1;
-    struct winsize ws = {};
-    if (frame.rows > 0) {
-        ws.ws_row = frame.rows;
-    } else {
-        ws.ws_row = PTY_ROWS_DEFAULT;
-    }
-    if (frame.cols > 0) {
-        ws.ws_col = frame.cols;
-    } else {
-        ws.ws_col = PTY_COLS_DEFAULT;
-    }
-    const pid_t childPid = forkpty(&masterFd, nullptr, nullptr, &ws);
-    if (childPid < 0) {
-        LOG_ERROR("DMShell: forkpty failed errno=%d", errno);
-        return false;
-    }
-
-    if (childPid == 0) {
-        const char *shell = getenv("SHELL");
-        if (!shell || !*shell) {
-            shell = "/bin/sh";
-        }
-        execl(shell, shell, "-i", static_cast<char *>(nullptr));
-        _exit(127);
-    }
-
-    const int flags = fcntl(masterFd, F_GETFL, 0);
-    if (flags >= 0) {
-        fcntl(masterFd, F_SETFL, flags | O_NONBLOCK);
-    }
-
-    session.active = true;
-    session.sessionId = (frame.session_id != 0) ? frame.session_id : static_cast<uint32_t>(random(1, 0x7fffffff));
-    session.peer = getFrom(&mp);
-    session.channel = mp.channel;
-    session.masterFd = masterFd;
-    session.childPid = childPid;
-    session.nextTxSeq = 1;
-    session.lastAckedRxSeq = frame.seq;
-    session.nextExpectedRxSeq = frame.seq + 1;
-    session.highestSeenRxSeq = frame.seq;
-    session.lastActivityMs = millis();
-
-    meshtastic_RemoteShell newFrame = {
-        .op = meshtastic_RemoteShell_OpCode_OPEN_OK,
-        .session_id = session.sessionId,
-        .seq = session.nextTxSeq++,
-        .ack_seq = frame.seq,
-        .cols = ws.ws_col,
-        .rows = ws.ws_row,
-        .flags = 0,
-    };
-    newFrame.payload.size = 0;
-    sendFrameToPeer(session.peer, newFrame, true);
-
-    LOG_INFO("DMShell: opened session=0x%x peer=0x%x pid=%d", session.sessionId, session.peer, session.childPid);
-    return true;
-}
-
-bool DMShellModule::writeSessionInput(const meshtastic_RemoteShell &frame)
-{
-    if (session.masterFd < 0) {
-        return false;
-    }
-    if (frame.payload.size == 0) {
-        return true;
-    }
-
-    const ssize_t bytesWritten = write(session.masterFd, frame.payload.bytes, frame.payload.size);
-    return bytesWritten >= 0;
-}
-
-void DMShellModule::closeSession(const char *reason, bool notifyPeer)
-{
-    if (!session.active) {
-        return;
-    }
-
-    if (notifyPeer) {
-        const size_t reasonLen = strnlen(reason, 256);
-        meshtastic_RemoteShell frame = {
-            .op = meshtastic_RemoteShell_OpCode_CLOSED,
-            .session_id = session.sessionId,
-            .seq = session.nextTxSeq++,
-            .ack_seq = session.lastAckedRxSeq,
-            .cols = 0,
-            .rows = 0,
-            .flags = 0,
-        };
-        assert(reasonLen <= sizeof(frame.payload.bytes));
-        memcpy(frame.payload.bytes, reason, reasonLen);
-        frame.payload.size = reasonLen;
-        sendFrameToPeer(session.peer, frame, true);
-    }
-
-    if (session.masterFd >= 0) {
-        close(session.masterFd);
-        session.masterFd = -1;
-    }
-
-    if (session.childPid > 0) {
-        // Run this to avoid forgetting a child
-        processPendingChildReap();
-
-        if (kill(session.childPid, SIGTERM) < 0 && errno != ESRCH) {
-            LOG_WARN("DMShell: failed to send SIGTERM to pid=%d errno=%d", session.childPid, errno);
-        }
-
-        pendingChildPid = session.childPid;
-        session.childPid = -1;
-    }
-
-    LOG_INFO("DMShell: closed session=0x%x reason=%s", session.sessionId, reason);
-    session = DMShellSession{};
-}
-
-void DMShellModule::reapChildIfExited()
-{
-    if (!session.active || session.childPid <= 0) {
-        return;
-    }
-
-    int status = 0;
-    const pid_t result = waitpid(session.childPid, &status, WNOHANG);
-    if (result == session.childPid) {
-        closeSession("shell_exited", true);
-    }
-}
-
-void DMShellModule::processPendingChildReap()
-{
-    if (pendingChildPid <= 0) {
-        return;
-    }
-
-    int status = 0;
-    const pid_t result = waitpid(pendingChildPid, &status, WNOHANG);
-
-    if (result == pendingChildPid || (result < 0 && errno == ECHILD)) {
-        pendingChildPid = -1;
-        return;
-    }
-
-    if (result < 0) {
-        LOG_WARN("DMShell: waitpid failed for pid=%d errno=%d", pendingChildPid, errno);
-        pendingChildPid = -1;
-        return;
-    }
-
-    if (pendingChildPid > 0) {
-        if (kill(pendingChildPid, SIGKILL) < 0 && errno != ESRCH) {
-            LOG_WARN("DMShell: failed to send SIGKILL to pid=%d errno=%d", pendingChildPid, errno);
-        }
-        pendingChildPid = -1;
-    }
-}
-
-void DMShellModule::rememberSentFrame(meshtastic_RemoteShell frame)
-{
-    if (frame.seq == 0 || frame.op == meshtastic_RemoteShell_OpCode_ACK) {
-        return;
-    }
-
-    auto &entry = session.txHistory[session.txHistoryNext];
-    entry.valid = true;
-    entry.op = frame.op;
-    entry.sessionId = frame.session_id;
-    entry.seq = frame.seq;
-    entry.ackSeq = frame.ack_seq;
-    entry.cols = frame.cols;
-    entry.rows = frame.rows;
-    entry.flags = frame.flags;
-    entry.payloadLen = frame.payload.size;
-    if (frame.payload.size > 0) {
-        memcpy(entry.payload, frame.payload.bytes, frame.payload.size);
-    }
-
-    session.txHistoryNext = (session.txHistoryNext + 1) % session.txHistory.size();
-}
-
-void DMShellModule::resendFramesFrom(uint32_t startSeq)
-{
-    if (startSeq == 0) {
-        return;
-    }
-
-    DMShellSession::SentFrame *match = nullptr;
-    for (auto &entry : session.txHistory) {
-        if (!entry.valid || entry.seq != startSeq) {
-            continue;
-        }
-        match = &entry;
-        break;
-    }
-
-    if (!match) {
-        LOG_WARN("DMShell: replay request for seq=%u not found in history", startSeq);
-        return;
-    }
-
-    LOG_INFO("DMShell: replaying frame seq=%u op=%d", match->seq, match->op);
-    meshtastic_RemoteShell frame = {
-        .op = match->op,
-        .session_id = match->sessionId,
-        .seq = match->seq,
-        .ack_seq = match->ackSeq,
-        .cols = match->cols,
-        .rows = match->rows,
-        .flags = match->flags,
-    };
-    assert(match->payloadLen <= sizeof(frame.payload.bytes));
-    memcpy(frame.payload.bytes, match->payload, match->payloadLen);
-    frame.payload.size = match->payloadLen;
-    sendFrameToPeer(session.peer, frame, false);
-}
-
-void DMShellModule::sendAck(uint32_t replayFromSeq)
-{
-    if (replayFromSeq > 0) {
-        LOG_WARN("DMShell: requesting replay from seq=%u", replayFromSeq);
-    }
-    meshtastic_RemoteShell frame = {
-        .op = meshtastic_RemoteShell_OpCode_ACK,
-        .session_id = session.sessionId,
-        .seq = 0,
-        .ack_seq = session.lastAckedRxSeq,
-        .cols = 0,
-        .rows = 0,
-        .flags = 0,
-        .last_rx_seq = replayFromSeq - 1,
-    };
-    frame.payload.size = 0;
-    sendFrameToPeer(session.peer, frame, false);
-}
-
-bool DMShellModule::shouldProcessIncomingFrame(const meshtastic_RemoteShell &frame)
-{
-    if (frame.seq == 0) {
-        return true;
-    }
-
-    if (frame.seq < session.nextExpectedRxSeq) {
-        if (session.highestSeenRxSeq >= session.nextExpectedRxSeq) {
-            sendAck(session.nextExpectedRxSeq);
-        } else {
-            sendAck();
-        }
-        return false;
-    }
-
-    if (frame.seq > session.nextExpectedRxSeq) {
-        if (frame.seq > session.highestSeenRxSeq) {
-            session.highestSeenRxSeq = frame.seq;
-        }
-        sendAck(session.nextExpectedRxSeq);
-        return false;
-    }
-
-    session.lastAckedRxSeq = frame.seq;
-    session.nextExpectedRxSeq = frame.seq + 1;
-    if (frame.seq > session.highestSeenRxSeq) {
-        session.highestSeenRxSeq = frame.seq;
-    }
-    if (session.highestSeenRxSeq >= session.nextExpectedRxSeq) {
-        sendAck(session.nextExpectedRxSeq);
-    } else {
-        session.highestSeenRxSeq = 0;
-    }
-    return true;
-}
-
-void DMShellModule::sendFrameToPeer(NodeNum peer, meshtastic_RemoteShell frame, bool remember)
-{
-    meshtastic_MeshPacket *packet = allocDataPacket();
-    if (!packet) {
-        return;
-    }
-    LOG_WARN("DMShell: building packet op=%u session=0x%x seq=%u payloadLen=%zu", frame.op, frame.session_id, frame.seq,
-             frame.payload.size);
-    const size_t encoded = pb_encode_to_bytes(packet->decoded.payload.bytes, sizeof(packet->decoded.payload.bytes),
-                                              meshtastic_RemoteShell_fields, &frame);
-    if (encoded == 0) {
-        return;
-    }
-    packet->decoded.payload.size = encoded;
-
-    if (remember) {
-        rememberSentFrame(frame);
-    }
-
-    packet->to = peer;
-    packet->hop_limit = 0;
-    packet->hop_start = 0;
-    packet->channel = 0;
-    packet->want_ack = false;
-    packet->pki_encrypted = true;
-    packet->priority = meshtastic_MeshPacket_Priority_RELIABLE;
-    service->sendToMesh(packet);
-}
-
-void DMShellModule::sendError(const char *message, NodeNum peer)
-{
-    const size_t len = strnlen(message, MAX_MESSAGE_SIZE);
-    meshtastic_RemoteShell frame = {
-        .op = meshtastic_RemoteShell_OpCode_ERROR,
-        .session_id = session.sessionId,
-        .seq = session.nextTxSeq++,
-        .ack_seq = session.lastAckedRxSeq,
-        .cols = 0,
-        .rows = 0,
-        .flags = 0,
-    };
-    if (message && len > 0) {
-        assert(len <= sizeof(frame.payload.bytes));
-        memcpy(frame.payload.bytes, message, len);
-        frame.payload.size = len;
-    }
-    if (peer == 0) {
-        peer = session.peer;
-    }
-    sendFrameToPeer(peer, frame, true);
-}
-#endif
@@ -1,77 +0,0 @@
-#pragma once
-
-#include "MeshModule.h"
-#include "Router.h"
-#include "SinglePortModule.h"
-#include "concurrency/OSThread.h"
-#include "configuration.h"
-#include "mesh/generated/meshtastic/mesh.pb.h"
-#include <Arduino.h>
-#include <array>
-#include <functional>
-
-#if defined(ARCH_PORTDUINO)
-
-struct DMShellSession {
-    bool active = false;
-    uint32_t sessionId = 0;
-    NodeNum peer = 0;
-    uint8_t channel = 0;
-    int masterFd = -1;
-    int childPid = -1;
-    uint32_t nextTxSeq = 1;
-    uint32_t lastAckedRxSeq = 0;
-    uint32_t nextExpectedRxSeq = 1;
-    uint32_t highestSeenRxSeq = 0;
-    uint32_t lastActivityMs = 0;
-    struct SentFrame {
-        bool valid = false;
-        meshtastic_RemoteShell_OpCode op = meshtastic_RemoteShell_OpCode_ERROR;
-        uint32_t sessionId = 0;
-        uint32_t seq = 0;
-        uint32_t ackSeq = 0;
-        uint32_t cols = 0;
-        uint32_t rows = 0;
-        uint32_t flags = 0;
-        uint8_t payload[meshtastic_Constants_DATA_PAYLOAD_LEN] = {0};
-        size_t payloadLen = 0;
-    };
-    std::array<SentFrame, 50> txHistory = {};
-    size_t txHistoryNext = 0;
-};
-
-class DMShellModule : private concurrency::OSThread, public SinglePortModule
-{
-
-  public:
-    DMShellModule();
-
-  protected:
-    virtual ProcessMessage handleReceived(const meshtastic_MeshPacket &mp) override;
-    virtual int32_t runOnce() override;
-
-  private:
-    static constexpr uint32_t SESSION_IDLE_TIMEOUT_MS = 5 * 60 * 1000;
-
-    DMShellSession session;
-    pid_t pendingChildPid = -1;
-
-    bool parseFrame(const meshtastic_MeshPacket &mp, meshtastic_RemoteShell &outFrame);
-    bool isAuthorizedPacket(const meshtastic_MeshPacket &mp) const;
-    bool openSession(const meshtastic_MeshPacket &mp, const meshtastic_RemoteShell &frame);
-    bool shouldProcessIncomingFrame(const meshtastic_RemoteShell &frame);
-    bool writeSessionInput(const meshtastic_RemoteShell &frame);
-    void closeSession(const char *reason, bool notifyPeer);
-    void reapChildIfExited();
-    void processPendingChildReap();
-
-    void rememberSentFrame(meshtastic_RemoteShell frame);
-    void resendFramesFrom(uint32_t startSeq);
-    void sendAck(uint32_t replayFromSeq = 0);
-    void sendFrameToPeer(NodeNum peer, meshtastic_RemoteShell frame, bool remember = true);
-    void sendError(const char *message, NodeNum peer = 0);
-};
-
-extern DMShellModule *dmShellModule;
-
-#endif
@@ -49,7 +49,6 @@
 #include "modules/WaypointModule.h"
 #endif
 #if ARCH_PORTDUINO
-#include "modules/DMShell.h"
 #include "modules/Telemetry/HostMetrics.h"
 #if !MESHTASTIC_EXCLUDE_STOREFORWARD
 #include "modules/StoreForwardModule.h"
@@ -196,7 +195,6 @@ void setupModules()
 #endif
 #if ARCH_PORTDUINO
    new HostMetricsModule();
-    dmShellModule = new DMShellModule();
 #endif
 #if HAS_TELEMETRY
    new DeviceTelemetryModule();
@@ -350,8 +350,6 @@ inline bool isConnectedToNetwork()
    return WiFi.isConnected();
 #elif HAS_ETHERNET
    return Ethernet.linkStatus() == LinkON;
-#elif defined(ARCH_PORTDUINO)
-    return true;
 #else
    return false;
 #endif
@@ -494,17 +494,10 @@ void portduinoSetup()
            exit(EXIT_FAILURE);
        }
        char serial[9] = {0};
-        // Pass the full buffer size (9 = 8 chars + null) to getSerialString,
-        // not 8. The function treats `len` as buffer size and reserves one
-        // slot for the null terminator, so passing 8 produced a 7-char serial
-        // and broke the `strlen(serial) == 8` check below — masked on Linux
-        // by the BlueZ HCI MAC fallback in getMacAddr(), but on macOS (where
-        // the BlueZ path is __linux__-guarded) it left mac_address empty and
-        // meshtasticd refused to start.
-        ch341Hal->getSerialString(serial, sizeof(serial));
+        ch341Hal->getSerialString(serial, 8);
        std::cout << "CH341 Serial " << serial << std::endl;
        char product_string[96] = {0};
-        ch341Hal->getProductString(product_string, sizeof(product_string));
+        ch341Hal->getProductString(product_string, 95);
        std::cout << "CH341 Product " << product_string << std::endl;
        if (strlen(serial) == 8 && portduino_config.mac_address.length() < 12) {
            std::cout << "Deriving MAC address from Serial and Product String" << std::endl;
@@ -127,60 +127,6 @@ void test_client_uses_public_channel_minimums()
    TEST_ASSERT_EQUAL_UINT32(60 * 60, position);
 }

-// --- Saturation/clamp tests for getConfiguredOrDefaultMs[Scaled] ---
-// These guard the INT32_MAX clamp added to avoid uint32 wrap of secs*1000 and
-// to keep results safe to cast to int32_t for OSThread runOnce returns.
-
-void test_ms_below_threshold()
-{
-    // Ordinary value passes through unchanged.
-    TEST_ASSERT_EQUAL_UINT32(60000U, Default::getConfiguredOrDefaultMs(60, 0));
-}
-
-void test_ms_at_threshold()
-{
-    // INT32_MAX / 1000 = 2,147,483 — largest secs that does not clamp.
-    TEST_ASSERT_EQUAL_UINT32(2147483000U, Default::getConfiguredOrDefaultMs(2147483U, 0));
-}
-
-void test_ms_just_above_threshold()
-{
-    // One second over the boundary must saturate, not wrap.
-    TEST_ASSERT_EQUAL_UINT32(static_cast<uint32_t>(INT32_MAX), Default::getConfiguredOrDefaultMs(2147484U, 0));
-}
-
-void test_ms_uint32_max()
-{
-    // default_sds_secs == UINT32_MAX on non-routers must not wrap.
-    TEST_ASSERT_EQUAL_UINT32(static_cast<uint32_t>(INT32_MAX), Default::getConfiguredOrDefaultMs(UINT32_MAX, 0));
-}
-
-void test_ms_default_clamps()
-{
-    // Clamp also applies when the default-arg path is taken (configured == 0).
-    TEST_ASSERT_EQUAL_UINT32(static_cast<uint32_t>(INT32_MAX), Default::getConfiguredOrDefaultMs(0, UINT32_MAX));
-}
-
-void test_ms_result_is_int32_safe()
-{
-    // Regression guard for runOnce returns: cast to int32_t must not go negative.
-    int32_t result = static_cast<int32_t>(Default::getConfiguredOrDefaultMs(UINT32_MAX, 0));
-    TEST_ASSERT_GREATER_OR_EQUAL_INT32(0, result);
-}
-
-void test_scaled_overflow_saturates()
-{
-    // long_fast (SF11/BW250) with a 24h base and heavy congestion overflows
-    // the uint32 result without the double-precision guard. Must saturate.
-    config.device.role = meshtastic_Config_DeviceConfig_Role_CLIENT;
-    config.lora.use_preset = false;
-    config.lora.spread_factor = 11;
-    config.lora.bandwidth = 250;
-
-    uint32_t res = Default::getConfiguredOrDefaultMsScaled(0, ONE_DAY, 1000);
-    TEST_ASSERT_EQUAL_UINT32(static_cast<uint32_t>(INT32_MAX), res);
-}
-
 void setup()
 {
    // Small delay to match other test mains
@@ -194,13 +140,6 @@ void setup()
    RUN_TEST(test_router_uses_router_minimums);
    RUN_TEST(test_router_late_uses_router_minimums);
    RUN_TEST(test_client_uses_public_channel_minimums);
-    RUN_TEST(test_ms_below_threshold);
-    RUN_TEST(test_ms_at_threshold);
-    RUN_TEST(test_ms_just_above_threshold);
-    RUN_TEST(test_ms_uint32_max);
-    RUN_TEST(test_ms_default_clamps);
-    RUN_TEST(test_ms_result_is_int32_safe);
-    RUN_TEST(test_scaled_overflow_saturates);
    exit(UNITY_END());
 }

@@ -1,97 +0,0 @@
-#include "../test_helpers.h"
-#include "mesh/mesh-pb-constants.h"
-
-namespace
-{
-struct BytesDecodeState {
-    uint8_t *buffer;
-    size_t capacity;
-    size_t length;
-};
-
-struct BytesEncodeState {
-    const uint8_t *buffer;
-    size_t length;
-};
-
-bool decodeBytesField(pb_istream_t *stream, const pb_field_iter_t *field, void **arg)
-{
-    (void)field;
-    auto *state = static_cast<BytesDecodeState *>(*arg);
-    if (!state) {
-        return false;
-    }
-
-    const size_t fieldLen = stream->bytes_left;
-    if (fieldLen > state->capacity) {
-        return false;
-    }
-
-    if (!pb_read(stream, state->buffer, fieldLen)) {
-        return false;
-    }
-
-    state->length = fieldLen;
-    return true;
-}
-
-bool encodeBytesField(pb_ostream_t *stream, const pb_field_iter_t *field, void *const *arg)
-{
-    auto *state = static_cast<const BytesEncodeState *>(*arg);
-    if (!state || !state->buffer || state->length == 0) {
-        return true;
-    }
-
-    if (!pb_encode_tag_for_field(stream, field)) {
-        return false;
-    }
-
-    return pb_encode_string(stream, state->buffer, state->length);
-}
-
-void assert_dmshell_roundtrip(meshtastic_RemoteShell_OpCode op, uint32_t sessionId, uint32_t seq, const uint8_t *payload,
-                              size_t payloadLen, uint32_t cols = 0, uint32_t rows = 0)
-{
-    meshtastic_RemoteShell tx = meshtastic_RemoteShell_init_zero;
-    tx.op = op;
-    tx.session_id = sessionId;
-    tx.seq = seq;
-    tx.cols = cols;
-    tx.rows = rows;
-
-    uint8_t encoded[meshtastic_Constants_DATA_PAYLOAD_LEN] = {0};
-    size_t encodedLen = pb_encode_to_bytes(encoded, sizeof(encoded), meshtastic_RemoteShell_fields, &tx);
-    TEST_ASSERT_GREATER_THAN_UINT32(0, encodedLen);
-
-    meshtastic_RemoteShell rx = meshtastic_RemoteShell_init_zero;
-
-    TEST_ASSERT_TRUE(pb_decode_from_bytes(encoded, encodedLen, meshtastic_RemoteShell_fields, &rx));
-    TEST_ASSERT_EQUAL(op, rx.op);
-    TEST_ASSERT_EQUAL_UINT32(sessionId, rx.session_id);
-    TEST_ASSERT_EQUAL_UINT32(seq, rx.seq);
-    TEST_ASSERT_EQUAL_UINT32(cols, rx.cols);
-    TEST_ASSERT_EQUAL_UINT32(rows, rx.rows);
-}
-} // namespace
-
-void test_dmshell_open_roundtrip()
-{
-    assert_dmshell_roundtrip(meshtastic_RemoteShell_OpCode_OPEN, 0x101, 1, nullptr, 0, 120, 40);
-}
-
-void test_dmshell_input_roundtrip()
-{
-    const uint8_t payload[] = {'l', 's', '\n'};
-    assert_dmshell_roundtrip(meshtastic_RemoteShell_OpCode_INPUT, 0x202, 2, payload, sizeof(payload));
-}
-
-void test_dmshell_resize_roundtrip()
-{
-    assert_dmshell_roundtrip(meshtastic_RemoteShell_OpCode_RESIZE, 0x303, 3, nullptr, 0, 180, 55);
-}
-
-void test_dmshell_close_roundtrip()
-{
-    const uint8_t reason[] = {'b', 'y', 'e'};
-    assert_dmshell_roundtrip(meshtastic_RemoteShell_OpCode_CLOSE, 0x404, 4, reason, sizeof(reason));
-}
@@ -19,10 +19,6 @@ void test_telemetry_environment_metrics_complete_coverage();
 void test_telemetry_environment_metrics_unset_fields();
 void test_encrypted_packet_serialization();
 void test_empty_encrypted_packet();
-void test_dmshell_open_roundtrip();
-void test_dmshell_input_roundtrip();
-void test_dmshell_resize_roundtrip();
-void test_dmshell_close_roundtrip();

 void setup()
 {
@@ -56,12 +52,6 @@ void setup()
    RUN_TEST(test_encrypted_packet_serialization);
    RUN_TEST(test_empty_encrypted_packet);

-    // DMShell protobuf transport tests
-    RUN_TEST(test_dmshell_open_roundtrip);
-    RUN_TEST(test_dmshell_input_roundtrip);
-    RUN_TEST(test_dmshell_resize_roundtrip);
-    RUN_TEST(test_dmshell_close_roundtrip);
-
    UNITY_END();
 }

@@ -89,10 +89,8 @@ build_flags =
  -D VIEW_240x320
  -D DISPLAY_SET_RESOLUTION
  -D DISPLAY_SIZE=240x320 ; portrait mode
-  -D LGFX_SPI_3WIRE=true
  -D LGFX_PIN_SCK=17
  -D LGFX_PIN_MOSI=33
-  -D LGFX_PIN_MISO=-1
  -D LGFX_PIN_DC=16
  -D LGFX_PIN_CS=15
  -D LGFX_PIN_BL=21
@@ -125,7 +123,7 @@ build_flags =
  -D SCREEN_TRANSITION_FRAMERATE=30
  -D BRIGHTNESS_DEFAULT=130 ; Medium Low Brightness
  -D HAS_TOUCHSCREEN=1
-  -D TOUCH_I2C_PORT=1
+  -D TOUCH_I2C_PORT=0
  -D TOUCH_SLAVE_ADDRESS=0x2E
  -D SCREEN_TOUCH_INT=TOUCH_INT_PIN
  -D SCREEN_TOUCH_RST=TOUCH_RST_PIN
@@ -1,56 +0,0 @@
-#ifndef Pins_Arduino_h
-#define Pins_Arduino_h
-
-#include <stdint.h>
-
-#define USB_VID 0x303a
-#define USB_PID 0x1001
-
-static const uint8_t TX = 43;
-static const uint8_t RX = 44;
-
-static const uint8_t SDA = 17;
-static const uint8_t SCL = 18;
-
-static const uint8_t SS = 8;
-static const uint8_t MOSI = 10;
-static const uint8_t MISO = 11;
-static const uint8_t SCK = 9;
-
-static const uint8_t A0 = 1;
-static const uint8_t A1 = 2;
-static const uint8_t A2 = 3;
-static const uint8_t A3 = 4;
-static const uint8_t A4 = 5;
-static const uint8_t A5 = 6;
-static const uint8_t A6 = 7;
-static const uint8_t A7 = 8;
-static const uint8_t A8 = 9;
-static const uint8_t A9 = 10;
-static const uint8_t A10 = 11;
-static const uint8_t A11 = 12;
-static const uint8_t A12 = 13;
-static const uint8_t A13 = 14;
-static const uint8_t A14 = 15;
-static const uint8_t A15 = 16;
-static const uint8_t A16 = 17;
-static const uint8_t A17 = 18;
-static const uint8_t A18 = 19;
-static const uint8_t A19 = 20;
-
-static const uint8_t T1 = 1;
-static const uint8_t T2 = 2;
-static const uint8_t T3 = 3;
-static const uint8_t T4 = 4;
-static const uint8_t T5 = 5;
-static const uint8_t T6 = 6;
-static const uint8_t T7 = 7;
-static const uint8_t T8 = 8;
-static const uint8_t T9 = 9;
-static const uint8_t T10 = 10;
-static const uint8_t T11 = 11;
-static const uint8_t T12 = 12;
-static const uint8_t T13 = 13;
-static const uint8_t T14 = 14;
-
-#endif /* Pins_Arduino_h */
@@ -1,145 +0,0 @@
-[heltec_v4_r8_base] 
-extends = esp32s3_base
-board = heltec_v4_r8
-board_check = true
-board_build.partitions = default_16MB.csv
-build_flags = 
-  ${esp32s3_base.build_flags}
-  -D HELTEC_V4_R8
-  -D HAS_LORA_FEM=1
-  -D BOARD_HAS_PSRAM
-  -I variants/esp32s3/heltec_v4_r8
-  -ULED_BUILTIN
-
-[env:heltec-v4-r8-oled]
-custom_meshtastic_hw_model = 132
-custom_meshtastic_hw_model_slug = HELTEC_V4_R8
-custom_meshtastic_architecture = esp32-s3
-custom_meshtastic_actively_supported = true
-custom_meshtastic_support_level = 1
-custom_meshtastic_display_name = Heltec V4 R8
-custom_meshtastic_images = heltec_v4_r8.svg
-custom_meshtastic_tags = Heltec
-custom_meshtastic_requires_dfu = true
-custom_meshtastic_partition_scheme = 16MB
-
-extends = heltec_v4_r8_base
-build_flags = 
-  ${heltec_v4_r8_base.build_flags}
-  -D HELTEC_V4_R8_OLED
-  -D USE_SSD1306 ; Heltec_v4_R8 has an SSD1315 display (compatible with SSD1306 driver)
-  -D LED_POWER=46
-  -D RESET_OLED=21
-  -D I2C_SDA=17
-  -D I2C_SCL=18
-
-[env:heltec-v4-r8-tft]
-custom_meshtastic_hw_model = 132
-custom_meshtastic_hw_model_slug = HELTEC_V4_R8
-custom_meshtastic_architecture = esp32-s3
-custom_meshtastic_actively_supported = true
-custom_meshtastic_support_level = 1
-custom_meshtastic_display_name = Heltec V4 R8 TFT
-custom_meshtastic_images = heltec_v4_r8_tft.svg
-custom_meshtastic_tags = Heltec
-custom_meshtastic_requires_dfu = true
-custom_meshtastic_partition_scheme = 16MB
-
-extends = heltec_v4_r8_base
-build_flags = 
-  ${heltec_v4_r8_base.build_flags} ;-Os
-  -D HELTEC_V4_R8_TFT
-  -D I2C_SDA=17
-  -D I2C_SCL=18
-  -D PIN_BUTTON2=46
-  -D ALT_BUTTON_PIN=PIN_BUTTON2
-  -D ALT_BUTTON_ACTIVE_LOW=false
-  -D PIN_BUZZER=4
-  -D USE_PIN_BUZZER=PIN_BUZZER
-  -D CONFIG_ARDUHAL_LOG_COLORS
-  -D RADIOLIB_DEBUG_SPI=0
-  -D RADIOLIB_DEBUG_PROTOCOL=0
-  -D RADIOLIB_DEBUG_BASIC=0
-  -D RADIOLIB_VERBOSE_ASSERT=0
-  -D RADIOLIB_SPI_PARANOID=0
-  -D CONFIG_DISABLE_HAL_LOCKS=1
-  -D INPUTDRIVER_BUTTON_TYPE=0
-  -D HAS_SCREEN=1
-  -D HAS_TFT=1
-  -D RAM_SIZE=5120
-  -D LV_LVGL_H_INCLUDE_SIMPLE
-  -D LV_CONF_INCLUDE_SIMPLE
-  -D LV_COMP_CONF_INCLUDE_SIMPLE
-  -D LV_USE_SYSMON=0
-  -D LV_USE_PROFILER=0
-  -D LV_USE_PERF_MONITOR=0
-  -D LV_USE_MEM_MONITOR=0
-  -D LV_USE_LOG=0
-  -D LV_BUILD_TEST=0
-  -D USE_LOG_DEBUG
-  -D LOG_DEBUG_INC=\"DebugConfiguration.h\"
-  -D USE_PACKET_API
-  -D LGFX_DRIVER=LGFX_HELTEC_V4_TFT
-  -D GFX_DRIVER_INC=\"graphics/LGFX/LGFX_HELTEC_V4_TFT.h\"
-  -D VIEW_240x320
-  -D DISPLAY_SET_RESOLUTION
-  -D DISPLAY_SIZE=240x320 ; portrait mode
-  -D LGFX_SPI_3WIRE=false
-  -D LGFX_PIN_SCK=16
-  -D LGFX_PIN_MOSI=15
-  -D LGFX_PIN_MISO=45
-  -D LGFX_PIN_DC=48
-  -D LGFX_PIN_CS=47
-  -D LGFX_PIN_BL=44
-  -D LGFX_PIN_RST=21
-  -D CUSTOM_TOUCH_DRIVER
-  -D TOUCH_SDA_PIN=I2C_SDA
-  -D TOUCH_SCL_PIN=I2C_SCL
-  -D TOUCH_INT_PIN=-1
-  -D TOUCH_RST_PIN=-1
-;base UI
-  -D TFT_CS=LGFX_PIN_CS
-  -D ST7789_CS=TFT_CS
-  -D ST7789_RS=LGFX_PIN_DC
-  -D ST7789_SDA=LGFX_PIN_MOSI
-  -D ST7789_SCK=LGFX_PIN_SCK
-  -D ST7789_RESET=LGFX_PIN_RST
-  -D ST7789_MISO=LGFX_PIN_MISO
-  -D ST7789_BUSY=-1
-  -D ST7789_BL=LGFX_PIN_BL
-  -D ST7789_SPI_HOST=SPI3_HOST
-  -D TFT_BL=ST7789_BL
-  -D SPI_FREQUENCY=75000000
-  -D SPI_READ_FREQUENCY=SPI_FREQUENCY
-  -D SPI_3_WIRE=false
-  -D TFT_HEIGHT=320
-  -D TFT_WIDTH=240
-  -D TFT_OFFSET_X=0
-  -D TFT_OFFSET_Y=0
-  -D TFT_OFFSET_ROTATION=0
-  -D SCREEN_ROTATE
-  -D SCREEN_TRANSITION_FRAMERATE=5
-  -D BRIGHTNESS_DEFAULT=130 ; Medium Low Brightness
-  -D HAS_TOUCHSCREEN=1
-  -D TOUCH_I2C_PORT=0
-  -D TOUCH_SLAVE_ADDRESS=0x2E
-  -D SCREEN_TOUCH_INT=TOUCH_INT_PIN
-  -D SCREEN_TOUCH_RST=TOUCH_RST_PIN
-
-; Have SPI interface SD card slot
-  -D HAS_SDCARD
-  -D SDCARD_USE_SPI1
-  -D SDCARD_USER_SPI_BEGIN
-  -D SPI_MOSI=LGFX_PIN_MOSI
-  -D SPI_SCK=LGFX_PIN_SCK
-  -D SPI_MISO=LGFX_PIN_MISO
-  -D SPI_CS=3
-  -D SDCARD_CS=SPI_CS
-  -D SD_SPI_FREQUENCY=SPI_FREQUENCY
-
-lib_deps = ${heltec_v4_r8_base.lib_deps}
-  ${device-ui_base.lib_deps}
-  # renovate: datasource=custom.pio depName=LovyanGFX packageName=lovyan03/library/LovyanGFX
-  lovyan03/LovyanGFX@1.2.19
-  # renovate: datasource=git-refs depName=Quency-D_chsc6x packageName=https://github.com/Quency-D/chsc6x gitBranch=master
-  https://github.com/Quency-D/chsc6x/archive/3b2b6cebf3177b3e2c33d06e07909b0b10159516.zip
@@ -1,72 +0,0 @@
-#define VEXT_ENABLE 40 // active low, powers the oled display and the lora antenna boost
-#define VEXT_ON_VALUE LOW
-#define BUTTON_PIN 0
-
-#define BATTERY_PIN 1 // A battery voltage measurement pin, voltage divider connected here to measure battery voltage
-#define ADC_CHANNEL ADC1_GPIO1_CHANNEL
-#define ADC_ATTENUATION ADC_ATTEN_DB_2_5 // lower dB for high resistance voltage divider
-#define ADC_MULTIPLIER 4.9 * 1.035
-
-#define USE_SX1262
-#define LORA_DIO0 -1 // a No connect on the SX1262 module
-#define LORA_RESET 12
-#define LORA_DIO1 14 // SX1262 IRQ
-#define LORA_DIO2 13 // SX1262 BUSY
-#define LORA_DIO3    // Not connected on PCB, but internally on the TTGO SX1262, if DIO3 is high the TCXO is enabled
-
-#define LORA_SCK 9
-#define LORA_MISO 11
-#define LORA_MOSI 10
-#define LORA_CS 8
-
-#define SX126X_CS LORA_CS
-#define SX126X_DIO1 LORA_DIO1
-#define SX126X_BUSY LORA_DIO2
-#define SX126X_RESET LORA_RESET
-
-#define SX126X_DIO2_AS_RF_SWITCH
-#define SX126X_DIO3_TCXO_VOLTAGE 1.8
-
-// Enable Traffic Management Module for Heltec V4
-#ifndef HAS_TRAFFIC_MANAGEMENT
-#define HAS_TRAFFIC_MANAGEMENT 1
-#endif
-#ifndef TRAFFIC_MANAGEMENT_CACHE_SIZE
-#define TRAFFIC_MANAGEMENT_CACHE_SIZE 2048
-#endif
-
-// ---- KCT8103L RF FRONT END CONFIGURATION ----
-// The Heltec V4.3 uses a KCT8103L FEM chip with integrated PA and LNA
-// RF path: SX1262 -> Pi attenuator -> KCT8103L PA -> Antenna
-// Control logic (from KCT8103L datasheet):
-//   Transmit PA:     CSD=1, CTX=1, CPS=1
-//   Receive LNA:     CSD=1, CTX=0, CPS=X  (21dB gain, 1.9dB NF)
-//   Receive bypass:  CSD=1, CTX=1, CPS=0
-//   Shutdown:        CSD=0, CTX=X, CPS=X
-// Pin mapping:
-//   CPS (pin 5)  -> SX1262 DIO2: TX/RX path select (automatic via SX126X_DIO2_AS_RF_SWITCH)
-//   CSD (pin 4)  -> GPIO2: Chip enable (HIGH=on, LOW=shutdown)
-//   CTX (pin 6)  -> GPIO5: Switch between Receive LNA Mode and Receive Bypass Mode. (HIGH=RX bypass, LOW=RX LNA)
-//   VCC0/VCC1    -> Vfem via U3 LDO, controlled by GPIO7
-// KCT8103L FEM: TX/RX path switching is handled by DIO2 -> CPS pin (via SX126X_DIO2_AS_RF_SWITCH)
-
-#define USE_KCT8103L_PA
-#define LORA_PA_POWER 7        // VFEM_Ctrl - KCT8103L LDO power enable
-#define LORA_KCT8103L_PA_CSD 2 // CSD - KCT8103L chip enable (HIGH=on)
-#define LORA_KCT8103L_PA_CTX 5 // CTX - Switch between Receive LNA Mode and Receive Bypass Mode. (HIGH=RX bypass, LOW=RX LNA)
-
-#if HAS_TFT
-#define USE_TFTDISPLAY 1
-#endif
-/*
- * GPS pins
- */
-#define GPS_L76K
-#define PIN_GPS_EN (42)
-#define GPS_EN_ACTIVE LOW
-#define PERIPHERAL_WARMUP_MS 1000 // Make sure I2C QuickLink has stable power before continuing
-#define PIN_GPS_PPS (41)
-// Seems to be missing on this new board
-#define GPS_TX_PIN (38) // This is for bits going TOWARDS the CPU
-#define GPS_RX_PIN (39) // This is for bits going TOWARDS the GPS
-#define GPS_THREAD_INTERVAL 50
@@ -133,39 +133,6 @@ test_testing_command =
 ;     SOCK_NONBLOCK fallback, Common.h __APPLE__ guard, WiFiServer.cpp extern-C
 ;     fix, package.json URL refresh. Pulled by platform-native at its pinned commit.
 ; This env therefore only carries the firmware-side build flags and src filter.
-;
-; Real LoRa hardware on macOS:
-;   The same lib_dep `pine64/libch341-spi-userspace` used on Linux works on
-;   macOS as-is — its `libusb_detach_kernel_driver()` call is `__linux__`-
-;   guarded, but on macOS the kernel doesn't bind a driver to a CH341A SPI
-;   bridge (PID 0x5512; bDeviceClass=0xff vendor-specific) by default, so
-;   no detach is needed. Apple's bundled CH34x driver targets the CH340
-;   *UART* variant (PID 0x7523) — different product. libusb opens the device
-;   and claims interface 0 directly via IOUSBHostInterface.
-;
-;   To use, point `meshtasticd` at any of the existing `bin/config.d/lora-*.yaml`
-;   files that specify `spidev: ch341` — they're platform-agnostic. Example:
-;     pio run -e native-macos
-;     mkdir -p ~/.meshtasticd && cp bin/config-dist.yaml ~/.meshtasticd/config.yaml
-;     # Edit ~/.meshtasticd/config.yaml: ConfigDirectory: ./config.d/
-;     mkdir ~/.meshtasticd/config.d && cp bin/config.d/lora-meshstick-1262.yaml ~/.meshtasticd/config.d/
-;     cd ~/.meshtasticd && /path/to/firmware/.pio/build/native-macos/meshtasticd
-;
-;   The MAC address auto-derives from the CH341's USB serial + product string
-;   (PortduinoGlue.cpp ~497-518); on Linux a BlueZ HCI socket is the fallback
-;   when that path isn't taken, but BlueZ is `__linux__`-guarded so the
-;   serial-derivation path is mandatory on macOS. Override with
-;   `MACAddress: AA:BB:CC:DD:EE:FF` in config.yaml's `General:` section if
-;   the device's serial isn't 8 hex chars.
-;
-;   Diagnosing CH341 issues on macOS:
-;     ioreg -p IOUSB -l -w 0 | grep -B2 -A30 0x5512
-;       Children should be `IOUSBHostInterface`. If a vendor driver class
-;       (e.g. `com.wch.CH34xVCPDriver` from a third-party WCH installer)
-;       claims interface 0, libusb will fail with LIBUSB_ERROR_BUSY.
-;       Workaround: `sudo kmutil unload -b <bundleID>`.
-;     LIBUSB_DEBUG=4 .pio/build/native-macos/meshtasticd
-;       Verbose libusb trace — useful when claim_interface fails.
 ; ---------------------------------------------------------------------------
 [env:native-macos]
 extends = native_base
Author	SHA1	Message	Date
Ben Meadors	ee293c209d	Merge branch 'develop' into macos	2026-04-26 21:05:17 -05:00
Ben Meadors	80ce9c4a75	Merge branch 'develop' into macos	2026-04-26 20:45:50 -05:00
copilot-swe-agent[bot]andthebentern	1d5b9361d8	fix: ensure null-termination in getSerialString() and handle len==0 Agent-Logs-Url: https://github.com/meshtastic/firmware/sessions/e5647919-2255-48ad-bcaa-7a2c2fdbf212 Co-authored-by: thebentern <9000580+thebentern@users.noreply.github.com>	2026-04-27 01:43:53 +00:00
Ben MeadorsandCopilot	12285088d1	Update variants/native/portduino/platformio.ini Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>	2026-04-26 20:42:22 -05:00
Jonathan BennettandCopilot	0e05e715c0	Apply suggestion from @Copilot Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>	2026-04-26 20:08:13 -05:00
Ben Meadors	5b5ebe6fb4	Native MacOS hello world	2026-04-26 07:09:14 -05:00