meshcore 2.2.5__tar.gz → 2.2.6__tar.gz

{meshcore-2.2.5 → meshcore-2.2.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcore
-Version: 2.2.5
+Version: 2.2.6
 Summary: Base classes for communicating with meshcore companion radios
 Project-URL: Homepage, https://github.com/fdlamotte/meshcore_py
 Project-URL: Issues, https://github.com/fdlamotte/meshcore_py/issues
@@ -541,6 +541,13 @@ All commands are async methods that return `Event` objects. Commands are organiz
 | `reboot()` | None | None | Reboot device (no response expected) |
 | **Security** ||||
 | `export_private_key()` | None | `PRIVATE_KEY/DISABLED` | Export device private key (requires PIN auth & enabled firmware) |
+| `import_private_key(key)` | `key: bytes` | `OK` | Import private key to device |
+| **Statistics** ||||
+| `get_stats_core()` | None | `STATS_CORE` | Get core statistics (voltage, uptime, errors, queue length) |
+| `get_stats_radio()` | None | `STATS_RADIO` | Get radio statistics (noise floor, last RSSI/SNR, tx/rx time stats) |
+| `get_stats_packets()` | None | `STATS_PACKETS` | Get packet statistics (rx/tx totals, flood vs. direct, recv_errors when present) |
+| **Advanced Configuration** ||||
+| `set_multi_acks(multi_acks)` | `multi_acks: int` | `OK` | Set multi-acks mode (experimental ack repeats) |
 
 #### Contact Commands (`meshcore.commands.*`)
 
@@ -568,7 +575,7 @@ All commands are async methods that return `Event` objects. Commands are organiz
 | `get_msg(timeout=None)` | `timeout: float` | `CONTACT_MSG_RECV/CHANNEL_MSG_RECV/NO_MORE_MSGS` | Get next pending message |
 | `send_msg(dst, msg, timestamp=None)` | `dst: contact/str/bytes, msg: str, timestamp: int` | `MSG_SENT` | Send direct message |
 | `send_cmd(dst, cmd, timestamp=None)` | `dst: contact/str/bytes, cmd: str, timestamp: int` | `MSG_SENT` | Send command message |
-| `send_chan_msg(chan, msg, timestamp=None)` | `chan: int, msg: str, timestamp: int` | `MSG_SENT` | Send channel message |
+| `send_chan_msg(chan, msg, timestamp=None)` | `chan: int, msg: str, timestamp: int` | `MSG_OK` | Send channel message |
 | **Authentication** ||||
 | `send_login(dst, pwd)` | `dst: contact/str/bytes, pwd: str` | `MSG_SENT` | Send login request |
 | `send_logout(dst)` | `dst: contact/str/bytes` | `MSG_SENT` | Send logout request |
@@ -579,6 +586,9 @@ All commands are async methods that return `Event` objects. Commands are organiz
 | `send_binary_req(dst, bin_data)` | `dst: contact/str/bytes, bin_data: bytes` | `MSG_SENT` | Send binary data request |
 | `send_path_discovery(dst)` | `dst: contact/str/bytes` | `MSG_SENT` | Initiate path discovery |
 | `send_trace(auth_code, tag, flags, path=None)` | `auth_code: int, tag: int, flags: int, path: list` | `MSG_SENT` | Send route trace packet |
+| **Message Retry & Scope** ||||
+| `send_msg_with_retry(dst, msg, ...)` | `dst, msg, timestamp, max_attempts, max_flood_attempts, flood_after, timeout, min_timeout` | `MSG_SENT/None` | Send message with automatic retry and ACK waiting |
+| `set_flood_scope(scope)` | `scope: str` | `OK` | Set flood scope (hash like "#name", "0"/""/"*" to disable, or raw key) |
 
 #### Binary Protocol Commands (`meshcore.commands.*`)
 
@@ -639,6 +649,7 @@ Check the `examples/` directory for more:
 - `serial_infos.py`: Quick device info retrieval
 - `serial_msg.py`: Message sending and receiving
 - `serial_pingbot.py`: Ping bot which can be run on a channel
+- `serial_rss_bot.py`: A RSS feed to Meshcore channel example, which broadcasts emergency bushfire warnings in VIC, AU
 - `serial_meshcore_ollama.py`: Simple Ollama to Meshcore gateway, a simple chat box 
 - `ble_pin_pairing_example.py`: BLE connection with PIN pairing
 - `ble_private_key_export.py`: BLE private key export with PIN authentication

{meshcore-2.2.5 → meshcore-2.2.6}/README.md

@@ -519,6 +519,13 @@ All commands are async methods that return `Event` objects. Commands are organiz
 | `reboot()` | None | None | Reboot device (no response expected) |
 | **Security** ||||
 | `export_private_key()` | None | `PRIVATE_KEY/DISABLED` | Export device private key (requires PIN auth & enabled firmware) |
+| `import_private_key(key)` | `key: bytes` | `OK` | Import private key to device |
+| **Statistics** ||||
+| `get_stats_core()` | None | `STATS_CORE` | Get core statistics (voltage, uptime, errors, queue length) |
+| `get_stats_radio()` | None | `STATS_RADIO` | Get radio statistics (noise floor, last RSSI/SNR, tx/rx time stats) |
+| `get_stats_packets()` | None | `STATS_PACKETS` | Get packet statistics (rx/tx totals, flood vs. direct, recv_errors when present) |
+| **Advanced Configuration** ||||
+| `set_multi_acks(multi_acks)` | `multi_acks: int` | `OK` | Set multi-acks mode (experimental ack repeats) |
 
 #### Contact Commands (`meshcore.commands.*`)
 
@@ -546,7 +553,7 @@ All commands are async methods that return `Event` objects. Commands are organiz
 | `get_msg(timeout=None)` | `timeout: float` | `CONTACT_MSG_RECV/CHANNEL_MSG_RECV/NO_MORE_MSGS` | Get next pending message |
 | `send_msg(dst, msg, timestamp=None)` | `dst: contact/str/bytes, msg: str, timestamp: int` | `MSG_SENT` | Send direct message |
 | `send_cmd(dst, cmd, timestamp=None)` | `dst: contact/str/bytes, cmd: str, timestamp: int` | `MSG_SENT` | Send command message |
-| `send_chan_msg(chan, msg, timestamp=None)` | `chan: int, msg: str, timestamp: int` | `MSG_SENT` | Send channel message |
+| `send_chan_msg(chan, msg, timestamp=None)` | `chan: int, msg: str, timestamp: int` | `MSG_OK` | Send channel message |
 | **Authentication** ||||
 | `send_login(dst, pwd)` | `dst: contact/str/bytes, pwd: str` | `MSG_SENT` | Send login request |
 | `send_logout(dst)` | `dst: contact/str/bytes` | `MSG_SENT` | Send logout request |
@@ -557,6 +564,9 @@ All commands are async methods that return `Event` objects. Commands are organiz
 | `send_binary_req(dst, bin_data)` | `dst: contact/str/bytes, bin_data: bytes` | `MSG_SENT` | Send binary data request |
 | `send_path_discovery(dst)` | `dst: contact/str/bytes` | `MSG_SENT` | Initiate path discovery |
 | `send_trace(auth_code, tag, flags, path=None)` | `auth_code: int, tag: int, flags: int, path: list` | `MSG_SENT` | Send route trace packet |
+| **Message Retry & Scope** ||||
+| `send_msg_with_retry(dst, msg, ...)` | `dst, msg, timestamp, max_attempts, max_flood_attempts, flood_after, timeout, min_timeout` | `MSG_SENT/None` | Send message with automatic retry and ACK waiting |
+| `set_flood_scope(scope)` | `scope: str` | `OK` | Set flood scope (hash like "#name", "0"/""/"*" to disable, or raw key) |
 
 #### Binary Protocol Commands (`meshcore.commands.*`)
 
@@ -617,6 +627,7 @@ Check the `examples/` directory for more:
 - `serial_infos.py`: Quick device info retrieval
 - `serial_msg.py`: Message sending and receiving
 - `serial_pingbot.py`: Ping bot which can be run on a channel
+- `serial_rss_bot.py`: A RSS feed to Meshcore channel example, which broadcasts emergency bushfire warnings in VIC, AU
 - `serial_meshcore_ollama.py`: Simple Ollama to Meshcore gateway, a simple chat box 
 - `ble_pin_pairing_example.py`: BLE connection with PIN pairing
 - `ble_private_key_export.py`: BLE private key export with PIN authentication

{meshcore-2.2.5 → meshcore-2.2.6}/examples/ble_stats.py

@@ -53,6 +53,11 @@ async def main():
         else:
             print("📦 Packet Statistics:")
             print(json.dumps(result.payload, indent=2))
+            recv_errors = result.payload.get("recv_errors")
+            if recv_errors is not None:
+                print(f"  Receive/CRC errors (RadioLib): {recv_errors}")
+            else:
+                print("  Receive/CRC errors (RadioLib): not reported (legacy 26-byte frame)")
         print()
 
     except Exception as e:

meshcore-2.2.6/examples/serial_rss_bot.py

@@ -0,0 +1,284 @@
+import asyncio
+import logging
+import re
+import urllib.request
+import xml.etree.ElementTree as ET
+from html import unescape
+from html.parser import HTMLParser
+import hashlib
+
+
+from meshcore import MeshCore, EventType
+
+# =====================
+# Config
+# =====================
+SERIAL_PORT = "COM4"          # change this to your serial port
+CHANNEL_IDXS = [6]#[5, 6]         # change this to the index of your target channel
+
+RSS_URL = "https://data.emergency.vic.gov.au/Show?pageId=getIncidentRSS"
+POLL_INTERVAL_SEC = 300       # poll interval (seconds)
+
+# Only send items whose description (plain text) contains this keyword (case-insensitive)
+KEYWORDS_REQUIRED = ["BUSHFIRE"]
+
+# Only send these fields from the RSS description
+FIELDS_TO_SEND = [
+    "Type",
+    "Fire District",
+    "Location",     
+    "Latitude",
+    "Longitude",    
+    "Status",
+    "Size",
+]
+
+BLOCKED_STATUSES = [
+    "Under Control",
+    "Safe",
+]
+
+logging.basicConfig(level=logging.INFO)
+_LOGGER = logging.getLogger("serial_rssbot")
+
+
+class _HTMLTextExtractor(HTMLParser):
+    def __init__(self):
+        super().__init__()
+        self._chunks: list[str] = []
+
+    def handle_data(self, data: str) -> None:
+        if data:
+            self._chunks.append(data)
+
+    def get_text(self) -> str:
+        return "".join(self._chunks)
+
+
+def _strip_html(html: str) -> str:
+    """Convert HTML-ish fragments into plain text."""
+    if not html:
+        return ""
+
+    # Normalize <br> into newlines so field parsing is reliable.
+    html = re.sub(r"<\s*br\s*/?\s*>", "\n", html, flags=re.IGNORECASE)
+
+    parser = _HTMLTextExtractor()
+    try:
+        parser.feed(html)
+        parser.close()
+        text = parser.get_text()
+    except Exception:
+        text = re.sub(r"<[^>]+>", "\n", html)
+
+    text = unescape(text)
+    # Normalize whitespace but keep newlines as separators.
+    text = text.replace("\r", "\n")
+    text = re.sub(r"[ \t\f\v]+", " ", text)
+    text = re.sub(r"\n+", "\n", text)
+    return text.strip()
+
+
+def _fetch_rss_bytes(url: str) -> bytes:
+    req = urllib.request.Request(
+        url,
+        headers={
+            "User-Agent": "meshcore-rss-bot/1.0",
+            "Accept": "application/rss+xml, application/xml;q=0.9, */*;q=0.8",
+        },
+        method="GET",
+    )
+    with urllib.request.urlopen(req, timeout=30) as resp:
+        return resp.read()
+
+def extract_fields(raw_html: str) -> dict[str, str]:
+    """
+    Extract desired fields from the HTML description.
+    We strip HTML to text with newlines, then parse lines like "Field: value".
+    """
+    text = _strip_html(raw_html)
+    lines = [ln.strip() for ln in text.split("\n") if ln.strip()]
+
+    result: dict[str, str] = {}
+    for ln in lines:
+        m = re.match(r"^([^:]+):\s*(.*)$", ln)
+        if not m:
+            continue
+        key = m.group(1).strip()
+        val = m.group(2).strip()
+
+        # Match desired fields case-insensitively
+        for wanted in FIELDS_TO_SEND:
+            if key.lower() == wanted.lower():
+                result[wanted] = val
+                break
+
+    return result
+
+def _parse_rss_items(xml_bytes: bytes) -> list[dict[str, str]]:
+    """Return list of items with keys: id, description, raw_description."""
+    items: list[dict[str, str]] = []
+
+    root = ET.fromstring(xml_bytes)
+
+    # RSS 2.0: <rss><channel><item>...
+    channel = root.find("channel") if root.tag.lower().endswith("rss") else root
+    if channel is None:
+        return items
+
+    for it in channel.findall("item"):
+        title = (it.findtext("title") or "").strip()
+        link = (it.findtext("link") or "").strip()
+        guid = (it.findtext("guid") or "").strip()
+        pub_date = (it.findtext("pubDate") or "").strip()
+
+        desc_html = it.findtext("description") or ""
+        desc_text = _strip_html(desc_html)
+
+        # stable_id = (guid or link or f"{title}|{pub_date}" or desc_text).strip()
+
+        base_id = (guid or link or f"{title}|{pub_date}").strip()
+
+        # fingerprint only the fields you output
+        fields = extract_fields(desc_html)
+        parts = []
+        for k in FIELDS_TO_SEND:
+            v = fields.get(k, "")
+            parts.append(f"{k}={v}")
+        fingerprint = hashlib.sha1("|".join(parts).encode("utf-8")).hexdigest()[:12]
+
+        stable_id = f"{base_id}|{fingerprint}"
+
+
+        items.append(
+            {
+                "id": stable_id,
+                "description": desc_text,        # plain text for keyword filtering
+                "raw_description": desc_html,    # original HTML-ish description
+            }
+        )
+
+    return items
+
+
+
+
+
+def build_filtered_message(item: dict[str, str]) -> str | None:
+    # Keyword filter (case-insensitive) on plain text description
+    desc_text_lower = (item.get("description") or "").lower()
+    if not any(k.lower() in desc_text_lower for k in KEYWORDS_REQUIRED):
+        return None
+
+    fields = extract_fields(item.get("raw_description") or "")
+    if not fields:
+        return None
+    
+    status_norm = fields.get("Status", "").strip().lower()
+    blocked_norm = [b.lower() for b in BLOCKED_STATUSES]
+
+    if status_norm in blocked_norm:
+        return None
+
+
+    # if any(b.lower() in status for b in BLOCKED_STATUSES):
+    #     return None    
+
+    # Keep order exactly as FIELDS_TO_SEND, skip missing
+    # parts = []
+    # for k in FIELDS_TO_SEND:
+    #     v = fields.get(k)
+    #     if v:
+    #         parts.append(f"{v}")
+
+    parts = []
+
+    lat = fields.get("Latitude")
+    lon = fields.get("Longitude")
+
+    for k in FIELDS_TO_SEND:
+        if k in ("Latitude", "Longitude"):
+            continue
+
+        v = fields.get(k)
+        if v:
+            parts.append(v)
+
+    # append formatted lat,lon at the end
+    if lat and lon:
+        parts.append(f"{lat},{lon}")
+
+
+    if not parts:
+        return None
+
+    return " | ".join(parts)
+
+
+async def _fetch_items_async() -> list[dict[str, str]]:
+    xml_bytes = await asyncio.to_thread(_fetch_rss_bytes, RSS_URL)
+    return _parse_rss_items(xml_bytes)
+
+
+async def main() -> None:
+    meshcore = await MeshCore.create_serial(SERIAL_PORT, debug=True)
+    print(f"Connected on {SERIAL_PORT}")
+
+    # await meshcore.start_auto_message_fetching()
+
+    seen_ids: set[str] = set()
+
+    # Prime seen set so we do not spam old items on startup
+    try:
+        initial_items = await _fetch_items_async()
+        for it in initial_items:
+            if it.get("id"):
+                seen_ids.add(it["id"])
+        _LOGGER.info("Primed %d existing RSS items as seen.", len(seen_ids))
+    except Exception as ex:
+        _LOGGER.warning("Failed to prime RSS items: %s", ex)
+
+    try:
+        while True:
+            try:
+                items = await _fetch_items_async()
+
+                # Feeds are usually newest-first. Send unseen in chronological order.
+                new_items = [it for it in items if it.get("id") and it["id"] not in seen_ids]
+                for it in reversed(new_items):
+                    msg_text = build_filtered_message(it)
+
+                    # Mark as seen even if it does not match filter, so we do not re-check forever
+                    seen_ids.add(it["id"])
+
+                    if not msg_text:
+                        continue
+
+                    # _LOGGER.info("Sending filtered RSS item to channel %s", CHANNEL_IDX)
+                    # result = await meshcore.commands.send_chan_msg(CHANNEL_IDX, msg_text)
+                    # if result.type == EventType.ERROR:
+                    #     _LOGGER.error("Error sending RSS message: %s", result.payload)
+                    for ch in CHANNEL_IDXS:
+                        _LOGGER.info("Sending filtered RSS item to channel %s", ch)
+                        result = await meshcore.commands.send_chan_msg(ch, msg_text)
+                        if result.type == EventType.ERROR:
+                            _LOGGER.error("Error sending RSS message to channel %s: %s", ch, result.payload)
+                        await asyncio.sleep(5)  # seconds    
+                    await asyncio.sleep(5)     
+
+
+            except Exception as ex:
+                _LOGGER.warning("RSS poll failed: %s", ex)
+
+            await asyncio.sleep(POLL_INTERVAL_SEC)
+
+    except KeyboardInterrupt:
+        print("Stopping...")
+    finally:
+        await meshcore.stop_auto_message_fetching()
+        await meshcore.disconnect()
+        print("Disconnected")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

{meshcore-2.2.5 → meshcore-2.2.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "meshcore"
-version = "2.2.5"
+version = "2.2.6"
 authors = [
   { name="Florent de Lamotte", email="florent@frizoncorrea.fr" },
   { name="Alex Wolden", email="awolden@gmail.com" },

{meshcore-2.2.5 → meshcore-2.2.6}/src/meshcore/commands/base.py

@@ -3,7 +3,7 @@ import logging
 import random
 from typing import Any, Callable, Coroutine, Dict, List, Optional, Union
 
-from meshcore.packets import BinaryReqType
+from meshcore.packets import BinaryReqType, AnonReqType
 
 from ..events import Event, EventDispatcher, EventType
 from ..reader import MessageReader
@@ -187,3 +187,24 @@ class CommandHandlerBase:
             self._reader.register_binary_request(pubkey_prefix.hex(), exp_tag, request_type, actual_timeout, context=context)
 
         return result
+
+    async def send_anon_req(self, dst: DestinationType, request_type: AnonReqType, data: Optional[bytes] = None, context={}, timeout=None, min_timeout=0) -> Event:
+        dst_bytes = _validate_destination(dst, prefix_length=32)
+        pubkey_prefix = _validate_destination(dst, prefix_length=6)
+        logger.debug(f"Anon Binary request to {dst_bytes.hex()}")
+        data = b"\x39" + dst_bytes + request_type.value.to_bytes(1, "little", signed=False) + (data if data else b"")
+
+        result = await self.send(data, [EventType.MSG_SENT, EventType.ERROR])
+        
+        # Register the request with the reader if we have both reader and request_type
+        if (result.type == EventType.MSG_SENT and 
+            self._reader is not None and 
+            request_type is not None):
+            
+            exp_tag = result.payload["expected_ack"].hex()
+            # Use provided timeout or fallback to suggested timeout (with 5s default)
+            actual_timeout = timeout if timeout is not None and timeout > 0 else result.payload.get("suggested_timeout", 4000) / 800.0
+            actual_timeout = min_timeout if actual_timeout < min_timeout else actual_timeout
+            self._reader.register_binary_request(pubkey_prefix.hex(), exp_tag, request_type, actual_timeout, context=context)
+
+        return result

{meshcore-2.2.5 → meshcore-2.2.6}/src/meshcore/commands/binary.py

@@ -1,10 +1,12 @@
 import asyncio
 import logging
 import random
+import io
 
 from .base import CommandHandlerBase
 from ..events import EventType
 from ..packets import BinaryReqType
+from ..packets import AnonReqType
 
 logger = logging.getLogger("meshcore")
 
@@ -242,3 +244,109 @@ class BinaryCommandHandler(CommandHandlerBase):
             res["neighbours"] += next_res["neighbours"]
 
         return res
+
+    async def req_regions_async(self, contact, timeout=0, min_timeout=0):
+        req = b"\0" # The return path, I currently do nothing with, so direct only
+        return await self.send_anon_req(
+            contact,
+            AnonReqType.REGIONS,
+            data=req,
+            timeout=timeout
+        )
+        
+    async def req_regions_sync(self, contact, timeout=0, min_timeout=0):
+        res = await self.req_regions_async(contact, timeout, min_timeout)
+
+        if res.type == EventType.ERROR:
+            return None
+
+        timeout = res.payload["suggested_timeout"] / 800 if timeout == 0 else timeout
+        timeout = timeout if timeout > min_timeout else min_timeout
+        
+        if self.dispatcher is None:
+            return None
+            
+        region_event = await self.dispatcher.wait_for_event(
+            EventType.BINARY_RESPONSE,
+            attribute_filters={"tag": res.payload["expected_ack"].hex()},
+            timeout=timeout,
+        )
+        
+        if region_event is None:
+            return None
+
+        pkt = bytes().fromhex(region_event.payload["data"])
+        pbuf = io.BytesIO(pkt)
+        tag_again = pbuf.read(4)
+        return pbuf.read().decode("utf-8", "ignore").strip("\x00")
+
+    async def req_owner_async(self, contact, timeout=0, min_timeout=0):
+        req = b"\0"
+        return await self.send_anon_req(
+            contact,
+            AnonReqType.OWNER,
+            data=req,
+            timeout=timeout
+        )
+
+    async def req_owner_sync(self, contact, timeout=0, min_timeout=0):
+
+        res = await self.req_owner_async(contact, timeout, min_timeout)
+
+        if res.type == EventType.ERROR:
+            return None
+
+        timeout = res.payload["suggested_timeout"] / 800 if timeout == 0 else timeout
+        timeout = timeout if timeout > min_timeout else min_timeout
+        
+        if self.dispatcher is None:
+            return None
+            
+        owner_event = await self.dispatcher.wait_for_event(
+            EventType.BINARY_RESPONSE,
+            attribute_filters={"tag": res.payload["expected_ack"].hex()},
+            timeout=timeout,
+        )
+        
+        if owner_event is None:
+            return None
+
+        pkt = bytes().fromhex(owner_event.payload["data"])
+        pbuf = io.BytesIO(pkt)
+        tag_again = pbuf.read(4)
+        strings = pbuf.read().decode("utf-8", "ignore").split("\n", 1)
+
+        return dict(name=strings[0], owner=strings[1].strip("\x00"))
+
+    async def req_basic_async(self, contact, timeout=0, min_timeout=0):
+        req = b"\0"
+        return await self.send_anon_req(
+            contact,
+            AnonReqType.BASIC,
+            data=req,
+            timeout=timeout
+        )
+
+    async def req_basic_sync(self, contact, timeout=0, min_timeout=0):
+
+        res = await self.req_basic_async(contact, timeout, min_timeout)
+
+        if res.type == EventType.ERROR:
+            return None
+
+        timeout = res.payload["suggested_timeout"] / 800 if timeout == 0 else timeout
+        timeout = timeout if timeout > min_timeout else min_timeout
+        
+        if self.dispatcher is None:
+            return None
+            
+        basic_event = await self.dispatcher.wait_for_event(
+            EventType.BINARY_RESPONSE,
+            attribute_filters={"tag": res.payload["expected_ack"].hex()},
+            timeout=timeout,
+        )
+        
+        if basic_event is None:
+            return None
+
+        return basic_event.payload

{meshcore-2.2.5 → meshcore-2.2.6}/src/meshcore/commands/contact.py

@@ -143,3 +143,12 @@ class ContactCommands(CommandHandlerBase):
 
     async def change_contact_flags(self, contact, flags) -> Event:
         return await self.update_contact(contact, flags=flags)
+
+    async def set_autoadd_config(self, flag : int) -> Event:
+        data = b"\x3A" + flag.to_bytes(1, "little", signed=False)
+        return await self.send(data, [EventType.OK, EventType.ERROR])
+
+    async def get_autoadd_config(self) -> Event:
+        data = b"\x3B"
+        return await self.send(data, [EventType.AUTOADD_CONFIG, EventType.ERROR])
+        

meshcore-2.2.6/src/meshcore/commands/control_data.py

@@ -0,0 +1,96 @@
+import logging
+import random
+
+from .base import CommandHandlerBase
+from ..events import EventType, Event
+from ..packets import ControlType, PacketType
+
+logger = logging.getLogger("meshcore")
+
+# Command codes
+CMD_REQUEST_ADVERT = 57  # 0x39
+
+class ControlDataCommandHandler(CommandHandlerBase):
+    """Helper functions to handle binary requests through binary commands"""
+
+    async def send_control_data (self, control_type: int, payload: bytes) -> Event:
+        data = bytearray([PacketType.SEND_CONTROL_DATA.value]) 
+        data.extend(control_type.to_bytes(1, "little", signed = False)) 
+        data.extend(payload)
+
+        result = await self.send(data, [EventType.OK, EventType.ERROR])
+        return result
+
+    async def send_node_discover_req (
+        self,
+        filter: int,
+        prefix_only: bool=True,
+        tag: int=None,
+        since: int=None
+    ) -> Event:
+
+        if tag is None:
+            tag = random.randint(1, 0xFFFFFFFF)
+
+        data = bytearray()
+        data.extend(filter.to_bytes(1, "little", signed=False))
+        data.extend(tag.to_bytes(4, "little"))
+        if not since is None:
+            data.extend(since.to_bytes(4, "little", signed=False))
+
+        logger.debug(f"sending node discover req {data.hex()}")
+
+        flags = 0
+        flags = flags | 1 if prefix_only else flags
+
+        res = await self.send_control_data(
+            ControlType.NODE_DISCOVER_REQ.value|flags, data)
+
+        if res is None:
+            return None
+        else:
+            res.payload["tag"] = tag
+            return res
+
+    async def request_advert(self, prefix: bytes, path: bytes) -> Event:
+        """
+        Request advertisement from a node via pull-based system.
+
+        Args:
+            prefix: First byte of target node's public key (PATH_HASH_SIZE = 1)
+            path: Path to reach the node (1-64 bytes)
+
+        Returns:
+            Event with type OK on success, ERROR on failure.
+            The actual response arrives asynchronously as ADVERT_RESPONSE event.
+
+        Raises:
+            ValueError: If prefix is not 1 byte or path is empty/too long
+
+        Example:
+            # Get repeater from contacts
+            contacts = (await mc.commands.get_contacts()).payload
+            repeater = next(c for c in contacts.values() if c['adv_type'] == 2)
+
+            # Extract prefix and path
+            prefix = bytes.fromhex(repeater['public_key'])[:1]
+            path = bytes(repeater.get('out_path', [])) or prefix
+
+            # Send request
+            result = await mc.commands.request_advert(prefix, path)
+            if result.type == EventType.ERROR:
+                print(f"Failed: {result.payload}")
+                return
+
+            # Wait for response
+            response = await mc.wait_for_event(EventType.ADVERT_RESPONSE, timeout=30)
+            if response:
+                print(f"Node: {response.payload['node_name']}")
+        """
+        if len(prefix) != 1:
+            raise ValueError("Prefix must be exactly 1 byte (PATH_HASH_SIZE)")
+        if not path or len(path) > 64:
+            raise ValueError("Path must be 1-64 bytes")
+
+        cmd = bytes([CMD_REQUEST_ADVERT]) + prefix + bytes([len(path)]) + path
+        return await self.send(cmd, [EventType.OK, EventType.ERROR])

{meshcore-2.2.5 → meshcore-2.2.6}/src/meshcore/commands/messaging.py

@@ -141,17 +141,27 @@ class MessagingCommands(CommandHandlerBase):
     
         return None if res is None else result
 
-    async def send_chan_msg(self, chan, msg, timestamp=None) -> Event:
+    async def send_chan_msg(self, chan: int, msg: str, timestamp: Optional[int|bytes] = None) -> Event:
         logger.debug(f"Sending channel message to channel {chan}: {msg}")
 
-        # Default to current time if timestamp not provided
         if timestamp is None:
+            # Default to current time if timestamp not provided
             import time
-
-            timestamp = int(time.time()).to_bytes(4, "little")
+            timestamp_bytes = int(time.time()).to_bytes(4, "little")
+        elif isinstance(timestamp, int):
+            timestamp_bytes = timestamp.to_bytes(4, "little")
+        elif isinstance(timestamp, bytes) and len(timestamp) == 4:
+            # expected bytes format
+            timestamp_bytes = timestamp
+        else:
+            if isinstance(timestamp, bytes):
+                logger.error(f"Invalid timestamp format: got bytes of length {len(timestamp)} but expected bytes of length 4")
+            else:
+                logger.error(f"Invalid timestamp format: got {type(timestamp)} but expected int or 4 bytes")
+            return Event(EventType.ERROR, {"reason": "invalid_timestamp_format"})
 
         data = (
-            b"\x03\x00" + chan.to_bytes(1, "little") + timestamp + msg.encode("utf-8")
+            b"\x03\x00" + chan.to_bytes(1, "little") + timestamp_bytes + msg.encode("utf-8")
         )
         return await self.send(data, [EventType.OK, EventType.ERROR])
 
@@ -225,13 +235,20 @@ class MessagingCommands(CommandHandlerBase):
         return await self.send(cmd_data, [EventType.MSG_SENT, EventType.ERROR])
 
     async def set_flood_scope(self, scope):
-        if scope.startswith("#"): # an hash
-            logger.debug(f"Setting scope from hash {scope}")
-            scope_key = sha256(scope.encode("utf-8")).digest()[0:16]
-        elif scope == "0" or scope == "None" or scope == "*" or scope == "": # disable
+
+        if scope is None:
+            logger.debug(f"Resetting scope")
             scope_key = b"\0"*16
-        else: # assume the key has been sent directly
-            scope_key = scope.encode("utf-8")
+        elif isinstance (scope, str):
+            if scope == "0" or scope == "None" or scope == "*" or scope == "": # disable
+                logger.debug(f"Resetting scope")
+                scope_key = b"\0"*16
+            else:
+                logger.debug(f"Setting scope from string {scope}")
+                scope_key = sha256(scope.encode("utf-8")).digest()[0:16]
+        elif isinstance (scope, bytes): # scope has been sent directly as byte
+                logger.debug(f"Directly setting scope to {scope}")
+                scope_key = scope
 
         logger.debug(f"Setting scope to {scope_key.hex()}")
 

{meshcore-2.2.5 → meshcore-2.2.6}/src/meshcore/events.py

@@ -22,6 +22,7 @@ class EventType(Enum):
     MSG_SENT = "message_sent"
     NEW_CONTACT = "new_contact"
     NEXT_CONTACT = "next_contact"
+    AUTOADD_CONFIG = "autoadd_config"
 
     # Push notifications
     ADVERTISEMENT = "advertisement"
@@ -52,6 +53,7 @@ class EventType(Enum):
     NEIGHBOURS_RESPONSE = "neighbours_response"
     SIGN_START = "sign_start"
     SIGNATURE = "signature"
+    ADVERT_RESPONSE = "advert_response"
 
     # Command response types
     OK = "command_ok"

{meshcore-2.2.5 → meshcore-2.2.6}/src/meshcore/packets.py

@@ -1,5 +1,10 @@
 from enum import Enum
 
+class AnonReqType(Enum):
+    REGIONS = 0x01
+    OWNER = 0x02
+    BASIC = 0x03 # just remote clock
+
 class BinaryReqType(Enum):
     STATUS = 0x01
     KEEP_ALIVE = 0x02
@@ -37,6 +42,7 @@ class PacketType(Enum):
     SIGNATURE = 20
     CUSTOM_VARS = 21
     STATS = 24
+    AUTOADD_CONFIG = 25
     BINARY_REQ = 50
     FACTORY_RESET = 51
     PATH_DISCOVERY = 52
@@ -59,3 +65,4 @@ class PacketType(Enum):
     BINARY_RESPONSE = 0x8C
     PATH_DISCOVERY_RESPONSE = 0x8D
     CONTROL_DATA = 0x8E
+    ADVERT_RESPONSE = 0x8F

{meshcore-2.2.5 → meshcore-2.2.6}/src/meshcore/reader.py

@@ -346,10 +346,11 @@ class MessageReader:
                         await self.dispatcher.dispatch(Event(EventType.ERROR, {"reason": f"binary_parse_error: {e}"}))
             
             elif stats_type == 2:  # STATS_TYPE_PACKETS
-                # RESP_CODE_STATS + STATS_TYPE_PACKETS: 26 bytes total
-                # Format: <B B I I I I I I (response_code, stats_type, recv, sent, flood_tx, direct_tx, flood_rx, direct_rx)
+                # RESP_CODE_STATS + STATS_TYPE_PACKETS: 26 bytes (legacy) or 30 bytes (includes recv_errors)
+                # Format: <B B I I I I I I [I] (response_code, stats_type, recv, sent, flood_tx, direct_tx, flood_rx, direct_rx [, recv_errors])
+                logger.debug(f"stats packets payload len={len(data)} (expected 26 or 30)")
                 if len(data) < 26:
-                    logger.error(f"Stats packets response too short: {len(data)} bytes, expected 26")
+                    logger.error(f"Stats packets response too short: {len(data)} bytes, expected 26 or 30")
                     await self.dispatcher.dispatch(Event(EventType.ERROR, {"reason": "invalid_frame_length"}))
                 else:
                     try:
@@ -362,6 +363,11 @@ class MessageReader:
                             'flood_rx': flood_rx,
                             'direct_rx': direct_rx
                         }
+                        if len(data) >= 30:
+                            (recv_errors,) = struct.unpack('<I', data[26:30])
+                            res['recv_errors'] = recv_errors
+                        else:
+                            res['recv_errors'] = None  # legacy 26-byte frame
                         logger.debug(f"parsed stats packets: {res}")
                         await self.dispatcher.dispatch(Event(EventType.STATS_PACKETS, res))
                     except struct.error as e:
@@ -372,6 +378,13 @@ class MessageReader:
                 logger.error(f"Unknown stats type: {stats_type}, data: {data.hex()}")
                 await self.dispatcher.dispatch(Event(EventType.ERROR, {"reason": f"unknown_stats_type: {stats_type}"}))
 
+        elif packet_type_value == PacketType.AUTOADD_CONFIG.value:
+            logger.debug(f"received autoadd config response: {data.hex()}")
+
+            res = {}
+            res["config"] = dbuf.read(1)[0]
+            await self.dispatcher.dispatch(Event(EventType.AUTOADD_CONFIG, res, res))            
+
         elif packet_type_value == PacketType.CHANNEL_INFO.value:
             logger.debug(f"received channel info response: {data.hex()}")
             res = {}
@@ -591,10 +604,10 @@ class MessageReader:
             )
 
         elif packet_type_value == PacketType.BINARY_RESPONSE.value:
-            logger.debug(f"Received binary data: {data.hex()}")
             dbuf.read(1)
             tag = dbuf.read(4).hex()
             response_data = dbuf.read()
+            logger.debug(f"Received binary data: {data.hex()}, tag {tag}, data {response_data.hex()}")
 
             # Always dispatch generic BINARY_RESPONSE
             binary_res = {"tag": tag, "data": response_data.hex()}
@@ -729,6 +742,69 @@ class MessageReader:
             res = {"reason": "private_key_export_disabled"}
             await self.dispatcher.dispatch(Event(EventType.DISABLED, res))
 
+        elif packet_type_value == PacketType.ADVERT_RESPONSE.value:
+            logger.debug(f"Received advert response: {data.hex()}")
+            # PUSH_CODE_ADVERT_RESPONSE (0x8F) format:
+            # Byte 0: 0x8F (push code)
+            # Bytes 1-4: tag (uint32)
+            # Bytes 5-36: pubkey (32 bytes)
+            # Byte 37: adv_type
+            # Bytes 38-69: node_name (32 bytes)
+            # Bytes 70-73: timestamp (uint32)
+            # Byte 74: flags
+            # [Optional fields based on flags]
+
+            if len(data) < 75:
+                logger.error(f"Advert response too short: {len(data)} bytes, need at least 75")
+                return
+
+            res = {}
+            offset = 1  # Skip push code
+
+            res["tag"] = struct.unpack('<I', data[offset:offset+4])[0]
+            offset += 4
+
+            res["pubkey"] = data[offset:offset+32].hex()
+            offset += 32
+
+            res["adv_type"] = data[offset]
+            offset += 1
+
+            res["node_name"] = data[offset:offset+32].decode('utf-8', errors='replace').rstrip('\x00')
+            offset += 32
+
+            res["timestamp"] = struct.unpack('<I', data[offset:offset+4])[0]
+            offset += 4
+
+            flags = data[offset]
+            res["flags"] = flags
+            offset += 1
+
+            # Parse optional fields based on flags
+            if flags & 0x01:  # has latitude
+                if offset + 4 <= len(data):
+                    lat_i32 = struct.unpack('<i', data[offset:offset+4])[0]
+                    res["latitude"] = lat_i32 / 1e6
+                    offset += 4
+
+            if flags & 0x02:  # has longitude
+                if offset + 4 <= len(data):
+                    lon_i32 = struct.unpack('<i', data[offset:offset+4])[0]
+                    res["longitude"] = lon_i32 / 1e6
+                    offset += 4
+
+            if flags & 0x04:  # has description
+                if offset + 32 <= len(data):
+                    res["node_desc"] = data[offset:offset+32].decode('utf-8', errors='replace').rstrip('\x00')
+                    offset += 32
+
+            attributes = {
+                "tag": res["tag"],
+                "pubkey": res["pubkey"],
+            }
+
+            await self.dispatcher.dispatch(Event(EventType.ADVERT_RESPONSE, res, attributes))
+
         elif packet_type_value == PacketType.CONTROL_DATA.value:
             logger.debug("Received control data packet")
             res={}

{meshcore-2.2.5 → meshcore-2.2.6}/tests/unit/test_commands.py

@@ -318,3 +318,26 @@ async def test_set_channel(command_handler, mock_connection):
 async def test_set_channel_invalid_secret_length(command_handler):
     with pytest.raises(ValueError, match="Channel secret must be exactly 16 bytes"):
         await command_handler.set_channel(1, "Test", b"tooshort")
+
+
+async def test_send_chan_msg_with_str_timestamp(command_handler, mock_connection):
+    ts = 1620000000
+    await command_handler.send_chan_msg(3, "world", timestamp=ts)
+    data = mock_connection.send.call_args[0][0]
+    assert data.startswith(b"\x03\x00\x03")
+    assert b"world" in data
+    assert data[3:7] == ts.to_bytes(4, "little")
+
+async def test_send_chan_msg_with_bytes_timestamp(command_handler, mock_connection):
+    ts = 1620000000
+    await command_handler.send_chan_msg(3, "world", timestamp=ts.to_bytes(4, "little"))
+    data = mock_connection.send.call_args[0][0]
+    assert data.startswith(b"\x03\x00\x03")
+    assert b"world" in data
+    assert data[3:7] == ts.to_bytes(4, "little")
+
+async def test_send_chan_msg_with_invalid_timestamp(command_handler, mock_connection):
+    result = await command_handler.send_chan_msg(3, "world", timestamp=b"00")
+
+    assert result.type == EventType.ERROR
+    assert result.payload["reason"] == "invalid_timestamp_format"

meshcore-2.2.5/src/meshcore/commands/control_data.py

@@ -1,50 +0,0 @@
-import logging
-import random
-
-from .base import CommandHandlerBase
-from ..events import EventType, Event
-from ..packets import ControlType, PacketType
-
-logger = logging.getLogger("meshcore")
-
-class ControlDataCommandHandler(CommandHandlerBase):
-    """Helper functions to handle binary requests through binary commands"""
-
-    async def send_control_data (self, control_type: int, payload: bytes) -> Event:
-        data = bytearray([PacketType.SEND_CONTROL_DATA.value]) 
-        data.extend(control_type.to_bytes(1, "little", signed = False)) 
-        data.extend(payload)
-
-        result = await self.send(data, [EventType.OK, EventType.ERROR])
-        return result
-
-    async def send_node_discover_req (
-        self,
-        filter: int,
-        prefix_only: bool=True,
-        tag: int=None,
-        since: int=None
-    ) -> Event:
-
-        if tag is None:
-            tag = random.randint(1, 0xFFFFFFFF)
-
-        data = bytearray()
-        data.extend(filter.to_bytes(1, "little", signed=False))
-        data.extend(tag.to_bytes(4, "little"))
-        if not since is None:
-            data.extend(since.to_bytes(4, "little", signed=False))
-
-        logger.debug(f"sending node discover req {data.hex()}")
-
-        flags = 0
-        flags = flags | 1 if prefix_only else flags
-
-        res = await self.send_control_data(
-            ControlType.NODE_DISCOVER_REQ.value|flags, data)
-
-        if res is None:
-            return None
-        else:
-            res.payload["tag"] = tag
-            return res