meshcore-cli 1.2.12__py3-none-any.whl → 1.3.0__py3-none-any.whl

meshcore_cli/meshcore_cli.py

@@ -32,7 +32,7 @@ import re
 from meshcore import MeshCore, EventType, logger
 
 # Version
-VERSION = "v1.2.12"
+VERSION = "v1.3.0"
 
 # default ble address is stored in a config file
 MCCLI_CONFIG_DIR = str(Path.home()) + "/.config/meshcore/"
@@ -76,13 +76,11 @@ ANSI_YELLOW = "\033[0;33m"
 ANSI_BYELLOW = "\033[1;33m"
 
 #Unicode chars
-# some possible symbols for prompts 🭬🬛🬗🭬🬛🬃🬗🭬🬛🬃🬗🬏🭀🭋🭨🮋
-ARROW_TAIL = "🭨"
-ARROW_HEAD = "🭬"
-
-if platform.system() == 'Windows' or platform.system() == 'Darwin':
-    ARROW_TAIL = ""                                                   
-    ARROW_HEAD = " "                                                   
+# some possible symbols for prompts 🭬🬛🬗🭬🬛🬃🬗🭬🬛🬃🬗🬏🭀🭋🭨🮋
+ARROW_HEAD = ""
+SLASH_END = ""
+SLASH_START = ""
+INVERT_SLASH = False
 
 def escape_ansi(line):
     ansi_escape = re.compile(r'(?:\x1B[@-_]|[\x80-\x9F])[0-?]*[ -/]*[@-~]')
@@ -205,29 +203,62 @@ process_event_message.print_snr=False
 process_event_message.color=True
 process_event_message.last_node=None
 
+PAYLOAD_TYPENAMES = ["REQ", "RESPONSE", "TEXT_MSG", "ACK", "ADVERT", "GRP_TXT", "GRP_DATA", "ANON_REQ", "PATH", "TRACE", "MULTIPART", "CONTROL"]
+ROUTE_TYPENAMES = ["TC_FLOOD", "FLOOD", "DIRECT", "TC_DIRECT"]
+
 async def handle_log_rx(event):
     mc = handle_log_rx.mc
-    if handle_log_rx.json_log_rx: # json mode ... raw dump
-        msg = json.dumps(event.payload)
-        if handle_message.above:
-            print_above(msg)
-        else :
-            print(msg)
-        return
 
     pkt = bytes().fromhex(event.payload["payload"])
     pbuf = io.BytesIO(pkt)
     header = pbuf.read(1)[0]
+    route_type = header & 0x03
+    payload_type = (header & 0x3c) >> 2
+    payload_ver = (header & 0xc0) >> 6
+
+    transport_code = None
+    if route_type == 0x00 or route_type == 0x03: # has transport code
+        transport_code = pbuf.read(4)    # discard transport code
+
+    path_len = pbuf.read(1)[0]
+    path = pbuf.read(path_len).hex() # Beware of traces where pathes are mixed
+
+    try :
+        route_typename = ROUTE_TYPENAMES[route_type]
+    except IndexError:
+        logger.debug(f"Unknown route type {route_type}") 
+        route_typename = "UNK"
+
+    try :
+        payload_typename = PAYLOAD_TYPENAMES[payload_type]
+    except IndexError:
+        logger.debug(f"Unknown payload type {payload_type}")
+        payload_typename = "UNK"
 
-    if header & ~1 == 0x14: # flood msg / channel
+    pkt_payload = pbuf.read()
+
+    event.payload["header"] = header
+    event.payload["route_type"] = route_type
+    event.payload["route_typename"] = route_typename
+    event.payload["payload_type"] = payload_type
+    event.payload["payload_typename"]= payload_typename
+
+    event.payload["payload_ver"] = payload_ver
+
+    if not transport_code is None:
+        event.payload["transport_code"] = transport_code.hex()
+
+    event.payload["path_len"] = path_len 
+    event.payload["path"] = path
+
+    event.payload["pkt_payload"] = pkt_payload.hex()
+
+    if payload_type == 0x05: # flood msg / channel
         if handle_log_rx.channel_echoes:
-            if header & 1 == 0: # has transport code
-                pbuf.read(4)    # discard transport code
-            path_len = pbuf.read(1)[0]
-            path = pbuf.read(path_len).hex()
-            chan_hash = pbuf.read(1).hex()
-            cipher_mac = pbuf.read(2)
-            msg = pbuf.read() # until the end of buffer
+            pk_buf = io.BytesIO(pkt_payload)
+            chan_hash = pk_buf.read(1).hex()
+            cipher_mac = pk_buf.read(2)
+            msg = pk_buf.read() # until the end of buffer
 
             channel = None
             for c in await get_channels(mc):
@@ -260,6 +291,14 @@ async def handle_log_rx(event):
                 else:
                     print(txt)
 
+    if handle_log_rx.json_log_rx: # json mode ... raw dump
+        msg = json.dumps(event.payload)
+        if handle_message.above:
+            print_above(msg)
+        else :
+            print(msg)
+
+
 handle_log_rx.json_log_rx = False
 handle_log_rx.channel_echoes = False
 handle_log_rx.mc = None
@@ -470,7 +509,7 @@ def make_completion_dict(contacts, pending={}, to=None, channels=None):
         "login" : contact_list,
         "cmd" : contact_list,
         "req_status" : contact_list,
-        "req_bstatus" : contact_list,
+        "req_neighbours": contact_list,
         "logout" : contact_list,
         "req_telemetry" : contact_list,
         "req_binary" : contact_list,
@@ -495,7 +534,6 @@ def make_completion_dict(contacts, pending={}, to=None, channels=None):
             "print_snr" : {"on":None, "off": None},
             "json_msgs" : {"on":None, "off": None},
             "color" : {"on":None, "off":None},
-            "print_name" : {"on":None, "off":None},
             "print_adverts" : {"on":None, "off":None},
             "json_log_rx" : {"on":None, "off":None},
             "channel_echoes" : {"on":None, "off":None},
@@ -525,7 +563,6 @@ def make_completion_dict(contacts, pending={}, to=None, channels=None):
             "print_snr":None,
             "json_msgs":None,
             "color":None,
-            "print_name":None,
             "print_adverts":None,
             "json_log_rx":None,
             "channel_echoes":None,
@@ -577,7 +614,6 @@ def make_completion_dict(contacts, pending={}, to=None, channels=None):
         "login" : None,
         "logout" : None,
         "req_status" : None,
-        "req_bstatus" : None,
         "req_neighbours": None,
         "cmd" : None,
         "ver" : None,
@@ -765,26 +801,32 @@ Line starting with \"$\" or \".\" will issue a meshcli command.
 
             color = process_event_message.color
             classic = interactive_loop.classic or not color
-            print_name = interactive_loop.print_name
 
             if classic:
                 prompt = ""
             else:
                 prompt = f"{ANSI_INVERT}"
 
-            if print_name or contact is None :
-                if color:
-                    prompt = prompt + f"{ANSI_BGRAY}"
-                prompt = prompt + f"{mc.self_info['name']}"
-                if contact is None: # display scope
-                    if not scope is None:
-                        prompt = prompt + f"|{scope}"
+            prompt = prompt + f"{ANSI_BGRAY}"
+            prompt = prompt + f"{mc.self_info['name']}"
+            if contact is None: # display scope
+                if not scope is None:
+                    prompt = prompt + f"|{scope}"
+
+            if contact is None :
                 if classic :
-                    prompt = prompt + "> "
+                    prompt = prompt + ">"
                 else :
-                    prompt = prompt + f"{ANSI_NORMAL}{ARROW_HEAD}{ANSI_INVERT}"
-
-            if not contact is None :
+                    prompt = prompt + f"{ANSI_NORMAL}{ARROW_HEAD}"
+            else:
+                if classic :
+                    prompt = prompt + "/"
+                else :
+                    if INVERT_SLASH:
+                        prompt = prompt + f"{ANSI_INVERT}"
+                    else:
+                        prompt = prompt + f"{ANSI_NORMAL}"
+                    prompt = prompt + f"{SLASH_START}"
                 if not last_ack:
                     prompt = prompt + f"{ANSI_BRED}"
                     if classic :
@@ -800,11 +842,9 @@ Line starting with \"$\" or \".\" will issue a meshcli command.
                 else :
                     prompt = prompt + f"{ANSI_BBLUE}"
                 if not classic:
+                    prompt = prompt + f"{SLASH_END}"
                     prompt = prompt + f"{ANSI_INVERT}"
 
-                if print_name and not classic :
-                    prompt = prompt + f"{ANSI_NORMAL}{ARROW_TAIL}{ANSI_INVERT}"
-
                 prompt = prompt + f"{contact['adv_name']}"
                 if contact["type"] == 0 or contact["out_path_len"]==-1:
                     if scope is None:
@@ -818,14 +858,15 @@ Line starting with \"$\" or \".\" will issue a meshcli command.
                         prompt = prompt + "|" + contact["out_path"]
 
                 if classic :
-                    prompt = prompt + f"{ANSI_NORMAL}> "
+                    prompt = prompt + f"{ANSI_NORMAL}>"
                 else:
                     prompt = prompt + f"{ANSI_NORMAL}{ARROW_HEAD}"
 
                 prompt = prompt + f"{ANSI_END}"
 
-                if not color :
-                    prompt=escape_ansi(prompt)
+            prompt = prompt + " "
+            if not color :
+                prompt=escape_ansi(prompt)
 
             session.app.ttimeoutlen = 0.2
             session.app.timeoutlen = 0.2
@@ -1036,8 +1077,10 @@ Line starting with \"$\" or \".\" will issue a meshcli command.
     except asyncio.CancelledError:
         # Handle task cancellation from KeyboardInterrupt in asyncio.run()
         print("Exiting cli")
-interactive_loop.classic = False
-interactive_loop.print_name = True
+if platform.system() == "Darwin" or platform.system() == "Windows":
+    interactive_loop.classic = True
+else:
+    interactive_loop.classic = False
 
 async def process_contact_chat_line(mc, contact, line):
     if contact["type"] == 0:
@@ -1069,6 +1112,29 @@ async def process_contact_chat_line(mc, contact, line):
             print("")
         return True
 
+    if line.startswith("sleep") or line.startswith("s"):
+        try:
+            sleeptime = int(line.split(" ",2)[1])
+            cmd_pos = 2
+        except IndexError: # nothing arg after sleep
+            sleeptime = 1
+            cmd_pos = 0
+        except ValueError:
+            sleeptime = 1
+            cmd_pos = 1
+
+        try:
+            if cmd_pos > 0:
+                secline = line.split(" ",cmd_pos)[cmd_pos]
+                await process_contact_chat_line(mc, contact, secline)
+        except IndexError:
+            pass
+
+        # will sleep after executed command if there is a command
+        await asyncio.sleep(sleeptime)
+
+        return True
+
     if line == "contact_lastmod":
         timestamp = contact["lastmod"]
         print(f"{contact['adv_name']} updated"
@@ -1085,7 +1151,6 @@ async def process_contact_chat_line(mc, contact, line):
             line == "contact_info" or line == "ci" or\
             line == "req_status" or line == "rs" or\
             line == "req_neighbours" or line == "rn" or\
-            line == "req_bstatus" or line == "rbs" or\
             line == "req_telemetry" or line == "rt" or\
             line == "req_acl" or\
             line == "path" or\
@@ -1615,7 +1680,7 @@ async def print_disc_trace_to (mc, contact):
 
 async def next_cmd(mc, cmds, json_output=False):
     """ process next command """
-    global ARROW_TAIL, ARROW_HEAD
+    global ARROW_HEAD, SLASH_START, SLASH_END, INVERT_SLASH
     try :
         argnum = 0
 
@@ -1722,37 +1787,25 @@ async def next_cmd(mc, cmds, json_output=False):
                 match cmds[1]:
                     case "help" :
                         argnum = 1
-                        print("""Available parameters :
-    pin <pin>                   : ble pin
-    radio <freq,bw,sf,cr>       : radio params
-    tuning <rx_dly,af>          : tuning params
-    tx <dbm>                    : tx power
-    name <name>                 : node name
-    lat <lat>                   : latitude
-    lon <lon>                   : longitude
-    coords <lat,lon>            : coordinates
-    print_snr <on/off>          : toggle snr display in messages
-    print_adverts <on/off>      : display adverts as they come
-    print_new_contacts <on/off> : display new pending contacts when available
-    print_path_updates <on/off> : display path updates as they come""")
+                        get_help_for("set")
                     case "max_flood_attempts":
                         msg_ack.max_flood_attempts=int(cmds[2])
                     case "max_attempts":
                         msg_ack.max_attempts=int(cmds[2])
                     case "flood_after":
                         msg_ack.flood_after=int(cmds[2])
-                    case "print_name":
-                        interactive_loop.print_name = (cmds[2] == "on")
-                        if json_output :
-                            print(json.dumps({"cmd" : cmds[1], "param" : cmds[2]}))
                     case "classic_prompt":
                         interactive_loop.classic = (cmds[2] == "on")
                         if json_output :
                             print(json.dumps({"cmd" : cmds[1], "param" : cmds[2]}))
-                    case "arrow_tail":
-                        ARROW_TAIL = cmds[2]
                     case "arrow_head":
                         ARROW_HEAD = cmds[2]
+                    case "slash_start":
+                        SLASH_START = cmds[2]
+                    case "slash_end":
+                        SLASH_END = cmds[2]
+                    case "invert_slash":
+                        INVERT_SLASH = cmds[2] == "on"
                     case "color" :
                         process_event_message.color = (cmds[2] == "on")
                         if json_output :
@@ -1958,21 +2011,7 @@ async def next_cmd(mc, cmds, json_output=False):
                 argnum = 1
                 match cmds[1]:
                     case "help":
-                        print("""Gets parameters from node
-    name               : node name
-    bat                : battery level in mV
-    fstats             : fs statistics
-    coords             : adv coordinates
-    lat                : latitude
-    lon                : longitude
-    radio              : radio parameters
-    tx                 : tx power
-    print_snr          : snr display in messages
-    print_adverts      : display adverts as they come
-    print_new_contacts : display new pending contacts when available
-    print_path_updates : display path updates as they come
-    custom             : all custom variables in json format
-                each custom var can also be get/set directly""")
+                        get_help_for("get")
                     case "max_flood_attempts":
                         if json_output :
                             print(json.dumps({"max_flood_attempts" : msg_ack.max_flood_attempts}))
@@ -1983,11 +2022,6 @@ async def next_cmd(mc, cmds, json_output=False):
                             print(json.dumps({"flood_after" : msg_ack.flood_after}))
                         else:
                             print(f"flood_after: {msg_ack.flood_after}")
-                    case "print_name":
-                        if json_output :
-                            print(json.dumps({"print_name" : interactive_loop.print_name}))
-                        else:
-                            print(f"{'on' if interactive_loop.print_name else 'off'}")
                     case "classic_prompt":
                         if json_output :
                             print(json.dumps({"classic_prompt" : interactive_loop.classic}))
@@ -2344,12 +2378,12 @@ async def next_cmd(mc, cmds, json_output=False):
                         else :
                             color = process_event_message.color
                             classic = interactive_loop.classic or not color
-                            print("]",end="")
+                            print(" ", end="")
                             for t in ev.payload["path"]:
                                 if classic :
                                     print("→",end="")
                                 else:
-                                    print(f" {ANSI_INVERT}", end="")
+                                    print(f"{ANSI_INVERT}", end="")
                                 snr = t['snr']
                                 if color:
                                     if snr >= 10 :
@@ -2368,7 +2402,7 @@ async def next_cmd(mc, cmds, json_output=False):
                                 if "hash" in t:
                                     print(f"[{t['hash']}]",end="")
                                 else:
-                                    print("[")
+                                    print()
 
             case "login" | "l" :
                 argnum = 2
@@ -2428,46 +2462,6 @@ async def next_cmd(mc, cmds, json_output=False):
                 contact = mc.get_contact_by_name(cmds[1])
                 contact["timeout"] = float(cmds[2])
 
-            case "req_status" | "rs" :
-                argnum = 1
-                await mc.ensure_contacts()
-                contact = mc.get_contact_by_name(cmds[1])
-                res = await mc.commands.send_statusreq(contact)
-                logger.debug(res)
-                if res.type == EventType.ERROR:
-                    print(f"Error while requesting status: {res}")
-                else :
-                    timeout = res.payload["suggested_timeout"]/800 if not "timeout" in contact or contact['timeout']==0 else contact["timeout"]
-                    res = await mc.wait_for_event(EventType.STATUS_RESPONSE, timeout=timeout)
-                    logger.debug(res)
-                    if res is None:
-                        if json_output :
-                            print(json.dumps({"error" : "Timeout waiting status"}))
-                        else:
-                            print("Timeout waiting status")
-                    else :
-                        print(json.dumps(res.payload, indent=4))
-
-            case "req_telemetry" | "rt" :
-                argnum = 1
-                await mc.ensure_contacts()
-                contact = mc.get_contact_by_name(cmds[1])
-                res = await mc.commands.send_telemetry_req(contact)
-                logger.debug(res)
-                if res.type == EventType.ERROR:
-                    print(f"Error while requesting telemetry")
-                else:
-                    timeout = res.payload["suggested_timeout"]/800 if not "timeout" in contact or contact['timeout']==0 else contact["timeout"]
-                    res = await mc.wait_for_event(EventType.TELEMETRY_RESPONSE, timeout=timeout)
-                    logger.debug(res)
-                    if res is None:
-                        if json_output :
-                            print(json.dumps({"error" : "Timeout waiting telemetry"}))
-                        else:
-                            print("Timeout waiting telemetry")
-                    else :
-                        print(json.dumps(res.payload, indent=4))
-
             case "disc_path" | "dp" :
                 argnum = 1
                 await mc.ensure_contacts()
@@ -2553,7 +2547,7 @@ async def next_cmd(mc, cmds, json_output=False):
 
                             print(f" {name:16} {type:>4} SNR: {n['SNR_in']:6,.2f}->{n['SNR']:6,.2f} RSSI: ->{n['RSSI']:4}")
 
-            case "req_btelemetry"|"rbt" :
+            case "req_telemetry"|"rt" :
                 argnum = 1
                 await mc.ensure_contacts()
                 contact = mc.get_contact_by_name(cmds[1])
@@ -2565,9 +2559,13 @@ async def next_cmd(mc, cmds, json_output=False):
                     else:
                         print("Error getting data")
                 else :
-                    print(json.dumps(res))
+                    print(json.dumps({
+                        "name": contact["adv_name"],
+                        "pubkey_pre": contact["public_key"][0:12],
+                        "lpp": res,
+                    }, indent = 4))
 
-            case "req_bstatus"|"rbs" :
+            case "req_status"|"rs" :
                 argnum = 1
                 await mc.ensure_contacts()
                 contact = mc.get_contact_by_name(cmds[1])
@@ -2651,15 +2649,30 @@ async def next_cmd(mc, cmds, json_output=False):
                     if json_output:
                         print(json.dumps(res, indent=4))
                     else:
+                        width = os.get_terminal_size().columns
                         print(f"Got {res['results_count']} neighbours out of {res['neighbours_count']} from {contact['adv_name']}:")
                         for n in res['neighbours']:
                             ct = mc.get_contact_by_key_prefix(n["pubkey"])
-                            if ct :
+                            if ct and width > 60 :
                                 name = f"[{n['pubkey'][0:8]}] {ct['adv_name']}"
+                                name = f"{name:30}"
+                            elif ct :
+                                name = f"{ct['adv_name']}"
+                                name = f"{name:20}"
                             else:
                                 name = f"[{n['pubkey']}]"
 
-                            print(f" {name:30} last viewed {n['secs_ago']} sec ago at {n['snr']} ")
+                            t_s = n['secs_ago']
+                            time_ago = f"{t_s}s"
+                            if t_s / 86400 >= 1 : # result in days
+                                time_ago = f"{int(t_s/86400)}d ago{f' ({time_ago})' if width > 62 else ''}"
+                            elif t_s / 3600 >= 1 : # result in days
+                                time_ago = f"{int(t_s/3600)}h ago{f' ({time_ago})' if width > 62 else ''}"
+                            elif t_s / 60 >= 1 : # result in min
+                                time_ago = f"{int(t_s/60)}m ago{f' ({time_ago})' if width > 62 else ''}"
+
+
+                            print(f" {name} {time_ago}, {n['snr']}dB{' SNR' if width > 66 else ''}")
 
             case "req_binary" :
                 argnum = 2
@@ -3109,8 +3122,8 @@ def command_help():
     reboot                 : reboots node
     sleep <secs>           : sleeps for a given amount of secs      s
     wait_key               : wait until user presses <Enter>        wk
-    apply_to <scope> <cmds>: sends cmds to contacts matching scope  at
-  Messenging
+    apply_to <f> <cmds>    : sends cmds to contacts matching f      at
+  Messaging
     msg <name> <msg>       : send message to node by name           m  {
     wait_ack               : wait an ack                            wa }
     chan <nb> <msg>        : send message to channel number <nb>    ch
@@ -3123,6 +3136,7 @@ def command_help():
     get_channel <n>        : get info for channel (by number or name)
     set_channel n nm k     : set channel info (nb, name, key)
     remove_channel <n>     : remove channel (by number or name)
+    scope <s>              : sets scope for flood messages
   Management
     advert                 : sends advert                           a
     floodadv               : flood advert
@@ -3174,7 +3188,6 @@ def usage () :
     -D : debug
     -S : scan for devices and show a selector
     -l : list available ble/serial devices and exit
-    -c <on/off>     : disables most of color output if off
     -T <timeout>    : timeout for the ble scan (-S and -l) default 2s
     -a <address>    : specifies device address (can be a name)
     -d <name>       : filter meshcore devices with name or address
@@ -3183,14 +3196,16 @@ def usage () :
     -p <port>       : specifies tcp port (default 5000)
     -s <port>       : use serial port <port>
     -b <baudrate>   : specify baudrate
+    -C              : toggles classic mode for prompt
+    -c <on/off>     : disables most of color output if off
 
  Available Commands and shorcuts (can be chained) :""")
     command_help()
 
 def get_help_for (cmdname, context="line") :
     if cmdname == "apply_to" or cmdname == "at" :
-        print("""apply_to <scope> <cmd> : applies cmd to contacts matching scope
-    Scope acts like a filter with comma separated fields :
+        print("""apply_to <f> <cmd> : applies cmd to contacts matching filter <f>
+    Filter is constructed with comma separated fields :
      - u, matches modification time < or > than a timestamp
             (can also be days hours or minutes ago if followed by d,h or m)
      - t, matches the type (1: client, 2: repeater, 3: room, 4: sensor)
@@ -3198,7 +3213,7 @@ def get_help_for (cmdname, context="line") :
      - d, direct, similar to h>-1
      - f, flood, similar to h<0 or h=-1
 
-    Note: Some commands like contact_name (aka cn), reset_path (aka rp), forget_password (aka fp) can be chained.
+    Note: Some commands like contact_name (aka cn), reset_path (aka rp), forget_password (aka fp) can be chained. There is also a sleep command taking an optional event. The sleep will be issued after the command, it helps limiting rate through repeaters ...
 
     Examples:
         # removes all clients that have not been updated in last 2 days
@@ -3209,7 +3224,7 @@ def get_help_for (cmdname, context="line") :
         at t=2 rp login
 """)
 
-    if cmdname == "node_discover" or cmdname == "nd" :
+    elif cmdname == "node_discover" or cmdname == "nd" :
         print("""node_discover <filter> : discovers 0-hop nodes and displays signal info
 
     filter can be "all" for all types or nodes or a comma separated list consisting of :
@@ -3221,6 +3236,68 @@ def get_help_for (cmdname, context="line") :
     nd can be used with no filter parameter ... !!! BEWARE WITH CHAINING !!!
 """)
 
+    elif cmdname == "get" :
+        print("""Gets parameters from node
+  Please see also help for set command, which is more up to date ...
+    name               : node name
+    bat                : battery level in mV
+    fstats             : fs statistics
+    coords             : adv coordinates
+    lat                : latitude
+    lon                : longitude
+    radio              : radio parameters
+    tx                 : tx power
+    print_snr          : snr display in messages
+    print_adverts      : display adverts as they come
+    print_new_contacts : display new pending contacts when available
+    print_path_updates : display path updates as they come
+    custom             : all custom variables in json format
+                each custom var can also be get/set directly""")
+
+    elif cmdname == "set" :
+        print("""Available parameters :
+  device:
+    pin <pin>                   : ble pin
+    radio <freq,bw,sf,cr>       : radio params
+    tuning <rx_dly,af>          : tuning params
+    tx <dbm>                    : tx power
+    name <name>                 : node name
+    lat <lat>                   : latitude
+    lon <lon>                   : longitude
+    coords <lat,lon>            : coordinates
+    auto_update_contacts <>     : automatically updates contact list
+    multi_ack <on/off>          : multi-acks feature
+    telemetry_mode_base <mode>  : set basic telemetry mode all/selected/off
+    telemetry_mode_loc <mode>   : set location telemetry mode all/selected/off
+    telemetry_mode_env <mode>   : set env telemetry mode all/selected/off
+    advert_loc_policy <policy>  : "share" means loc will be shared in adv
+  display:
+    print_snr <on/off>          : toggle snr display in messages
+    print_adverts <on/off>      : display adverts as they come
+    print_new_contacts <on/off> : display new pending contacts when available
+    print_path_updates <on/off> : display path updates as they come
+    json_log_rx <on/off>        : logs packets incoming to device as json
+    channel_echoes <on/off>     : print repeats for channel data
+    echo_unk_channels <on/off>  : also dump unk channels (encrypted)
+    color <on/off>              : color off should remove ANSI codes from output
+  prompt:
+    classic_prompt <on/off>     : activates less fancier prompt
+    arrow_head <string>         : change arrow head in prompt
+    slash_start <string>        : idem for slash start
+    slash_end <string>          : slash end
+    invert_slash <on/off>       : apply color inversion to slash """)
+
+    elif cmdname == "scope":
+        print("""scope <scope> : changes flood scope of the node
+
+    The scope command can be used from command line or interactive mode to set the region in which flood packets will be transmitted.
+
+Managing Flood Scope in interactive mode
+    Flood scope has recently been introduced in meshcore (from v1.10.0). It limits the scope of packets to regions, using transport codes in the frame.
+    When entering chat mode, scope will be reset to *, meaning classic flood.
+    You can switch scope using the scope command, or postfixing the to command with %<scope>.
+    Scope can also be applied to a command using % before the scope name. For instance login%#Morbihan will limit diffusion of the login command (which is usually sent flood to get the path to a repeater) to the #Morbihan region.""")
+
     else:
         print(f"Sorry, no help yet for {cmdname}")
 
@@ -3242,12 +3319,14 @@ async def main(argv):
         with open(MCCLI_ADDRESS, encoding="utf-8") as f :
             address = f.readline().strip()
 
-    opts, args = getopt.getopt(argv, "a:d:s:ht:p:b:fjDhvSlT:Pc:")
+    opts, args = getopt.getopt(argv, "a:d:s:ht:p:b:fjDhvSlT:Pc:C")
     for opt, arg in opts :
         match opt:
             case "-c" :
                 if arg == "off":
                     process_event_message.color = False
+            case "-C":
+                interactive_loop.classic = not interactive_loop.classic
             case "-d" : # name specified on cmdline
                 address = arg
             case "-a" : # address specified on cmdline

{meshcore_cli-1.2.12.dist-info → meshcore_cli-1.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcore-cli
-Version: 1.2.12
+Version: 1.3.0
 Summary: Command line interface to meshcore companion radios
 Project-URL: Homepage, https://github.com/fdlamotte/meshcore-cli
 Project-URL: Issues, https://github.com/fdlamotte/meshcore-cli/issues
@@ -58,22 +58,25 @@ Init files can also be defined for a given device, meshcore-cli will look for `&
 
 ### Arguments
 
-Arguments mostly deals with ble connection
+Arguments mostly deals with connection to the node
 
 <pre>
     -h : prints this help
     -v : prints version
     -j : json output (disables init file)
     -D : debug
-    -S : performs a ble scan and ask for device
-    -l : list available ble devices and exit
-    -T &lt;timeout>    : timeout for the ble scan (-S and -l) default 2s
-    -a &lt;address>    : specifies device address (can be a name)
-    -d &lt;name>       : filter meshcore devices with name or address
-    -t &lt;hostname>   : connects via tcp/ip
-    -p &lt;port>       : specifies tcp port (default 5000)
-    -s &lt;port>       : use serial port &lt;port>
-    -b &lt;baudrate>   : specify baudrate
+    -S : scan for devices and show a selector
+    -l : list available ble/serial devices and exit
+    -T &lt;timeout&gt;    : timeout for the ble scan (-S and -l) default 2s
+    -a &lt;address&gt;    : specifies device address (can be a name)
+    -d &lt;name&gt;       : filter meshcore devices with name or address
+    -P              : forces pairing via the OS
+    -t &lt;hostname&gt;   : connects via tcp/ip
+    -p &lt;port&gt;       : specifies tcp port (default 5000)
+    -s &lt;port&gt;       : use serial port &lt;port&gt;
+    -b &lt;baudrate&gt;   : specify baudrate
+    -C              : toggles classic mode for prompt
+    -c &lt;on/off&gt;     : disables most of color output if off
 </pre>
 
 ### Available Commands
@@ -81,60 +84,70 @@ Arguments mostly deals with ble connection
 Commands are given after arguments, they can be chained and some have shortcuts. Also prefixing a command with a dot `.` will force it to output json instead of synthetic result.
 
 <pre>
+    ?&lt;cmd&gt; may give you some more help about cmd
   General commands
     chat                   : enter the chat (interactive) mode
-    chat_to &lt;ct>           : enter chat with contact                to
-    script &lt;filename>      : execute commands in filename
+    chat_to &lt;ct&gt;           : enter chat with contact                to
+    script &lt;filename&gt;      : execute commands in filename
     infos                  : print informations about the node      i
     self_telemetry         : print own telemtry                     t
     card                   : export this node URI                   e
     ver                    : firmware version                       v
     reboot                 : reboots node
-    sleep &lt;secs>           : sleeps for a given amount of secs      s
-    wait_key               : wait until user presses &lt;Enter>        wk
-  Messenging
-    msg &lt;name> &lt;msg>       : send message to node by name           m  {
+    sleep &lt;secs&gt;           : sleeps for a given amount of secs      s
+    wait_key               : wait until user presses &lt;Enter&gt;        wk
+    apply_to &lt;f&gt; &lt;cmds&gt;    : sends cmds to contacts matching f      at
+  Messaging
+    msg &lt;name&gt; &lt;msg&gt;       : send message to node by name           m  {
     wait_ack               : wait an ack                            wa }
-    chan &lt;nb> &lt;msg>        : send message to channel number &lt;nb>    ch
-    public &lt;msg>           : send message to public channel (0)     dch
+    chan &lt;nb&gt; &lt;msg&gt;        : send message to channel number &lt;nb&gt;    ch
+    public &lt;msg&gt;           : send message to public channel (0)     dch
     recv                   : reads next msg                         r
     wait_msg               : wait for a message and read it         wm
     sync_msgs              : gets all unread msgs from the node     sm
     msgs_subscribe         : display msgs as they arrive            ms
-    get_channel &lt;n>        : get info for channel n
+    get_channels           : prints all channel info
+    get_channel &lt;n&gt;        : get info for channel (by number or name)
     set_channel n nm k     : set channel info (nb, name, key)
+    remove_channel &lt;n&gt;     : remove channel (by number or name)
+    scope &lt;s&gt;              : sets node's flood scope
   Management
     advert                 : sends advert                           a
     floodadv               : flood advert
-    get &lt;param>            : gets a param, "get help" for more
-    set &lt;param> &lt;value>    : sets a param, "set help" for more
-    time &lt;epoch>           : sets time to given epoch
+    get &lt;param&gt;            : gets a param, \"get help\" for more
+    set &lt;param&gt; &lt;value&gt;    : sets a param, \"set help\" for more
+    time &lt;epoch&gt;           : sets time to given epoch
     clock                  : get current time
     clock sync             : sync device clock                      st
+    node_discover &lt;filter&gt; : discovers nodes based on their type    nd
   Contacts
     contacts / list        : gets contact list                      lc
-    contact_info &lt;ct>      : prints information for contact ct      ci
-    contact_timeout &lt;ct> v : sets temp default timeout for contact
-    share_contact &lt;ct>     : share a contact with others            sc
-    export_contact &lt;ct>    : get a contact's URI                    ec
-    import_contact &lt;URI>   : import a contact from its URI          ic
-    remove_contact &lt;ct>    : removes a contact from this node
-    path &lt;ct>              : diplays path for a contact
-    reset_path &lt;ct>        : resets path to a contact to flood      rp
-    change_path &lt;ct> &lt;pth> : change the path to a contact           cp
-    change_flags &lt;ct> &lt;f>  : change contact flags (tel_l|tel_a|star)cf
-    req_telemetry &lt;ct>     : prints telemetry data as json          rt
-    req_mma &lt;ct>           : requests min/max/avg for a sensor      rm
-    req_acl &lt;ct>           : requests access control list for sensor
+    reload_contacts        : force reloading all contacts           rc
+    contact_info &lt;ct&gt;      : prints information for contact ct      ci
+    contact_timeout &lt;ct&gt; v : sets temp default timeout for contact
+    share_contact &lt;ct&gt;     : share a contact with others            sc
+    export_contact &lt;ct&gt;    : get a contact's URI                    ec
+    import_contact &lt;URI&gt;   : import a contact from its URI          ic
+    remove_contact &lt;ct&gt;    : removes a contact from this node
+    path &lt;ct&gt;              : diplays path for a contact
+    disc_path &lt;ct&gt;         : discover new path and display          dp
+    reset_path &lt;ct&gt;        : resets path to a contact to flood      rp
+    change_path &lt;ct&gt; &lt;pth&gt; : change the path to a contact           cp
+    change_flags &lt;ct&gt; &lt;f&gt;  : change contact flags (tel_l|tel_a|star)cf
+    req_telemetry &lt;ct&gt;     : prints telemetry data as json          rt
+    req_mma &lt;ct&gt;           : requests min/max/avg for a sensor      rm
+    req_acl &lt;ct&gt;           : requests access control list for sensor
     pending_contacts       : show pending contacts
-    add_pending &lt;key>      : manually add pending contact from key
-    flush_pending          : flush pending contact clist
+    add_pending &lt;pending&gt;  : manually add pending contact
+    flush_pending          : flush pending contact list
   Repeaters
-    login &lt;name> &lt;pwd>     : log into a node (rep) with given pwd   l
-    logout &lt;name>          : log out of a repeater
-    cmd &lt;name> &lt;cmd>       : sends a command to a repeater (no ack) c  [
+    login &lt;name&gt; &lt;pwd&gt;     : log into a node (rep) with given pwd   l
+    logout &lt;name&gt;          : log out of a repeater
+    cmd &lt;name&gt; &lt;cmd&gt;       : sends a command to a repeater (no ack) c  [
     wmt8                   : wait for a msg (reply) with a timeout     ]
-    req_status &lt;name>      : requests status from a node            rs
+    req_status &lt;name&gt;      : requests status from a node            rs
+    req_neighbours &lt;name&gt;  : requests for neighbours in binary form rn
+    trace &lt;path&gt;           : run a trace, path is comma separated
 </pre>
 
 ### Interactive Mode
@@ -147,14 +160,70 @@ You'll get a prompt with the name of your node. From here you can type meshcore-
 
 The `to` command is specific to chat mode, it lets you enter the recipient for next command. By default you're on your node but you can enter other nodes or public rooms. Here are some examples :
 
-- `to <nodename>` : will enter nodename
+- `to <dest>` : will enter dest (node or channel)
 - `to /`, `to ~` : will go to the root (your node)
 - `to ..` : will go to the last node (it will switch between the two last nodes, this is just a 1-depth history)
 - `to !` : will switch to the node you received last message from
 
-When you are connected to a node, the behaviour will depend on the node type, if you're on a chat node, it will send messages by default and you can chat. On a repeater or a room server, it will send commands (autocompletioin has been set to comply with the CommonCli class of meshcore). To send a message through a room you'll have to prefix the message with a quote or use the send command.
+When you are in a node, the behaviour will depend on the node type, if you're on a chat node, it will send messages by default and you can chat. On a repeater or a room server, it will send commands (autocompletion has been set to comply with the CommonCli class of meshcore). To send a message through a room you'll have to prefix the message with a quote or use the send command.
 
-You can alse set a channel as recipient, `to public` will switch to the public channel, and `to ch1` to channel 1.
+The `/` character is used to bypass the node you have currently selected using `to`:
+- `/<cmd>` issues cmd command on the root
+- `/<node>/<cmd>` will send cmd to selected node
+- `/<dest> <msg>` will send msg to dest (channel or node)
+
+#### Flood Scope in interactive mode
+
+Flood scope has recently been introduced in meshcore (from `v1.10.0`). It limits the scope of packets to regions, using transport codes in the frame.
+
+When entering chat mode, scope will be reset to `*`, meaning classic flood.
+
+You can switch scope using the `scope` command, or postfixing the `to` command with `%<scope>`.
+
+Scope can also be applied to a command using `%` before the scope name. For instance `login%#Morbihan` will limit diffusion of the login command (which is usually sent flood to get the path to a repeater) to the `#Morbihan` region.
+
+#### Channel echoes
+
+It's sometimes interesting to know the path taken by a message received from a channel or which repeaters have repeated a sent message.
+
+The app give you the information by listening `rx_log` from the device, when obtained the information is attached to the message and can be read.
+
+In meshcore-cli I went lower-level by implementing channel echoes. When activated (with `/set channel_echoes on`), all the channel messages will be printed on the terminal along with the SNR and path taken. When sending a message, you'll have all the repeats from 0-hop repeaters as echoes, and when a message is received, you should see information about the received message, but also all the instances of the same message that might have reached you from another path.
+
+In the example below, a msg has been sent between two repeaters, 21 and 25. 25 repeated the message and 21 the repeat and both echoes came back to the node with different SNRs.
+
+```
+f1down/#fdl|*> 8
+#fdl f1down: 8                                                 [25] -4.75-112
+#fdl f1down: 8                                               [2521]  1.00-109
+```
+
+### Issuing batch commands to contacts with apply to
+
+`apply_to <f> <cmd>` : applies cmd to contacts matching filter `<f>` it can be used to apply the same command to a pool of repeaters, or remove some contacts matching a condition.
+
+Filter is constructed with comma separated fields :
+ 
+- `u`, matches modification time `<` or `>` than a timestamp (can also be days hours or minutes ago if followed by `d`,`h` or `m`)
+- `t`, matches the type (1: client, 2: repeater, 3: room, 4: sensor)
+- `h`, matches number of hops
+- `d`, direct, similar to `h>-1`
+- `f`, flood, similar to `h<0` or `h=-1`
+
+Commands should be written as if in interactive mode, if writing from the commandline don't forget to use commas to clearly delimit fields.
+                    
+Note: Some commands like `contact_name` (aka `cn`), `reset_path` (aka `rp`), `forget_password` (aka `fp`) can be chained. There is also a `sleep` command taking an optional time parameter. The sleep will be issued after the command, it helps limiting rate through repeaters ...
+                   
+#### Examples
+
+```
+  # removes all clients that have not been updated in last 2 days
+  at u<2d,t=1 remove_contact
+  # gives traces to repeaters that have been updated in the last 24h and are direct
+  at t=2,u>1d,d cn trace
+  # tries to do flood login to all repeaters
+  at t=2 rp login
+```
 
 ## Examples
 

meshcore_cli-1.3.0.dist-info/RECORD

@@ -0,0 +1,8 @@
+meshcore_cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+meshcore_cli/__main__.py,sha256=PfYgibmu2LEtC-OV7L1UgmvV3swJ5rQ4bbXHlwUFlgE,83
+meshcore_cli/meshcore_cli.py,sha256=C6dZGtfqIEIsEaoVBNOmr4xmoy0sMr-gZOTqZ0prxd0,146609
+meshcore_cli-1.3.0.dist-info/METADATA,sha256=Fgv1cb5iij3ExDitwB8vRvP7GuxSOPqkv5nxnyATMRA,15873
+meshcore_cli-1.3.0.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+meshcore_cli-1.3.0.dist-info/entry_points.txt,sha256=77V29Pyth11GteDk7tneBN3MMk8JI7bTlS-BGSmxCmI,103
+meshcore_cli-1.3.0.dist-info/licenses/LICENSE,sha256=F9s987VtS0AKxW7LdB2EkLMkrdeERI7ICdLJR60A9M4,1066
+meshcore_cli-1.3.0.dist-info/RECORD,,

meshcore_cli-1.2.12.dist-info/RECORD

@@ -1,8 +0,0 @@
-meshcore_cli/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-meshcore_cli/__main__.py,sha256=PfYgibmu2LEtC-OV7L1UgmvV3swJ5rQ4bbXHlwUFlgE,83
-meshcore_cli/meshcore_cli.py,sha256=cbZPbXrhDENJvnGlR63lrupJQ22Nzk4bxGzudBKQMxQ,143616
-meshcore_cli-1.2.12.dist-info/METADATA,sha256=XU2LqLOUEHonAUDaa2VaiLsp_wvVa5XIwobda-mP_NE,11658
-meshcore_cli-1.2.12.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-meshcore_cli-1.2.12.dist-info/entry_points.txt,sha256=77V29Pyth11GteDk7tneBN3MMk8JI7bTlS-BGSmxCmI,103
-meshcore_cli-1.2.12.dist-info/licenses/LICENSE,sha256=F9s987VtS0AKxW7LdB2EkLMkrdeERI7ICdLJR60A9M4,1066
-meshcore_cli-1.2.12.dist-info/RECORD,,