vnode 0.1.5__tar.gz → 0.1.7__tar.gz

{vnode-0.1.5 → vnode-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: vnode
-Version: 0.1.5
+Version: 0.1.7
 Summary: Virtual Meshtastic node using mudp transport and meshdb storage.
 License-Expression: GPL-3.0-only
 License-File: LICENSE
@@ -30,6 +30,20 @@ Virtual Meshtastic node runtime built around:
 - `meshdb` for packet and node persistence
 - Meshtastic-style PKI DM encryption using X25519 + SHA-256 + AES-CCM
 
+## Install
+
+Install from PyPI:
+
+```bash
+pip install vnode
+```
+
+If you are working from this repository instead:
+
+```bash
+.venv/bin/pip install -e .
+```
+
 ## Config
 
 Edit [node.json](node.json).
@@ -39,6 +53,8 @@ If `node.json` does not exist yet, the runtime will create it automatically from
 
 If the template leaves `node_id` blank, the runtime will generate and persist a random
 Meshtastic-style node ID when it creates or first loads `node.json`.
+If `long_name` or `short_name` are blank, the runtime will also generate them from the
+last 4 hex characters of the node ID, for example `Meshtastic 691c` and `691c`.
 
 The runtime will generate and persist a PKI private key into `node.json` on first run if
 the private key is blank.
@@ -56,7 +72,6 @@ broadcasts.
 ## Run
 
 ```bash
-.venv/bin/pip install -e .
 .venv/bin/python -m vnode --vnode-file node.json run
 ```
 
@@ -82,32 +97,36 @@ node = VirtualNode("node.json")
 packet_id = node.send_text("!1234abcd", "hello")
 ```
 
-The runtime also mirrors the common Meshtastic Python pubsub and method surface:
+Supported `VirtualNode` calls:
 
-- topics: `meshtastic.connection.established`, `meshtastic.connection.lost`, `meshtastic.receive`, `meshtastic.receive.text`, `meshtastic.receive.position`, `meshtastic.receive.user`, `meshtastic.receive.data.<PORTNUM>`, `meshtastic.node.updated`, `meshtastic.log.line`
-- methods: `receive()`, `unreceive()`, `close()`, `sendText()`, `sendData()`, `sendPosition()`, `getMyNodeInfo()`, `getMyUser()`, `getLongName()`
-
-That means code shaped like the Meshtastic Python library can often run on `VirtualNode` with minimal changes.
+- Lifecycle: `start()`, `stop()`, `close()`, `run_forever()`
+- Subscription: `receive(callback)`, `unreceive(callback)`
+- Node identity: `getLongName()`, `getShortName()`, `getPublicKey()`, `getMyUser()`, `getMyNodeInfo()`
+- Native vnode sends: `send_text()`, `send_reply()`, `send_nodeinfo()`, `send_position()`
+- MeshInterface-compatible sends: `sendText()`, `sendAlert()`, `sendData()`, `sendPosition()`
+- Packet helpers: `is_direct_message_for_me()`, `is_text_message()`, `get_text_message()`, `reply_to_packet()`
 
 ## Examples
 
 Use these as small runnable references for common tasks:
 
 - `examples/autoresponder.py`: DM-only reply bot for inbound direct text messages
-- `examples/listen_packets.py`: packet logger using the mirrored `meshtastic.receive` callback shape
+- `examples/basic_subscriptions.py`: minimal `node.receive()` subscription example
+- `examples/listen_packets.py`: packet logger for multicast traffic and decoded text
+- `examples/mesh_interface_compat.py`: examples of MeshInterface-style compatibility calls on `VirtualNode`
+- `examples/serial_or_vnode.py`: try a serial Meshtastic node first, then fall back to `VirtualNode`
 - `examples/send_dm.py`: minimal one-shot direct-message sender
-- `examples/library_embed.py`: minimal application-style embedding example using both vnode and Meshtastic-style APIs
-- `examples/meshtastic_compat.py`: minimal Meshtastic-style example using `meshtastic.*` topics and `sendText()`
-- `examples/serial_or_vnode.py`: try a real serial node first, then fall back to `vnode` when no device is attached
+- `examples/library_embed.py`: minimal application-style embedding example using `VirtualNode` directly
 - `examples/watch_reliability.py`: watcher for ACK, NAK, retry, and retransmit-failure events
 
 ```bash
 .venv/bin/python examples/autoresponder.py
+.venv/bin/python examples/basic_subscriptions.py
 .venv/bin/python examples/listen_packets.py
+.venv/bin/python examples/mesh_interface_compat.py
+.venv/bin/python examples/serial_or_vnode.py
 .venv/bin/python examples/send_dm.py --to '!1234abcd' --message 'hello'
 .venv/bin/python examples/library_embed.py
-.venv/bin/python examples/meshtastic_compat.py
-.venv/bin/python examples/serial_or_vnode.py
 .venv/bin/python examples/watch_reliability.py --to '!1234abcd' --message 'hello'
 ```
 

{vnode-0.1.5 → vnode-0.1.7}/README.md

@@ -6,6 +6,20 @@ Virtual Meshtastic node runtime built around:
 - `meshdb` for packet and node persistence
 - Meshtastic-style PKI DM encryption using X25519 + SHA-256 + AES-CCM
 
+## Install
+
+Install from PyPI:
+
+```bash
+pip install vnode
+```
+
+If you are working from this repository instead:
+
+```bash
+.venv/bin/pip install -e .
+```
+
 ## Config
 
 Edit [node.json](node.json).
@@ -15,6 +29,8 @@ If `node.json` does not exist yet, the runtime will create it automatically from
 
 If the template leaves `node_id` blank, the runtime will generate and persist a random
 Meshtastic-style node ID when it creates or first loads `node.json`.
+If `long_name` or `short_name` are blank, the runtime will also generate them from the
+last 4 hex characters of the node ID, for example `Meshtastic 691c` and `691c`.
 
 The runtime will generate and persist a PKI private key into `node.json` on first run if
 the private key is blank.
@@ -32,7 +48,6 @@ broadcasts.
 ## Run
 
 ```bash
-.venv/bin/pip install -e .
 .venv/bin/python -m vnode --vnode-file node.json run
 ```
 
@@ -58,32 +73,36 @@ node = VirtualNode("node.json")
 packet_id = node.send_text("!1234abcd", "hello")
 ```
 
-The runtime also mirrors the common Meshtastic Python pubsub and method surface:
+Supported `VirtualNode` calls:
 
-- topics: `meshtastic.connection.established`, `meshtastic.connection.lost`, `meshtastic.receive`, `meshtastic.receive.text`, `meshtastic.receive.position`, `meshtastic.receive.user`, `meshtastic.receive.data.<PORTNUM>`, `meshtastic.node.updated`, `meshtastic.log.line`
-- methods: `receive()`, `unreceive()`, `close()`, `sendText()`, `sendData()`, `sendPosition()`, `getMyNodeInfo()`, `getMyUser()`, `getLongName()`
-
-That means code shaped like the Meshtastic Python library can often run on `VirtualNode` with minimal changes.
+- Lifecycle: `start()`, `stop()`, `close()`, `run_forever()`
+- Subscription: `receive(callback)`, `unreceive(callback)`
+- Node identity: `getLongName()`, `getShortName()`, `getPublicKey()`, `getMyUser()`, `getMyNodeInfo()`
+- Native vnode sends: `send_text()`, `send_reply()`, `send_nodeinfo()`, `send_position()`
+- MeshInterface-compatible sends: `sendText()`, `sendAlert()`, `sendData()`, `sendPosition()`
+- Packet helpers: `is_direct_message_for_me()`, `is_text_message()`, `get_text_message()`, `reply_to_packet()`
 
 ## Examples
 
 Use these as small runnable references for common tasks:
 
 - `examples/autoresponder.py`: DM-only reply bot for inbound direct text messages
-- `examples/listen_packets.py`: packet logger using the mirrored `meshtastic.receive` callback shape
+- `examples/basic_subscriptions.py`: minimal `node.receive()` subscription example
+- `examples/listen_packets.py`: packet logger for multicast traffic and decoded text
+- `examples/mesh_interface_compat.py`: examples of MeshInterface-style compatibility calls on `VirtualNode`
+- `examples/serial_or_vnode.py`: try a serial Meshtastic node first, then fall back to `VirtualNode`
 - `examples/send_dm.py`: minimal one-shot direct-message sender
-- `examples/library_embed.py`: minimal application-style embedding example using both vnode and Meshtastic-style APIs
-- `examples/meshtastic_compat.py`: minimal Meshtastic-style example using `meshtastic.*` topics and `sendText()`
-- `examples/serial_or_vnode.py`: try a real serial node first, then fall back to `vnode` when no device is attached
+- `examples/library_embed.py`: minimal application-style embedding example using `VirtualNode` directly
 - `examples/watch_reliability.py`: watcher for ACK, NAK, retry, and retransmit-failure events
 
 ```bash
 .venv/bin/python examples/autoresponder.py
+.venv/bin/python examples/basic_subscriptions.py
 .venv/bin/python examples/listen_packets.py
+.venv/bin/python examples/mesh_interface_compat.py
+.venv/bin/python examples/serial_or_vnode.py
 .venv/bin/python examples/send_dm.py --to '!1234abcd' --message 'hello'
 .venv/bin/python examples/library_embed.py
-.venv/bin/python examples/meshtastic_compat.py
-.venv/bin/python examples/serial_or_vnode.py
 .venv/bin/python examples/watch_reliability.py --to '!1234abcd' --message 'hello'
 ```
 

{vnode-0.1.5 → vnode-0.1.7}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "vnode"
-version = "0.1.5"
+version = "0.1.7"
 description = "Virtual Meshtastic node using mudp transport and meshdb storage."
 authors = [
     {name = "Ben Lipsey",email = "ben@pdxlocations.com"}

{vnode-0.1.5 → vnode-0.1.7}/vnode/vnode/runtime.py

@@ -5,13 +5,12 @@ import sqlite3
 import threading
 import time
 from pathlib import Path
-from types import SimpleNamespace
-from typing import Any, Callable, Dict, Optional, Union
+from typing import Any, Dict, Optional, Union
 
-import meshdb
 from google.protobuf.json_format import MessageToDict
+import meshdb
 from google.protobuf.message import DecodeError
-from meshtastic import BROADCAST_ADDR, BROADCAST_NUM, config_pb2, mesh_pb2, portnums_pb2
+from meshtastic import BROADCAST_ADDR, BROADCAST_NUM, LOCAL_ADDR, config_pb2, mesh_pb2, portnums_pb2, protocols
 from mudp import UDPPacketStream
 from mudp.encryption import encrypt_packet as mudp_encrypt_packet
 from mudp.reliability import is_ack, is_nak, publish_ack, register_pending_ack, send_ack
@@ -64,9 +63,9 @@ def resolve_role(value: Union[str, int]) -> int:
 
 
 class VirtualNode:
-    RECEIVE_TOPIC = "mesh.rx.packet"
     PACKET_TOPIC = "mesh.rx.unique_packet"
     DUPLICATE_TOPIC = "mesh.rx.duplicate"
+    RECEIVE_TOPIC = "meshtastic.receive"
 
     def __init__(self, config_path: Union[str, Path] = "node.json") -> None:
         self.config_path = Path(config_path).resolve()
@@ -84,11 +83,7 @@ class VirtualNode:
         self._last_nodeinfo_sent_monotonic = 0.0
         self._last_position_reply_monotonic = 0.0
         self._last_nodeinfo_seen: Dict[int, int] = {}
-        self._response_handlers: Dict[int, tuple[Callable[[Dict[str, Any]], Any], bool]] = {}
-        self.nodesByNum: Dict[int, Dict[str, Any]] = {}
-        self.nodes: Dict[str, Dict[str, Any]] = {}
-        self.myInfo = SimpleNamespace(my_node_num=self.node_num)
-        self._connected = False
+        self._response_handlers: Dict[int, Dict[str, Any]] = {}
 
         self._ensure_security_keys()
         self._write_public_key_file()
@@ -129,7 +124,6 @@ class VirtualNode:
             is_licensed=int(self.config.is_licensed),
             public_key=self._public_key_b64,
         )
-        self._upsert_local_node_cache()
 
     def _configure_mudp_globals(self) -> None:
         mudp_node.node_id = self.config.node_id
@@ -150,6 +144,9 @@ class VirtualNode:
             return
         pub.subscribe(self._handle_raw_packet, "mesh.rx.packet")
         pub.subscribe(self._handle_unique_packet, self.PACKET_TOPIC)
+        pub.subscribe(self._handle_compat_response_packet, self.RECEIVE_TOPIC)
+        pub.subscribe(self._handle_compat_ack, "mesh.rx.ack")
+        pub.subscribe(self._handle_compat_nak, "mesh.rx.nak")
         self.stream = UDPPacketStream(
             self.config.udp.mcast_group,
             int(self.config.udp.mcast_port),
@@ -157,10 +154,6 @@ class VirtualNode:
             parse_payload=False,
         )
         self.stream.start()
-        self._connected = True
-        self._publish_log_line(f"virtual node connected: {self.config.node_id}")
-        pub.sendMessage("meshtastic.connection.established", interface=self)
-        self._publish_node_updated(self.nodesByNum[self.node_num])
         if self.config.broadcasts.send_startup_nodeinfo:
             self.send_nodeinfo()
         self._broadcast_thread = threading.Thread(
@@ -172,8 +165,6 @@ class VirtualNode:
 
     def stop(self) -> None:
         self._stop.set()
-        was_connected = self._connected
-        self._connected = False
         if self.stream is not None:
             self.stream.stop()
             self.stream = None
@@ -185,11 +176,17 @@ class VirtualNode:
             pub.unsubscribe(self._handle_unique_packet, self.PACKET_TOPIC)
         except KeyError:
             pass
+        for topic, listener in (
+            (self.RECEIVE_TOPIC, self._handle_compat_response_packet),
+            ("mesh.rx.ack", self._handle_compat_ack),
+            ("mesh.rx.nak", self._handle_compat_nak),
+        ):
+            try:
+                pub.unsubscribe(listener, topic)
+            except KeyError:
+                pass
         if self._broadcast_thread and self._broadcast_thread.is_alive():
             self._broadcast_thread.join(timeout=2.0)
-        if was_connected:
-            self._publish_log_line(f"virtual node disconnected: {self.config.node_id}")
-            pub.sendMessage("meshtastic.connection.lost", interface=self)
 
     def run_forever(self) -> None:
         self.start()
@@ -199,30 +196,57 @@ class VirtualNode:
         finally:
             self.stop()
 
-    def receive(self, callback: Callable[..., Any]) -> None:
-        pub.subscribe(callback, "meshtastic.receive")
+    def receive(self, callback) -> None:
+        pub.subscribe(callback, self.RECEIVE_TOPIC)
 
-    def unreceive(self, callback: Callable[..., Any]) -> None:
+    def unreceive(self, callback) -> None:
         try:
-            pub.unsubscribe(callback, "meshtastic.receive")
+            pub.unsubscribe(callback, self.RECEIVE_TOPIC)
         except KeyError:
             pass
 
     def close(self) -> None:
         self.stop()
 
+    def getLongName(self):
+        return self.config.long_name
+
+    def getShortName(self):
+        return self.config.short_name
+
+    def getPublicKey(self):
+        return b64_decode(self._public_key_b64) if self._public_key_b64 else None
+
+    def getMyUser(self):
+        user = mesh_pb2.User(
+            id=self.config.node_id,
+            long_name=self.config.long_name,
+            short_name=self.config.short_name,
+            hw_model=resolve_hw_model(self.config.hw_model),
+        )
+        user.role = resolve_role(self.config.role)
+        if self._public_key_b64:
+            user.public_key = b64_decode(self._public_key_b64)
+        return MessageToDict(user, preserving_proto_field_name=False, use_integers_for_enums=False)
+
+    def getMyNodeInfo(self):
+        return {
+            "num": self.node_num,
+            "user": self.getMyUser(),
+        }
+
     def sendText(
         self,
         text: str,
         destinationId: Union[int, str] = BROADCAST_ADDR,
         wantAck: bool = False,
         wantResponse: bool = False,
-        onResponse: Optional[Callable[[dict], Any]] = None,
+        onResponse=None,
         channelIndex: int = 0,
         portNum: int = portnums_pb2.PortNum.TEXT_MESSAGE_APP,
         replyId: Optional[int] = None,
         hopLimit: Optional[int] = None,
-    ) -> mesh_pb2.MeshPacket:
+    ):
         return self.sendData(
             text.encode("utf-8"),
             destinationId=destinationId,
@@ -235,51 +259,78 @@ class VirtualNode:
             replyId=replyId,
         )
 
+    def sendAlert(
+        self,
+        text: str,
+        destinationId: Union[int, str] = BROADCAST_ADDR,
+        onResponse=None,
+        channelIndex: int = 0,
+        hopLimit: Optional[int] = None,
+    ):
+        return self.sendData(
+            text.encode("utf-8"),
+            destinationId=destinationId,
+            portNum=portnums_pb2.PortNum.ALERT_APP,
+            wantAck=False,
+            wantResponse=False,
+            onResponse=onResponse,
+            channelIndex=channelIndex,
+            hopLimit=hopLimit,
+            priority=mesh_pb2.MeshPacket.Priority.ALERT,
+        )
+
     def sendData(
         self,
-        data: Any,
+        data,
         destinationId: Union[int, str] = BROADCAST_ADDR,
         portNum: int = portnums_pb2.PortNum.PRIVATE_APP,
         wantAck: bool = False,
         wantResponse: bool = False,
-        onResponse: Optional[Callable[[dict], Any]] = None,
+        onResponse=None,
         onResponseAckPermitted: bool = False,
         channelIndex: int = 0,
         hopLimit: Optional[int] = None,
-        pkiEncrypted: bool = False,
+        pkiEncrypted: Optional[bool] = False,
         publicKey: Optional[bytes] = None,
         priority: int = mesh_pb2.MeshPacket.Priority.RELIABLE,
         replyId: Optional[int] = None,
-    ) -> mesh_pb2.MeshPacket:
-        if channelIndex != 0:
-            raise ValueError("vnode currently supports only channelIndex=0")
+    ):
         if getattr(data, "SerializeToString", None):
             data = data.SerializeToString()
-        payload = bytes(data)
-        destination_num = self._resolve_destination(destinationId)
-
-        decoded = mesh_pb2.Data()
-        decoded.portnum = int(portNum)
-        decoded.payload = payload
-        decoded.source = self.node_num
-        decoded.dest = destination_num
-        decoded.want_response = bool(wantResponse)
+        if not isinstance(data, (bytes, bytearray)):
+            raise TypeError("data must be bytes or a protobuf with SerializeToString()")
+        if int(channelIndex) != 0:
+            raise NotImplementedError("Only channelIndex=0 is currently supported")
+        if publicKey is not None:
+            raise NotImplementedError("publicKey override is not currently supported")
+        if int(portNum) == portnums_pb2.PortNum.UNKNOWN_APP:
+            raise ValueError("A non-zero port number must be specified")
+
+        destination = self._resolve_destination_compat(destinationId)
+        force_pki = bool(pkiEncrypted)
+        data_message = mesh_pb2.Data()
+        data_message.portnum = int(portNum)
+        data_message.payload = bytes(data)
+        data_message.want_response = bool(wantResponse)
+        data_message.source = self.node_num
+        data_message.dest = int(destination)
         if replyId is not None:
-            decoded.reply_id = int(replyId)
+            data_message.reply_id = int(replyId)
 
-        packet = self._send_packet(
-            decoded,
-            destination=destination_num,
-            force_pki=bool(pkiEncrypted),
+        packet = self._send_data_packet(
+            data_message,
+            destination=int(destination),
+            force_pki=force_pki,
             hop_limit=hopLimit,
-            hop_start=None,
-            want_ack=bool(wantAck),
-            priority=priority,
-            remote_public_key=publicKey,
+            want_ack=wantAck,
+            priority=int(priority),
         )
         if onResponse is not None:
-            self._response_handlers[int(packet.id)] = (onResponse, bool(onResponseAckPermitted))
-        return self._packet_for_return(packet, decoded)
+            self._response_handlers[int(packet.id)] = {
+                "callback": onResponse,
+                "ack_permitted": bool(onResponseAckPermitted) or getattr(onResponse, "__name__", "") == "onAckNak",
+            }
+        return packet
 
     def sendPosition(
         self,
@@ -291,12 +342,12 @@ class VirtualNode:
         wantResponse: bool = False,
         channelIndex: int = 0,
         hopLimit: Optional[int] = None,
-    ) -> mesh_pb2.MeshPacket:
+    ):
         position = mesh_pb2.Position()
         if latitude != 0.0:
-            position.latitude_i = int(latitude / 1e-7)
+            position.latitude_i = int(latitude * 1e7)
         if longitude != 0.0:
-            position.longitude_i = int(longitude / 1e-7)
+            position.longitude_i = int(longitude * 1e7)
         if altitude != 0:
             position.altitude = int(altitude)
         return self.sendData(
@@ -309,23 +360,6 @@ class VirtualNode:
             hopLimit=hopLimit,
         )
 
-    def getMyNodeInfo(self) -> Optional[Dict[str, Any]]:
-        return self.nodesByNum.get(self.node_num)
-
-    def getMyUser(self) -> Optional[Dict[str, Any]]:
-        node_info = self.getMyNodeInfo()
-        if node_info is None:
-            return None
-        user = node_info.get("user")
-        return user if isinstance(user, dict) else None
-
-    def getLongName(self) -> Optional[str]:
-        user = self.getMyUser()
-        if user is None:
-            return None
-        value = user.get("longName")
-        return str(value) if value is not None else None
-
     def connect_send_socket(self) -> None:
         if getattr(conn, "socket", None) is None:
             conn.setup_multicast(self.config.udp.mcast_group, int(self.config.udp.mcast_port))
@@ -525,18 +559,20 @@ class VirtualNode:
         hop_limit: Optional[int] = None,
         hop_start: Optional[int] = None,
         want_ack: bool = False,
+        priority: Optional[int] = None,
     ) -> int:
-        packet = self._send_packet(
+        packet = self._send_data_packet(
             data,
             destination=destination,
             force_pki=force_pki,
             hop_limit=hop_limit,
             hop_start=hop_start,
             want_ack=want_ack,
+            priority=priority,
         )
         return packet.id
 
-    def _send_packet(
+    def _send_data_packet(
         self,
         data: mesh_pb2.Data,
         *,
@@ -546,7 +582,6 @@ class VirtualNode:
         hop_start: Optional[int] = None,
         want_ack: bool = False,
         priority: Optional[int] = None,
-        remote_public_key: Optional[bytes] = None,
     ) -> mesh_pb2.MeshPacket:
         self.connect_send_socket()
         packet = mesh_pb2.MeshPacket()
@@ -564,15 +599,14 @@ class VirtualNode:
         packet.hop_start = resolved_hop_start
 
         if force_pki:
-            key_bytes = remote_public_key if remote_public_key is not None else self._lookup_public_key(destination)
-            if key_bytes is None:
+            remote_public_key = self._lookup_public_key(destination)
+            if remote_public_key is None:
                 raise ValueError(f"Destination {destination} does not have a stored public key in meshdb")
             packet.channel = 0
             packet.pki_encrypted = True
-            packet.public_key = key_bytes
             packet.encrypted = encrypt_dm(
                 sender_private_key=b64_decode(self.config.security.private_key),
-                receiver_public_key=key_bytes,
+                receiver_public_key=remote_public_key,
                 packet_id=packet.id,
                 from_node=self.node_num,
                 plaintext=data.SerializeToString(),
@@ -591,19 +625,18 @@ class VirtualNode:
         self._persist_outbound_packet(packet, data)
         return packet
 
-    def _handle_raw_packet(self, packet: mesh_pb2.MeshPacket, **kwargs: Any) -> None:
-        del kwargs
+    def _handle_raw_packet(self, packet: mesh_pb2.MeshPacket, addr: Any = None) -> None:
+        del addr
         if not getattr(packet, "rx_time", 0):
             packet.rx_time = int(time.time())
 
         if not packet.HasField("decoded"):
             self._try_decode_pki(packet)
-        self._publish_meshtastic_receive(packet)
         self._maybe_send_ack(packet)
         self._maybe_send_response(packet)
 
-    def _handle_unique_packet(self, packet: mesh_pb2.MeshPacket, **kwargs: Any) -> None:
-        del kwargs
+    def _handle_unique_packet(self, packet: mesh_pb2.MeshPacket, addr: Any = None) -> None:
+        del addr
         if not getattr(packet, "rx_time", 0):
             packet.rx_time = int(time.time())
         if not packet.HasField("decoded"):
@@ -612,186 +645,7 @@ class VirtualNode:
             return
 
         self._persist_packet(packet)
-        self._update_node_cache_from_packet(packet)
-
-    def _packet_to_receive_dict(self, packet: mesh_pb2.MeshPacket) -> Dict[str, Any]:
-        as_dict = MessageToDict(packet)
-        as_dict["raw"] = packet
-
-        if "from" not in as_dict:
-            as_dict["from"] = 0
-        if "to" not in as_dict:
-            as_dict["to"] = 0
-
-        as_dict["fromId"] = self._node_num_to_id(int(as_dict["from"]), is_dest=False)
-        as_dict["toId"] = self._node_num_to_id(int(as_dict["to"]), is_dest=True)
-
-        if "decoded" in as_dict and packet.HasField("decoded"):
-            as_dict["decoded"]["payload"] = packet.decoded.payload
-            if packet.decoded.portnum in TEXT_PORTNUMS:
-                as_dict["decoded"]["text"] = packet.decoded.payload.decode("utf-8", "ignore")
-            elif packet.decoded.portnum == portnums_pb2.PortNum.POSITION_APP:
-                position = mesh_pb2.Position()
-                try:
-                    position.ParseFromString(packet.decoded.payload)
-                    position_dict = MessageToDict(position)
-                    position_dict["raw"] = position
-                    as_dict["decoded"]["position"] = position_dict
-                except DecodeError:
-                    pass
-            elif packet.decoded.portnum == portnums_pb2.PortNum.NODEINFO_APP:
-                user = mesh_pb2.User()
-                try:
-                    user.ParseFromString(packet.decoded.payload)
-                    user_dict = MessageToDict(user)
-                    user_dict["raw"] = user
-                    as_dict["decoded"]["user"] = user_dict
-                except DecodeError:
-                    pass
-
-        return as_dict
-
-    def _node_num_to_id(self, node_num: int, *, is_dest: bool) -> Optional[str]:
-        if node_num == BROADCAST_NUM:
-            return "^all" if is_dest else "Unknown"
-        if node_num == self.node_num:
-            return self.config.node_id
-
-        return f"!{int(node_num):08x}"
-
-    def _packet_for_return(self, packet: mesh_pb2.MeshPacket, data: mesh_pb2.Data) -> mesh_pb2.MeshPacket:
-        returned = mesh_pb2.MeshPacket()
-        returned.CopyFrom(packet)
-        returned.decoded.CopyFrom(data)
-        return returned
-
-    def _publish_meshtastic_receive(self, packet: mesh_pb2.MeshPacket) -> None:
-        if int(getattr(packet, "from", 0) or 0) == self.node_num:
-            return
-        packet_dict = self._packet_to_receive_dict(packet)
-        self._dispatch_response_handler(packet, packet_dict)
-        topic = "meshtastic.receive"
-        if packet.HasField("decoded"):
-            portnum_name = str(packet_dict.get("decoded", {}).get("portnum", "UNKNOWN_APP"))
-            topic = f"meshtastic.receive.data.{portnum_name}"
-            if packet.decoded.portnum in TEXT_PORTNUMS:
-                topic = "meshtastic.receive.text"
-            elif packet.decoded.portnum == portnums_pb2.PortNum.POSITION_APP:
-                topic = "meshtastic.receive.position"
-            elif packet.decoded.portnum == portnums_pb2.PortNum.NODEINFO_APP:
-                topic = "meshtastic.receive.user"
-        pub.sendMessage(topic, packet=packet_dict, interface=self)
-
-    def _dispatch_response_handler(self, packet: mesh_pb2.MeshPacket, packet_dict: Dict[str, Any]) -> None:
-        decoded = packet_dict.get("decoded")
-        if not isinstance(decoded, dict):
-            return
-        request_id = decoded.get("requestId")
-        if request_id is None:
-            return
-        try:
-            request_id_num = int(request_id)
-        except (TypeError, ValueError):
-            return
-        handler = self._response_handlers.get(request_id_num)
-        if handler is None:
-            return
-        callback, ack_permitted = handler
-        if is_ack(packet) and not ack_permitted and getattr(callback, "__name__", "") != "onAckNak":
-            return
-        self._response_handlers.pop(request_id_num, None)
-        callback(packet_dict)
-
-    def _upsert_local_node_cache(self) -> None:
-        node = self._default_node_dict(self.node_num)
-        node["user"].update(
-            {
-                "id": self.config.node_id,
-                "longName": self.config.long_name,
-                "shortName": self.config.short_name,
-                "hwModel": str(self.config.hw_model),
-                "role": str(self.config.role),
-                "publicKey": self._public_key_b64,
-                "isLicensed": bool(self.config.is_licensed),
-            }
-        )
-        if (
-            self.config.position.enabled
-            and self.config.position.latitude is not None
-            and self.config.position.longitude is not None
-        ):
-            node["position"] = {
-                "latitudeI": int(float(self.config.position.latitude) * 1e7),
-                "longitudeI": int(float(self.config.position.longitude) * 1e7),
-            }
-            if self.config.position.altitude is not None:
-                node["position"]["altitude"] = int(self.config.position.altitude)
-        self.nodesByNum[self.node_num] = node
-        self.nodes[self.config.node_id] = node
-
-    def _default_node_dict(self, node_num: int) -> Dict[str, Any]:
-        node_id = f"!{int(node_num):08x}"
-        return {
-            "num": int(node_num),
-            "user": {
-                "id": node_id,
-                "longName": f"Meshtastic {node_id[-4:]}",
-                "shortName": node_id[-4:],
-                "hwModel": "UNSET",
-            },
-        }
-
-    def _update_node_cache_from_packet(self, packet: mesh_pb2.MeshPacket) -> None:
-        sender = int(getattr(packet, "from", 0) or 0)
-        if sender == 0:
-            return
-        packet_dict = self._packet_to_receive_dict(packet)
-        node = dict(self.nodesByNum.get(sender, self._default_node_dict(sender)))
-        changed = sender not in self.nodesByNum
-
-        rx_time = packet_dict.get("rxTime")
-        if rx_time is not None and node.get("lastHeard") != rx_time:
-            node["lastHeard"] = rx_time
-            changed = True
-        snr = packet_dict.get("rxSnr")
-        if snr is not None and node.get("snr") != snr:
-            node["snr"] = snr
-            changed = True
-
-        decoded = packet_dict.get("decoded")
-        if isinstance(decoded, dict):
-            user = decoded.get("user")
-            if isinstance(user, dict):
-                clean_user = dict(user)
-                clean_user.pop("raw", None)
-                existing_user = node.get("user", {})
-                merged_user = dict(existing_user) if isinstance(existing_user, dict) else {}
-                merged_user.update(clean_user)
-                if merged_user != existing_user:
-                    node["user"] = merged_user
-                    changed = True
-            position = decoded.get("position")
-            if isinstance(position, dict):
-                clean_position = dict(position)
-                clean_position.pop("raw", None)
-                if clean_position != node.get("position"):
-                    node["position"] = clean_position
-                    changed = True
-
-        self.nodesByNum[sender] = node
-        user = node.get("user")
-        if isinstance(user, dict):
-            node_id = user.get("id")
-            if node_id:
-                self.nodes[str(node_id)] = node
-        if changed:
-            self._publish_node_updated(node)
-
-    def _publish_node_updated(self, node: Dict[str, Any]) -> None:
-        pub.sendMessage("meshtastic.node.updated", node=node, interface=self)
-
-    def _publish_log_line(self, line: str) -> None:
-        pub.sendMessage("meshtastic.log.line", line=str(line), interface=self)
+        self._publish_receive(packet)
 
     def _try_decode_pki(self, packet: mesh_pb2.MeshPacket) -> bool:
         if packet.channel != 0 or packet.to != self.node_num or not packet.encrypted:
@@ -933,6 +787,103 @@ class VirtualNode:
             db_path=self.meshdb_path,
         )
 
+    def _publish_receive(self, packet: mesh_pb2.MeshPacket) -> None:
+        packet_dict = self._mesh_interface_packet_dict(packet)
+
+        topic = self.RECEIVE_TOPIC
+        decoded = packet_dict.get("decoded")
+        portnum = None
+        if isinstance(decoded, dict):
+            raw_portnum = decoded.get("portnum")
+            if raw_portnum is not None:
+                portnum = raw_portnum
+
+        if portnum is not None:
+            try:
+                portnum_value = portnums_pb2.PortNum.Value(str(portnum))
+            except ValueError:
+                portnum_value = None
+            handler = protocols.get(portnum_value) if portnum_value is not None else None
+            if handler is not None:
+                topic = f"{self.RECEIVE_TOPIC}.{handler.name}"
+            else:
+                if isinstance(portnum, str):
+                    topic = f"{self.RECEIVE_TOPIC}.data.{portnum}"
+                else:
+                    topic = f"{self.RECEIVE_TOPIC}.data.{portnum}"
+
+        pub.sendMessage(topic, packet=packet_dict, interface=self)
+
+    def _mesh_interface_packet_dict(self, packet: mesh_pb2.MeshPacket) -> Dict[str, Any]:
+        packet_dict = meshdb.normalize_packet(packet, "udp")
+        packet_dict["raw"] = packet
+
+        if packet.HasField("decoded"):
+            decoded = packet_dict.setdefault("decoded", {})
+            decoded["payload"] = bytes(packet.decoded.payload)
+            try:
+                decoded["portnum"] = portnums_pb2.PortNum.Name(int(packet.decoded.portnum))
+            except ValueError:
+                decoded["portnum"] = int(packet.decoded.portnum)
+            if getattr(packet.decoded, "want_response", False):
+                decoded["wantResponse"] = True
+            if getattr(packet.decoded, "request_id", 0):
+                decoded["requestId"] = int(packet.decoded.request_id)
+            if getattr(packet.decoded, "reply_id", 0):
+                decoded["replyId"] = int(packet.decoded.reply_id)
+            if getattr(packet.decoded, "emoji", 0):
+                decoded["emoji"] = int(packet.decoded.emoji)
+
+            handler = protocols.get(int(packet.decoded.portnum))
+            if handler is not None and getattr(handler, "protobufFactory", None) is not None:
+                try:
+                    pb = handler.protobufFactory()
+                    pb.ParseFromString(bytes(packet.decoded.payload))
+                    decoded[handler.name] = MessageToDict(
+                        pb,
+                        preserving_proto_field_name=False,
+                        use_integers_for_enums=False,
+                    )
+                except Exception:
+                    pass
+        return packet_dict
+
+    def _resolve_destination_compat(self, destination: Union[int, str]) -> int:
+        if destination == BROADCAST_ADDR:
+            return BROADCAST_NUM
+        if destination == LOCAL_ADDR:
+            return self.node_num
+        return self._resolve_destination(destination)
+
+    def _handle_compat_response_packet(self, packet, interface=None) -> None:
+        if interface is not self:
+            return
+        raw_packet = packet.get("raw") if isinstance(packet, dict) else None
+        if not isinstance(raw_packet, mesh_pb2.MeshPacket) or not raw_packet.HasField("decoded"):
+            return
+        request_id = int(getattr(raw_packet.decoded, "request_id", 0))
+        if request_id <= 0 or is_ack(raw_packet) or is_nak(raw_packet):
+            return
+        handler = self._response_handlers.pop(request_id, None)
+        if handler is not None:
+            handler["callback"](packet)
+
+    def _handle_compat_ack(self, packet, routing=None, addr=None, pending=None) -> None:
+        del routing, addr, pending
+        request_id = int(getattr(packet.decoded, "request_id", 0)) if packet.HasField("decoded") else 0
+        handler = self._response_handlers.get(request_id)
+        if handler is None or not handler["ack_permitted"]:
+            return
+        self._response_handlers.pop(request_id, None)
+        handler["callback"](self._mesh_interface_packet_dict(packet))
+
+    def _handle_compat_nak(self, packet, routing=None, addr=None, pending=None) -> None:
+        del routing, addr, pending
+        request_id = int(getattr(packet.decoded, "request_id", 0)) if packet.HasField("decoded") else 0
+        handler = self._response_handlers.pop(request_id, None)
+        if handler is not None:
+            handler["callback"](self._mesh_interface_packet_dict(packet))
+
     def _broadcast_loop(self) -> None:
         nodeinfo_interval = int(self.config.broadcasts.nodeinfo_interval_seconds)
         position_interval = int(self.config.position.position_interval_seconds)
@@ -966,8 +917,6 @@ class VirtualNode:
         if isinstance(destination, int):
             return destination
         text = str(destination).strip()
-        if text == BROADCAST_ADDR:
-            return BROADCAST_NUM
         if text.startswith("!"):
             return parse_node_id(text)
         resolved = meshdb.get_node_num(text, owner_node_num=self.node_num, db_path=self.meshdb_path)