meshcore-cli 1.1.40__py3-none-any.whl → 1.2.10__py3-none-any.whl

meshcore_cli/meshcore_cli.py

@@ -1,29 +1,39 @@
 #!/usr/bin/python
-""" 
+"""
     mccli.py : CLI interface to MeschCore BLE companion app
 """
+
 import asyncio
-import os, sys
+import os, sys, io, platform
 import time, datetime
 import getopt, json, shlex, re
 import logging
 import requests
 from bleak import BleakScanner, BleakClient
+from bleak.exc import BleakError
 import serial.tools.list_ports
 from pathlib import Path
 import traceback
 from prompt_toolkit.shortcuts import PromptSession
 from prompt_toolkit.shortcuts import CompleteStyle
 from prompt_toolkit.completion import NestedCompleter
+from prompt_toolkit.completion import CompleteEvent, Completer, Completion
 from prompt_toolkit.history import FileHistory
 from prompt_toolkit.formatted_text import ANSI
 from prompt_toolkit.key_binding import KeyBindings
 from prompt_toolkit.shortcuts import radiolist_dialog
+from prompt_toolkit.completion.word_completer import WordCompleter
+from prompt_toolkit.document import Document
+from hashlib import sha256
+from Crypto.Cipher import AES
+from Crypto.Hash import HMAC, SHA256
+
+import re
 
 from meshcore import MeshCore, EventType, logger
 
 # Version
-VERSION = "v1.1.40"
+VERSION = "v1.2.10"
 
 # default ble address is stored in a config file
 MCCLI_CONFIG_DIR = str(Path.home()) + "/.config/meshcore/"
@@ -45,6 +55,7 @@ ANSI_INVERT = "\033[7m"
 ANSI_NORMAL = "\033[27m"
 ANSI_GREEN = "\033[0;32m"
 ANSI_BGREEN = "\033[1;32m"
+ANSI_DGREEN="\033[0;38;5;22m"
 ANSI_BLUE = "\033[0;34m"
 ANSI_BBLUE = "\033[1;34m"
 ANSI_RED = "\033[0;31m"
@@ -65,6 +76,15 @@ ANSI_BORANGE="\033[1;38;5;214m"
 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 = " "                                                   
+
 def escape_ansi(line):
     ansi_escape = re.compile(r'(?:\x1B[@-_]|[\x80-\x9F])[0-?]*[ -/]*[@-~]')
     return ansi_escape.sub('', line)
@@ -186,6 +206,66 @@ process_event_message.print_snr=False
 process_event_message.color=True
 process_event_message.last_node=None
 
+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]
+
+    if header & ~1 == 0x14: # 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
+
+            channel = None
+            for c in await get_channels(mc):
+                if c["channel_hash"] == chan_hash : # validate against MAC
+                    h = HMAC.new(bytes.fromhex(c["channel_secret"]), digestmod=SHA256)
+                    h.update(msg)
+                    if h.digest()[0:2] == cipher_mac:
+                        channel = c
+                        break
+
+            chan_name = ""
+
+            if channel is None :
+                if handle_log_rx.echo_unk_chans:
+                    chan_name = chan_hash
+                    message = msg.hex()
+            else:
+                chan_name = channel["channel_name"]
+                aes_key = bytes.fromhex(channel["channel_secret"])
+                cipher = AES.new(aes_key, AES.MODE_ECB)
+                message = cipher.decrypt(msg)[5:].decode("utf-8").strip("\x00")
+
+            if chan_name != "" :
+                width = os.get_terminal_size().columns
+                cars = width - 13 - 2 * path_len - len(chan_name) - 1
+                dispmsg = message[0:cars]
+                txt = f"{ANSI_LIGHT_GRAY}{chan_name} {ANSI_DGREEN}{dispmsg+(cars-len(dispmsg))*' '} {ANSI_YELLOW}[{path}]{ANSI_LIGHT_GRAY}{event.payload['snr']:6,.2f}{event.payload['rssi']:4}{ANSI_END}"
+                if handle_message.above:
+                    print_above(txt)
+                else:
+                    print(txt)
+
+handle_log_rx.json_log_rx = False
+handle_log_rx.channel_echoes = False
+handle_log_rx.mc = None
+handle_log_rx.echo_unk_chans=False
+
 async def handle_advert(event):
     if not handle_advert.print_adverts:
         return
@@ -257,7 +337,7 @@ async def log_message(mc, msg):
     if msg["type"] == "PRIV" :
         ct = mc.get_contact_by_key_prefix(msg['pubkey_prefix'])
         if ct is None:
-            msg["name"] = data["pubkey_prefix"]
+            msg["name"] = msg["pubkey_prefix"]
         else:
             msg["name"] = ct["adv_name"]
     elif msg["type"] == "CHAN" :
@@ -296,6 +376,29 @@ async def subscribe_to_msgs(mc, json_output=False, above=False):
         CS = mc.subscribe(EventType.CHANNEL_MSG_RECV, handle_message)
     await mc.start_auto_message_fetching()
 
+# redefine get_completion to let user put symbols in first item
+# and handle navigating in path ...
+class MyNestedCompleter(NestedCompleter):
+    def get_completions( self, document, complete_event):
+        txt = document.text_before_cursor.lstrip()
+        if not " " in txt:
+            if txt != "" and txt[0] == "/" and txt.count("/") == 1:
+                opts = []
+                for k in self.options.keys():
+                    if k[0] == "/" :
+                        v = "/" + k.split("/")[1] #+ ("/" if k.count("/") == 2 else "")
+                        if v not in opts:
+                            opts.append(v)
+            else:
+                opts = self.options.keys()
+            completer = WordCompleter(
+                opts, ignore_case=self.ignore_case,
+                pattern=re.compile(r"([a-zA-Z0-9_\\/\#]+|[^a-zA-Z0-9_\s\#]+)"))
+            yield from completer.get_completions(document, complete_event)
+        else: # normal behavior for remainder
+            yield from super().get_completions(document, complete_event)
+
+
 def make_completion_dict(contacts, pending={}, to=None, channels=None):
     contact_list = {}
     pending_list = {}
@@ -306,12 +409,15 @@ def make_completion_dict(contacts, pending={}, to=None, channels=None):
     if not process_event_message.last_node is None:
         to_list["!"] = None
     to_list[".."] = None
-    to_list["public"] = None
 
     it = iter(contacts.items())
     for c in it :
         contact_list[c[1]['adv_name']] = None
 
+    pit = iter(pending.items())
+    for c in pit :
+        pending_list[c[1]['adv_name']] = None
+
     pit = iter(pending.items())
     for c in pit :
         pending_list[c[1]['public_key']] = None
@@ -332,229 +438,269 @@ def make_completion_dict(contacts, pending={}, to=None, channels=None):
         "chan" : None,
     }
 
+    root_completion_list = {
+        "ver" : None,
+        "infos" : None,
+        "advert" : None,
+        "floodadv" : None,
+        "msg" : contact_list,
+        "wait_ack" : None,
+        "time" : None,
+        "clock" : {"sync" : None},
+        "reboot" : None,
+        "card" : None,
+        "upload_card" : None,
+        "contacts": None,
+        "pending_contacts": None,
+        "add_pending": pending_list,
+        "flush_pending": None,
+        "contact_info": contact_list,
+        "export_contact" : contact_list,
+        "upload_contact" : contact_list,
+        "share_contact" : contact_list,
+        "path": contact_list,
+        "disc_path" : contact_list,
+        "node_discover": {"all":None, "sens":None, "rep":None, "comp":None, "room":None, "cli":None},
+        "trace" : None,
+        "reset_path" : contact_list,
+        "change_path" : contact_list,
+        "change_flags" : contact_list,
+        "remove_contact" : contact_list,
+        "import_contact" : {"meshcore://":None},
+        "reload_contacts" : None,
+        "login" : contact_list,
+        "cmd" : contact_list,
+        "req_status" : contact_list,
+        "req_bstatus" : contact_list,
+        "logout" : contact_list,
+        "req_telemetry" : contact_list,
+        "req_binary" : contact_list,
+        "req_mma" : contact_list,
+        "self_telemetry" : None,
+        "get_channel": None,
+        "set_channel": None,
+        "get_channels": None,
+        "remove_channel": None,
+        "apply_to": None,
+        "at": None,
+        "scope": None,
+        "set" : {
+            "name" : None,
+            "pin" : None,
+            "radio" : {",,,":None, "f,bw,sf,cr":None},
+            "tx" : None,
+            "tuning" : {",", "af,tx_d"},
+            "lat" : None,
+            "lon" : None,
+            "coords" : 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},
+            "echo_unk_chans" : {"on":None, "off":None},
+            "print_new_contacts" : {"on": None, "off":None},
+            "print_path_updates" : {"on":None,"off":None},
+            "classic_prompt" : {"on" : None, "off":None},
+            "manual_add_contacts" : {"on" : None, "off":None},
+            "telemetry_mode_base" : {"always" : None, "device":None, "never":None},
+            "telemetry_mode_loc" : {"always" : None, "device":None, "never":None},
+            "telemetry_mode_env" : {"always" : None, "device":None, "never":None},
+            "advert_loc_policy" : {"none" : None, "share" : None},
+            "auto_update_contacts" : {"on":None, "off":None},
+            "multi_acks" : {"on": None, "off":None},
+            "max_attempts" : None,
+            "max_flood_attempts" : None,
+            "flood_after" : None,
+        },
+        "get" : {"name":None,
+            "bat":None,
+            "fstats": None,
+            "radio":None,
+            "tx":None,
+            "coords":None,
+            "lat":None,
+            "lon":None,
+            "print_snr":None,
+            "json_msgs":None,
+            "color":None,
+            "print_name":None,
+            "print_adverts":None,
+            "json_log_rx":None,
+            "channel_echoes":None,
+            "echo_unk_chans":None,
+            "print_path_updates":None,
+            "print_new_contacts":None,
+            "classic_prompt":None,
+            "manual_add_contacts":None,
+            "telemetry_mode_base":None,
+            "telemetry_mode_loc":None,
+            "telemetry_mode_env":None,
+            "advert_loc_policy":None,
+            "auto_update_contacts":None,
+            "multi_acks":None,
+            "max_attempts":None,
+            "max_flood_attempts":None,
+            "flood_after":None,
+            "custom":None,
+        },
+    }
+
+    contact_completion_list = {
+        "contact_info": None,
+        "contact_name": None,
+        "contact_lastmod": None,
+        "export_contact" : None,
+        "share_contact" : None,
+        "upload_contact" : None,
+        "path": None,
+        "disc_path": None,
+        "trace": None,
+        "dtrace": None,
+        "reset_path" : None,
+        "change_path" : None,
+        "change_flags" : None,
+        "req_telemetry" : None,
+        "req_binary" : None,
+        "forget_password" : None,
+    }
+
+    client_completion_list = dict(contact_completion_list)
+    client_completion_list.update({
+        "get" : { "timeout":None, },
+        "set" : { "timeout":None, },
+    })
+
+    repeater_completion_list = dict(contact_completion_list)
+    repeater_completion_list.update({
+        "login" : None,
+        "logout" : None,
+        "req_status" : None,
+        "req_bstatus" : None,
+        "cmd" : None,
+        "ver" : None,
+        "advert" : None,
+        "time" : None,
+        "clock" : {"sync" : None},
+        "reboot" : None,
+        "start ota" : None,
+        "password" : None,
+        "neighbors" : None,
+        "req_acl":None,
+        "setperm":contact_list,
+        "region" : {"get":None, "allowf": None, "denyf": None, "put": None, "remove": None, "save": None, "home": None},
+        "gps" : {"on":None,"off":None,"sync":None,"setloc":None,
+            "advert" : {"none": None, "share": None, "prefs": None},
+        },
+        "sensor": {"list": None, "set": {"gps": None}, "get": {"gps": None}},
+        "get" : {"name" : None,
+            "role":None,
+            "radio" : None,
+            "freq":None,
+            "tx":None,
+            "af" : None,
+            "repeat" : None,
+            "allow.read.only" : None,
+            "flood.advert.interval" : None,
+            "flood.max":None,
+            "advert.interval" : None,
+            "guest.password" : None,
+            "rxdelay": None,
+            "txdelay": None,
+            "direct.tx_delay":None,
+            "public.key":None,
+            "lat" : None,
+            "lon" : None,
+            "telemetry" : None,
+            "status" : None,
+            "timeout" : None,
+            "acl":None,
+            "bridge.enabled":None,
+            "bridge.delay":None,
+            "bridge.source":None,
+            "bridge.baud":None,
+            "bridge.secret":None,
+            "bridge.type":None,
+            },
+        "set" : {"name" : None,
+            "radio" : {",,,":None, "f,bw,sf,cr": None},
+            "freq" : None,
+            "tx" : None,
+            "af": None,
+            "repeat" : {"on": None, "off": None},
+            "flood.advert.interval" : None,
+            "flood.max" : None,
+            "advert.interval" : None,
+            "guest.password" : None,
+            "allow.read.only" : {"on": None, "off": None},
+            "rxdelay" : None,
+            "txdelay": None,
+            "direct.txdelay" : None,
+            "lat" : None,
+            "lon" : None,
+            "timeout" : None,
+            "perm":contact_list,
+            "bridge.enabled":{"on": None, "off": None},
+            "bridge.delay":None,
+            "bridge.source":None,
+            "bridge.baud":None,
+            "bridge.secret":None,
+            },
+        "erase": None,
+        "log" : {"start" : None, "stop" : None, "erase" : None}
+    })
+
+    sensor_completion_list = dict(repeater_completion_list)
+    sensor_completion_list.update({"req_mma":{"begin end":None}})
+    sensor_completion_list["get"].update({ "mma":None, })
+
     if to is None :
-        completion_list.update({
-            "ver" : None,
-            "infos" : None,
-            "advert" : None,
-            "floodadv" : None,
-            "msg" : contact_list,
-            "wait_ack" : None,
-            "time" : None,
-            "clock" : {"sync" : None},
-            "reboot" : None,
-            "card" : None,
-            "upload_card" : None,
-            "contacts": None,
-            "pending_contacts": None,
-            "add_pending": pending_list,
-            "flush_pending": None,
-            "contact_info": contact_list,
-            "export_contact" : contact_list,
-            "upload_contact" : contact_list,
-            "share_contact" : contact_list,
-            "path": contact_list,
-            "disc_path" : contact_list,
-            "trace" : None,
-            "reset_path" : contact_list,
-            "change_path" : contact_list,
-            "change_flags" : contact_list,
-            "remove_contact" : contact_list,
-            "import_contact" : {"meshcore://":None},
-            "reload_contacts" : None,
-            "login" : contact_list,
-            "cmd" : contact_list,
-            "req_status" : contact_list,
-            "req_bstatus" : contact_list,
-            "logout" : contact_list,
-            "req_telemetry" : contact_list,
-            "req_binary" : contact_list,
-            "req_mma" : contact_list,
-            "self_telemetry" : None,
-            "get_channel": None,
-            "set_channel": None,
-            "get_channels": None,
-            "remove_channel": None,
-            "set" : {
-                    "name" : None,
-                    "pin" : None,
-                    "radio" : {",,,":None, "f,bw,sf,cr":None},
-                    "tx" : None,
-                    "tuning" : {",", "af,tx_d"},
-                    "lat" : None,
-                    "lon" : None,
-                    "coords" : 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},
-                    "print_new_contacts" : {"on": None, "off":None},
-                    "print_path_updates" : {"on":None,"off":None},
-                    "classic_prompt" : {"on" : None, "off":None},
-                    "manual_add_contacts" : {"on" : None, "off":None},
-                    "telemetry_mode_base" : {"always" : None, "device":None, "never":None},
-                    "telemetry_mode_loc" : {"always" : None, "device":None, "never":None},
-                    "telemetry_mode_env" : {"always" : None, "device":None, "never":None},
-                    "advert_loc_policy" : {"none" : None, "share" : None},
-                    "auto_update_contacts" : {"on":None, "off":None},
-                    "multi_acks" : {"on": None, "off":None},
-                    "max_attempts" : None,
-                    "max_flood_attempts" : None,
-                    "flood_after" : None,
-                    },
-            "get" : {"name":None,
-                     "bat":None,
-                     "fstats": None,
-                     "radio":None,
-                     "tx":None,
-                     "coords":None,
-                     "lat":None,
-                     "lon":None,
-                     "print_snr":None,
-                     "json_msgs":None,
-                     "color":None,
-                     "print_name":None,
-                     "print_adverts":None,
-                     "print_path_updates":None,
-                     "print_new_contacts":None,
-                     "classic_prompt":None,
-                     "manual_add_contacts":None,
-                     "telemetry_mode_base":None,
-                     "telemetry_mode_loc":None,
-                     "telemetry_mode_env":None,
-                     "advert_loc_policy":None,
-                     "auto_update_contacts":None,
-                     "multi_acks":None,
-                     "max_attempts":None,
-                     "max_flood_attempts":None,
-                     "flood_after":None,
-                     "custom":None,
-                     },
-        })
+        completion_list.update(dict(root_completion_list))
         completion_list["set"].update(make_completion_dict.custom_vars)
         completion_list["get"].update(make_completion_dict.custom_vars)
     else :
         completion_list.update({
             "send" : None,
         })
+        if to['type'] == 1 :
+            completion_list.update(client_completion_list)
+        if to['type'] == 2 or to['type'] == 3 : # repeaters and room servers
+            completion_list.update(repeater_completion_list)
+        if (to['type'] == 4) : #specific to sensors
+            completion_list.update(sensor_completion_list)
 
-        if to['type'] > 0: # contact
-            completion_list.update({
-                "contact_info": None,
-                "export_contact" : None,
-                "share_contact" : None,
-                "upload_contact" : None,
-                "path": None,
-                "disc_path": None,
-                "trace": None,
-                "dtrace": None,
-                "reset_path" : None,
-                "change_path" : None,
-                "change_flags" : None,
-                "req_telemetry" : None,
-                "req_binary" : None,
-            })
+    slash_root_completion_list = {}
+    for k,v in root_completion_list.items():
+        slash_root_completion_list["/"+k]=v
 
-        if to['type'] == 1 :
-            completion_list.update({
-                "get" : {
-                    "timeout":None,
-                },
-                "set" : {
-                    "timeout":None,
-                },
-            })
-
-        if to['type'] > 1 : # repeaters and room servers
-            completion_list.update({
-                "login" : None,
-                "logout" : None,
-                "req_status" : None,
-                "req_bstatus" : None,
-                "cmd" : None,
-                "ver" : None,
-                "advert" : None,
-                "time" : None,
-                "clock" : {"sync" : None},
-                "reboot" : None,
-                "start ota" : None,
-                "password" : None,
-                "neighbors" : None,
-                "req_acl":None,
-                "setperm":contact_list,
-                "gps" : {"on":None,"off":None,"sync":None,"setloc":None, 
-                         "advert" : {"none": None, "share": None, "prefs": None}, 
-                },
-                "sensor": {"list": None, "set": {"gps": None}, "get": {"gps": None}},
-                "get" : {"name" : None,
-                         "role":None,
-                         "radio" : None,
-                         "freq":None,
-                         "tx":None,
-                         "af" : None,
-                         "repeat" : None,
-                         "allow.read.only" : None,
-                         "flood.advert.interval" : None,
-                         "flood.max":None,
-                         "advert.interval" : None,
-                         "guest.password" : None,
-                         "rxdelay": None,
-                         "txdelay": None,
-                         "direct.tx_delay":None,
-                         "public.key":None,
-                         "lat" : None,
-                         "lon" : None,
-                         "telemetry" : None,
-                         "status" : None,
-                         "timeout" : None,
-                         "acl":None,
-                         "bridge.enabled":None,
-                         "bridge.delay":None,
-                         "bridge.source":None,
-                         "bridge.baud":None,
-                         "bridge.secret":None,
-                         "bridge.type":None,
-                         },
-                "set" : {"name" : None,
-                         "radio" : {",,,":None, "f,bw,sf,cr": None},
-                         "freq" : None,
-                         "tx" : None,
-                         "af": None,
-                         "repeat" : {"on": None, "off": None},
-                         "flood.advert.interval" : None,
-                         "flood.max" : None,
-                         "advert.interval" : None,
-                         "guest.password" : None,
-                         "allow.read.only" : {"on": None, "off": None},
-                         "rxdelay" : None,
-                         "txdelay": None,
-                         "direct.txdelay" : None,
-                         "lat" : None,
-                         "lon" : None,
-                         "timeout" : None,
-                         "perm":contact_list,
-                         "bridge.enabled":{"on": None, "off": None},
-                         "bridge.delay":None,
-                         "bridge.source":None,
-                         "bridge.baud":None,
-                         "bridge.secret":None,
-                         },
-                "erase": None,
-                "log" : {"start" : None, "stop" : None, "erase" : None}
-            })
+    completion_list.update(slash_root_completion_list)
 
-        if (to['type'] == 4) : #specific to sensors
-            completion_list.update({
-                "req_mma":{"begin end":None},
-            })
+    slash_contacts_completion_list = {}
+    for k,v in contacts.items():
+        d={}
+        if v["type"] == 1:
+            l = client_completion_list
+        elif v["type"] == 2 or v["type"] == 3:
+            l = repeater_completion_list
+        elif v["type"] == 4:
+            l = sensor_completion_list
+
+        for kk, vv in l.items():
+            d["/" + v["adv_name"] + "/" + kk] = vv
 
-            completion_list["get"].update({
-                "mma":None,
-            })
+        slash_contacts_completion_list.update(d)
 
-            completion_list["set"].update({
-            })
+    completion_list.update(slash_contacts_completion_list)
+
+    slash_chan_completion_list = {}
+    if not channels is None:
+        for c in channels :
+            if c["channel_name"] != "":
+                slash_chan_completion_list["/" + c["channel_name"]] = None
+
+    completion_list.update(slash_chan_completion_list)
 
     completion_list.update({
         "script" : None,
@@ -573,7 +719,8 @@ Line starting with \"$\" or \".\" will issue a meshcli command.
     contact = to
     prev_contact = None
 
-#    await get_contacts(mc, anim=True)
+    scope = await set_scope(mc, "*")
+
     await get_contacts(mc, anim=True)
     await get_channels(mc, anim=True)
     await subscribe_to_msgs(mc, above=True)
@@ -612,6 +759,9 @@ Line starting with \"$\" or \".\" will issue a meshcli command.
 
         last_ack = True
         while True:
+            # reset scope (if changed)
+            scope = await set_scope(mc, scope)
+
             color = process_event_message.color
             classic = interactive_loop.classic or not color
             print_name = interactive_loop.print_name
@@ -621,14 +771,16 @@ Line starting with \"$\" or \".\" will issue a meshcli command.
             else:
                 prompt = f"{ANSI_INVERT}"
 
-            # some possible symbols for prompts 🭬🬛🬗🭬🬛🬃🬗🭬🬛🬃🬗🬏🭀🭋🭨🮋
             if print_name or contact is None :
                 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 classic :
                     prompt = prompt + " > "
                 else :
-                    prompt = prompt + "🭨"
+                    prompt = prompt + f"{ANSI_NORMAL}{ARROW_HEAD}{ANSI_INVERT}"
 
             if not contact is None :
                 if not last_ack:
@@ -649,13 +801,24 @@ Line starting with \"$\" or \".\" will issue a meshcli command.
                     prompt = prompt + f"{ANSI_INVERT}"
 
                 if print_name and not classic :
-                    prompt = prompt + "🭬"
+                    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:
+                        prompt = prompt + f"|*"
+                    else:
+                        prompt = prompt + f"|{scope}"
+                else: # display path to dest or 0 if 0 hop
+                    if contact["out_path_len"] == 0:
+                        prompt = prompt + f"|0"
+                    else:
+                        prompt = prompt + "|" + contact["out_path"]
+
                 if classic :
                     prompt = prompt + f"{ANSI_NORMAL} > "
                 else:
-                    prompt = prompt + f"{ANSI_NORMAL}🭬"
+                    prompt = prompt + f"{ANSI_NORMAL}{ARROW_HEAD}"
 
                 prompt = prompt + f"{ANSI_END}"
 
@@ -665,7 +828,7 @@ Line starting with \"$\" or \".\" will issue a meshcli command.
             session.app.ttimeoutlen = 0.2
             session.app.timeoutlen = 0.2
 
-            completer = NestedCompleter.from_nested_dict(
+            completer = MyNestedCompleter.from_nested_dict(
                             make_completion_dict(mc.contacts,
                                     mc.pending_contacts,
                                     to=contact,
@@ -676,18 +839,91 @@ Line starting with \"$\" or \".\" will issue a meshcli command.
                                               completer=completer,
                                               key_bindings=bindings)
 
+            line = line.strip()
+
             if line == "" : # blank line
                 pass
 
+            elif line.startswith("?") :
+                get_help_for(line[1:], context="chat")
+
             # raw meshcli command as on command line
             elif line.startswith("$") :
-                args = shlex.split(line[1:])
-                await process_cmds(mc, args)
+                try :
+                    args = shlex.split(line[1:])
+                    await process_cmds(mc, args)
+                except ValueError:
+                    logger.error("Error parsing line {line[1:]}")
+
+            elif line.startswith("/scope") or\
+                    line.startswith("scope") and contact is None:
+                if not scope is None:
+                    prev_scope = scope
+                    try:
+                        newscope = line.split(" ", 1)[1]
+                        scope = await set_scope(mc, newscope)
+                    except IndexError:
+                        print(scope)
+
+            elif contact is None and (line.startswith("apply_to ") or line.startswith("at ")) or\
+                 line.startswith("/apply_to ") or line.startswith("/at ") :
+                try:
+                    await apply_command_to_contacts(mc, line.split(" ",2)[1], line.split(" ",2)[2])
+                except IndexError:
+                    logger.error(f"Error with apply_to command parameters")
+
+            elif line.startswith("/") :
+                path = line.split(" ", 1)[0]
+                if path.count("/") == 1:
+                    args = line[1:].split(" ")
+                    dest = args[0]
+                    dest_scope = None
+                    if "%" in dest :
+                        dest_scope = dest.split("%")[-1]
+                        dest = dest[:-len(dest_scope)-1]
+                        await set_scope (mc, dest_scope)
+                    tct = mc.get_contact_by_name(dest)
+                    if len(args)>1 and not tct is None: # a contact, send a message
+                        if tct["type"] == 1 or tct["type"] == 3: # client or room
+                            last_ack = await msg_ack(mc, tct, line.split(" ", 1)[1])
+                        else:
+                            print("Can only send msg to chan, client or room")
+                    else :
+                        ch = await get_channel_by_name(mc, dest)
+                        if len(args)>1 and not ch is None: # a channel, send message
+                            await send_chan_msg(mc, ch["channel_idx"], line.split(" ", 1)[1])
+                        else :
+                            try :
+                                await process_cmds(mc, shlex.split(line[1:]))
+                            except ValueError:
+                                logger.error(f"Error processing line{line[1:]}")
+                else:
+                    cmdline = line[1:].split("/",1)[1]
+                    contact_name = path[1:].split("/",1)[0]
+                    dest_scope = None
+                    if "%" in contact_name:
+                        dest_scope = contact_name.split("%")[-1]
+                        contact_name = contact_name[:-len(dest_scope)-1]
+                        await set_scope (mc, dest_scope)
+                    tct = mc.get_contact_by_name(contact_name)
+                    if tct is None:
+                        print(f"{contact_name} is not a contact")
+                    else:
+                        if not await process_contact_chat_line(mc, tct, cmdline):
+                            if cmdline != "":
+                                if tct["type"] == 1:
+                                    last_ack = await msg_ack(mc, tct, cmdline)
+                                else :
+                                    await process_cmds(mc, ["cmd", tct["adv_name"], cmdline])
 
             elif line.startswith("to ") : # dest
                 dest = line[3:]
                 if dest.startswith("\"") or dest.startswith("\'") : # if name starts with a quote
                     dest = shlex.split(dest)[0] # use shlex.split to get contact name between quotes
+                dest_scope = None
+                if '%' in dest and scope!=None :
+                    dest_scope = dest.split("%")[-1]
+                    dest = dest[:-len(dest_scope)-1]
                 nc = mc.get_contact_by_name(dest)
                 if nc is None:
                     if dest == "public" :
@@ -701,12 +937,14 @@ Line starting with \"$\" or \".\" will issue a meshcli command.
                             nc["adv_name"] = mc.channels[dest]["channel_name"]
                     elif dest == ".." : # previous recipient
                         nc = prev_contact
+                        if dest_scope is None and not scope is None:
+                            dest_scope = prev_scope
                     elif dest == "~" or dest == "/" or dest == mc.self_info['name']:
                         nc = None
                     elif dest == "!" :
                         nc = process_event_message.last_node
                     else :
-                        chan = await get_channel_by_name(mc, dest)            
+                        chan = await get_channel_by_name(mc, dest)
                         if chan is None :
                             print(f"Contact '{dest}' not found in contacts.")
                             nc = contact
@@ -718,6 +956,12 @@ Line starting with \"$\" or \".\" will issue a meshcli command.
                     last_ack = True
                     prev_contact = contact
                     contact = nc
+                if dest_scope is None:
+                    dest_scope = scope
+                if not scope is None and dest_scope != scope:
+                    prev_scope = scope
+                    if not dest_scope is None:
+                        scope = await set_scope(mc, dest_scope)
 
             elif line == "to" :
                 if contact is None :
@@ -740,7 +984,7 @@ Line starting with \"$\" or \".\" will issue a meshcli command.
                 if ln is None :
                     print("No received msg yet !")
                 elif ln["type"] == 0 :
-                    await process_cmds(mc, ["chan", str(contact["chan_nb"]), line]  )
+                    await send_chan_msg(mc, ln["chan_nb"], line[1:])
                 else :
                     last_ack = await msg_ack(mc, ln, line[1:])
                     if last_ack == False :
@@ -748,107 +992,14 @@ Line starting with \"$\" or \".\" will issue a meshcli command.
 
             # commands are passed through if at root
             elif contact is None or line.startswith(".") :
-                args = shlex.split(line)
-                await process_cmds(mc, args)
-
-            # commands that take contact as second arg will be sent to recipient
-            elif contact["type"] > 0 and (line == "sc" or line == "share_contact" or\
-                    line == "ec" or line == "export_contact" or\
-                    line == "uc" or line == "upload_contact" or\
-                    line == "rp" or line == "reset_path" or\
-                    line == "dp" or line == "disc_path" or\
-                    line == "contact_info" or line == "ci" or\
-                    line == "req_status" or line == "rs" or\
-                    line == "req_bstatus" or line == "rbs" or\
-                    line == "req_telemetry" or line == "rt" or\
-                    line == "req_acl" or\
-                    line == "path" or\
-                    line == "logout" ) :
-                args = [line, contact['adv_name']]
-                await process_cmds(mc, args)
-
-            elif contact["type"] > 0 and line.startswith("set timeout "):
-                cmds=line.split(" ")
-                contact["timeout"] = float(cmds[2])
-
-            elif contact["type"] > 0 and line == "get timeout":
-                print(f"timeout: {0 if not 'timeout' in contact else contact['timeout']}")
-
-            elif contact["type"] == 4 and\
-                    (line.startswith("get mma ")) or\
-                 contact["type"] > 1 and\
-                    (line.startswith("get telemetry") or line.startswith("get status") or line.startswith("get acl")):
-                cmds = line.split(" ")
-                args = [f"req_{cmds[1]}", contact['adv_name']]
-                if len(cmds) > 2 :
-                    args = args + cmds[2:]
-                if line.startswith("get mma ") and len(args) < 4:
-                    args.append("0")
-                await process_cmds(mc, args)
-
-            # special treatment for setperm to support contact name as param
-            elif contact["type"] > 1 and\
-                (line.startswith("setperm ") or line.startswith("set perm ")):
                 try:
-                    cmds = shlex.split(line)
-                    off = 1 if line.startswith("set perm") else 0
-                    name = cmds[1 + off]
-                    perm_string = cmds[2 + off]
-                    if (perm_string.startswith("0x")):
-                        perm = int(perm_string,0)
-                    elif (perm_string.startswith("#")):
-                        perm = int(perm_string[1:])
-                    else:
-                        perm = int(perm_string,16)
-                    ct=mc.get_contact_by_name(name)
-                    if ct is None:
-                        ct=mc.get_contact_by_key_prefix(name)
-                    if ct is None:
-                        if name == "self" or mc.self_info["public_key"].startswith(name):
-                            key = mc.self_info["public_key"]
-                        else:
-                            key = name
-                    else:
-                        key=ct["public_key"]
-                    newline=f"setperm {key} {perm}"
-                    await process_cmds(mc, ["cmd", contact["adv_name"], newline])
-                except IndexError:
-                    print("Wrong number of parameters")
-
-            # trace called on a contact
-            elif contact["type"] > 0 and (
-                    line == "trace" or line == "tr") :
-                await print_trace_to(mc, contact)
-
-            elif contact["type"] > 0 and (
-                    line == "dtrace" or line == "dt") :
-                await print_disc_trace_to(mc, contact)
-                
-            # same but for commands with a parameter
-            elif contact["type"] > 0 and (line.startswith("cmd ") or\
-                    line.startswith("cp ") or line.startswith("change_path ") or\
-                    line.startswith("cf ") or line.startswith("change_flags ") or\
-                    line.startswith("req_binary ") or\
-                    line.startswith("login ")) :
-                cmds = line.split(" ", 1)
-                args = [cmds[0], contact['adv_name'], cmds[1]]
-                await process_cmds(mc, args)
-
-            elif contact["type"] == 4 and \
-                (line.startswith("req_mma ") or line.startswith('rm ')) :
-                cmds = line.split(" ")
-                if len(cmds) < 3 :
-                    cmds.append("0")
-                args = [cmds[0], contact['adv_name'], cmds[1], cmds[2]]
-                await process_cmds(mc, args)
+                    args = shlex.split(line)
+                    await process_cmds(mc, args)
+                except ValueError:
+                    logger.error(f"Error processing {line}")
 
-            elif line.startswith(":") : # : will send a command to current recipient
-                args=["cmd", contact['adv_name'], line[1:]]
-                await process_cmds(mc, args)
-
-            elif line == "reset path" : # reset path for compat with terminal chat
-                args = ["reset_path", contact['adv_name']]
-                await process_cmds(mc, args)
+            elif await process_contact_chat_line(mc, contact, line):
+                pass
 
             elif line == "list" : # list command from chat displays contacts on a line
                 it = iter(mc.contacts.items())
@@ -868,7 +1019,7 @@ Line starting with \"$\" or \".\" will issue a meshcli command.
                 last_ack = await msg_ack(mc, contact, line)
 
             elif contact["type"] == 0 : # channel, send msg to channel
-                await process_cmds(mc, ["chan", str(contact["chan_nb"]), line]  )
+                await send_chan_msg(mc, contact["chan_nb"], line)
 
             elif contact["type"] == 1 : # chat, send to recipient and wait ack
                 last_ack = await msg_ack(mc, contact, line)
@@ -886,6 +1037,291 @@ Line starting with \"$\" or \".\" will issue a meshcli command.
 interactive_loop.classic = False
 interactive_loop.print_name = True
 
+async def process_contact_chat_line(mc, contact, line):
+    if contact["type"] == 0:
+        return False
+
+    # if one element in line (most cases) strip the scope and apply it
+    if not " " in line and "%" in line:
+        dest_scope = line.split("%")[-1]
+        line = line[:-len(dest_scope)-1]
+        await set_scope (mc, dest_scope)
+
+    if line.startswith(":") : # : will send a command to current recipient
+        args=["cmd", contact['adv_name'], line[1:]]
+        await process_cmds(mc, args)
+        return True
+
+    if line == "reset path" : # reset path for compat with terminal chat
+        args = ["reset_path", contact['adv_name']]
+        await process_cmds(mc, args)
+        return True
+
+    if line.startswith("contact_name") or line.startswith("cn"):
+        print(contact['adv_name'],end="")
+        if " " in line:
+            print(" ", end="", flush=True)
+            secline = line.split(" ", 1)[1]
+            await process_contact_chat_line(mc, contact, secline)
+        else:
+            print("")
+        return True
+
+    if line == "contact_lastmod":
+        timestamp = contact["lastmod"]
+        print(f"{contact['adv_name']} updated"
+              f" {datetime.datetime.fromtimestamp(timestamp).strftime('%Y-%m-%d at %H:%M:%S')}"
+              f" ({timestamp})")
+        return True
+
+    # commands that take contact as second arg will be sent to recipient
+    if line == "sc" or line == "share_contact" or\
+            line == "ec" or line == "export_contact" or\
+            line == "uc" or line == "upload_contact" or\
+            line == "rp" or line == "reset_path" or\
+            line == "dp" or line == "disc_path" or\
+            line == "contact_info" or line == "ci" or\
+            line == "req_status" or line == "rs" or\
+            line == "req_bstatus" or line == "rbs" or\
+            line == "req_telemetry" or line == "rt" or\
+            line == "req_acl" or\
+            line == "path" or\
+            line == "logout" :
+        args = [line, contact['adv_name']]
+        await process_cmds(mc, args)
+        return True
+
+    # special case for rp that can be chained from cmdline
+    if line.startswith("rp ") or line.startswith("reset_path ") :
+        args = ["rp", contact['adv_name']]
+        await process_cmds(mc, args)
+        secline = line.split(" ", 1)[1]
+        await process_contact_chat_line(mc, contact, secline)
+        return True
+
+    if line.startswith("set timeout "):
+        cmds=line.split(" ")
+        contact["timeout"] = float(cmds[2])
+        return True
+
+    if line == "get timeout":
+        print(f"timeout: {0 if not 'timeout' in contact else contact['timeout']}")
+        return True
+
+    if contact["type"] == 4 and\
+            (line.startswith("get mma ")) or\
+         contact["type"] > 1 and\
+            (line.startswith("get telemetry") or line.startswith("get status") or line.startswith("get acl")):
+        cmds = line.split(" ")
+        args = [f"req_{cmds[1]}", contact['adv_name']]
+        if len(cmds) > 2 :
+            args = args + cmds[2:]
+        if line.startswith("get mma ") and len(args) < 4:
+            args.append("0")
+        await process_cmds(mc, args)
+        return True
+
+    # special treatment for setperm to support contact name as param
+    if contact["type"] > 1 and\
+        (line.startswith("setperm ") or line.startswith("set perm ")):
+        try:
+            cmds = shlex.split(line)
+            off = 1 if line.startswith("set perm") else 0
+            name = cmds[1 + off]
+            perm_string = cmds[2 + off]
+            if (perm_string.startswith("0x")):
+                perm = int(perm_string,0)
+            elif (perm_string.startswith("#")):
+                perm = int(perm_string[1:])
+            else:
+                perm = int(perm_string,16)
+            ct=mc.get_contact_by_name(name)
+            if ct is None:
+                ct=mc.get_contact_by_key_prefix(name)
+            if ct is None:
+                if name == "self" or mc.self_info["public_key"].startswith(name):
+                    key = mc.self_info["public_key"]
+                else:
+                    key = name
+            else:
+                key=ct["public_key"]
+            newline=f"setperm {key} {perm}"
+            await process_cmds(mc, ["cmd", contact["adv_name"], newline])
+        except IndexError:
+            print("Wrong number of parameters")
+        return True
+
+    # trace called on a contact
+    if line == "trace" or line == "tr" :
+        await print_trace_to(mc, contact)
+        return True
+
+    if line == "dtrace" or line == "dt" :
+        await print_disc_trace_to(mc, contact)
+        return True
+
+    # same but for commands with a parameter
+    if " " in line:
+        cmds = line.split(" ", 1)
+        if "%" in cmds[0]:
+            dest_scope = cmds[0].split("%")[-1]
+            cmds[0] = cmds[0][:-len(dest_scope)-1]
+            await set_scope(mc, dest_scope)
+
+        if cmds[0] == "cmd" or cmds[0] == "msg" or\
+                cmds[0] == "cp" or cmds[0] == "change_path" or\
+                cmds[0] == "cf" or cmds[0] == "change_flags" or\
+                cmds[0] == "req_binary" or\
+                cmds[0] == "login" :
+            args = [cmds[0], contact['adv_name'], cmds[1]]
+            await process_cmds(mc, args)
+            return True
+
+    if line == "login": # use stored password or prompt for it
+        password_file = ""
+        password = ""
+        if os.path.isdir(MCCLI_CONFIG_DIR) :
+            # if a password file exists with node name open it and destroy it
+            password_file = MCCLI_CONFIG_DIR + contact['adv_name'] + ".pass"
+            if os.path.exists(password_file) :
+                with open(password_file, "r", encoding="utf-8") as f :
+                    password=f.readline().strip()
+                os.remove(password_file)
+                password_file = MCCLI_CONFIG_DIR + contact["public_key"] + ".pass"
+                with open(password_file, "w", encoding="utf-8") as f :
+                    f.write(password)
+
+            # this is the new correct password file, using pubkey
+            password_file = MCCLI_CONFIG_DIR + contact["public_key"] + ".pass"
+            if os.path.exists(password_file) :
+                with open(password_file, "r", encoding="utf-8") as f :
+                    password=f.readline().strip()
+
+        if password == "":
+            try:
+                sess = PromptSession(f"Password for {contact['adv_name']}: ", is_password=True)
+                password = await sess.prompt_async()
+            except EOFError:
+                logger.info("Canceled")
+                return True
+
+            if password_file != "":
+                with open(password_file, "w", encoding="utf-8") as f :
+                    f.write(password)
+
+        args = ["login", contact['adv_name'], password]
+        await process_cmds(mc, args)
+        return True
+
+    if line.startswith("forget_password") or line.startswith("fp"):
+        password_file = MCCLI_CONFIG_DIR + contact['adv_name'] + ".pass"
+        if os.path.exists(password_file):
+            os.remove(password_file)
+        password_file = MCCLI_CONFIG_DIR + contact['public_key'] + ".pass"
+        if os.path.exists(password_file):
+            os.remove(password_file)
+        try:
+            secline = line.split(" ", 1)[1]
+            await process_contact_chat_line(mc, contact, secline)
+        except IndexError:
+            pass
+        return True
+
+    if contact["type"] == 4 and \
+        (line.startswith("req_mma ") or line.startswith('rm ')) :
+        cmds = line.split(" ")
+        if len(cmds) < 3 :
+            cmds.append("0")
+        args = [cmds[0], contact['adv_name'], cmds[1], cmds[2]]
+        await process_cmds(mc, args)
+        return True
+
+    return False
+
+async def apply_command_to_contacts(mc, contact_filter, line):
+    upd_before = None
+    upd_after = None
+    contact_type = None
+    min_hops = None
+    max_hops = None
+
+    await mc.ensure_contacts()
+
+    filters = contact_filter.split(",")
+    for f in filters:
+        if f == "all":
+            pass
+        elif f[0] == "u": #updated
+            val_str = f[2:]
+            t = time.time()
+            if val_str[-1] == "d": # value in days
+                t = t - float(val_str[0:-1]) * 86400
+            elif val_str[-1] == "h": # value in hours
+                t = t - float(val_str[0:-1]) * 3600
+            elif val_str[-1] == "m": # value in minutes
+                t = t - float(val_str[0:-1]) * 60
+            else:
+                t = int(val_str)
+            if f[1] == "<": #before
+                upd_before = t
+            elif f[1] == ">":
+                upd_after = t
+            else:
+                logger.error(f"Time filter can only be < or >")
+                return
+        elif f[0] == "t": # type
+            if f[1] == "=":
+                contact_type = int(f[2:])
+            else:
+                logger.error(f"Type can only be equals to a value")
+                return
+        elif f[0] == "d": # direct
+            min_hops=0
+        elif f[0] == "f": # flood
+            max_hops=-1
+        elif f[0] == "h": # hop number
+            if f[1] == ">":
+                min_hops = int(f[2:])+1
+            elif f[1] == "<":
+                max_hops = int(f[2:])-1
+            elif f[1] == "=":
+                min_hops = int(f[2:])
+                max_hops = int(f[2:])
+        else:
+            logger.error(f"Unknown filter {f}")
+            return
+
+    for c in dict(mc._contacts).items():
+        contact = c[1]
+        if (contact_type is None or contact["type"] == contact_type) and\
+                (upd_before is None or contact["lastmod"] < upd_before) and\
+                (upd_after is None or contact["lastmod"] > upd_after) and\
+                (min_hops is None or contact["out_path_len"] >= min_hops) and\
+                (max_hops is None or contact["out_path_len"] <= max_hops):
+            if await process_contact_chat_line(mc, contact, line):
+                pass
+
+            elif line == "remove_contact":
+                args = [line, contact['adv_name']]
+                await process_cmds(mc, args)
+
+            elif line.startswith("send") or line.startswith("\"") :
+                if line.startswith("send") :
+                    line = line[5:]
+                if line.startswith("\"") :
+                    line = line[1:]
+                await msg_ack(mc, contact, line)
+
+            elif contact["type"] == 2 or\
+                 contact["type"] == 3 or\
+                 contact["type"] == 4 : # repeater, room, sensor send cmd
+                await process_cmds(mc, ["cmd", contact["adv_name"], line])
+                # wait for a reply from cmd
+                await mc.wait_for_event(EventType.MESSAGES_WAITING, timeout=7)
+
+            else:
+                logger.error(f"Can't send {line} to {contact['adv_name']}")
+
 async def send_cmd (mc, contact, cmd) :
     res = await mc.commands.send_cmd(contact, cmd)
     if not res is None and not res.type == EventType.ERROR:
@@ -909,7 +1345,7 @@ async def send_chan_msg(mc, nb, msg):
         sent["text"] = msg
         sent["txt_type"] = 0
         sent["name"] = mc.self_info['name']
-        await log_message(mc, sent) 
+        await log_message(mc, sent)
     return res
 
 async def send_msg (mc, contact, msg) :
@@ -928,7 +1364,7 @@ async def send_msg (mc, contact, msg) :
 
 async def msg_ack (mc, contact, msg) :
     timeout = 0 if not 'timeout' in contact else contact['timeout']
-    res = await mc.commands.send_msg_with_retry(contact, msg, 
+    res = await mc.commands.send_msg_with_retry(contact, msg,
                 max_attempts=msg_ack.max_attempts,
                 flood_after=msg_ack.flood_after,
                 max_flood_attempts=msg_ack.max_flood_attempts,
@@ -948,6 +1384,28 @@ msg_ack.max_attempts=3
 msg_ack.flood_after=2
 msg_ack.max_flood_attempts=1
 
+async def set_scope (mc, scope) :
+    if not set_scope.has_scope:
+        return None
+
+    if scope == "None" or scope == "0" or scope == "clear" or scope == "":
+        scope = "*"
+
+    if set_scope.current_scope == scope:
+        return scope
+
+    res = await mc.commands.set_flood_scope(scope)
+    if res is None or res.type == EventType.ERROR:
+        if not res is None and res.payload["error_code"] == 1: #unsupported
+            set_scope.has_scope = False
+        return None
+
+    set_scope.current_scope = scope
+
+    return scope
+set_scope.has_scope = True
+set_scope.current_scope = None
+
 async def get_channel (mc, chan) :
     if not chan.isnumeric():
         return await get_channel_by_name(mc, chan)
@@ -984,6 +1442,7 @@ async def set_channel (mc, chan, name, key=None):
         return None
 
     info = res.payload
+    info["channel_hash"] = sha256(info["channel_secret"]).digest()[0:1].hex()
     info["channel_secret"] = info["channel_secret"].hex()
 
     if hasattr(mc,'channels') :
@@ -1002,6 +1461,9 @@ async def get_channel_by_name (mc, name):
     return None
 
 async def get_contacts (mc, anim=False, lastomod=0, timeout=5) :
+    if mc._contacts:
+        return
+
     if anim:
         print("Fetching contacts ", end="", flush=True)
 
@@ -1020,7 +1482,7 @@ async def get_contacts (mc, anim=False, lastomod=0, timeout=5) :
         done, pending = await asyncio.wait(
             futures, timeout=timeout, return_when=asyncio.FIRST_COMPLETED
         )
-    
+
         # Check if any future completed successfully
         if len(done) == 0:
             logger.debug("Timeout while getting contacts")
@@ -1040,7 +1502,7 @@ async def get_contacts (mc, anim=False, lastomod=0, timeout=5) :
                     if anim:
                         if event.type == EventType.CONTACTS:
                             print ((len(event.payload)-contact_nb)*"." + " Done")
-                        else : 
+                        else :
                             print(" Error")
                     for future in pending:
                         future.cancel()
@@ -1069,12 +1531,14 @@ async def get_channels (mc, anim=False) :
         if res.type == EventType.ERROR:
             break
         info = res.payload
+        info["channel_hash"] = sha256(info["channel_secret"]).digest()[0:1].hex()
         info["channel_secret"] = info["channel_secret"].hex()
         mc.channels.append(info)
         ch = ch + 1
         if anim:
             print(".", end="", flush=True)
-    print (" Done")
+    if anim:
+        print (" Done")
     return mc.channels
 
 async def print_trace_to (mc, contact):
@@ -1148,8 +1612,14 @@ 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
     try :
         argnum = 0
+
+        if cmds[0].startswith("?") : # get some help
+            get_help_for(cmds[0][1:], context="line")
+            return cmds[argnum+1:]
+
         if cmds[0].startswith(".") : # override json_output
             json_output = True
             cmd = cmds[0][1:]
@@ -1240,6 +1710,10 @@ async def next_cmd(mc, cmds, json_output=False):
                 else:
                     print("Time set")
 
+            case "apply_to"|"at":
+                argnum = 2
+                await apply_command_to_contacts(mc, cmds[1], cmds[2])
+
             case "set":
                 argnum = 2
                 match cmds[1]:
@@ -1272,6 +1746,10 @@ async def next_cmd(mc, cmds, json_output=False):
                         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 "color" :
                         process_event_message.color = (cmds[2] == "on")
                         if json_output :
@@ -1280,6 +1758,18 @@ async def next_cmd(mc, cmds, json_output=False):
                         process_event_message.print_snr = (cmds[2] == "on")
                         if json_output :
                             print(json.dumps({"cmd" : cmds[1], "param" : cmds[2]}))
+                    case "json_log_rx" :
+                        handle_log_rx.json_log_rx = (cmds[2] == "on")
+                        if json_output :
+                            print(json.dumps({"cmd" : cmds[1], "param" : cmds[2]}))
+                    case "channel_echoes" :
+                        handle_log_rx.channel_echoes = (cmds[2] == "on")
+                        if json_output :
+                            print(json.dumps({"cmd" : cmds[1], "param" : cmds[2]}))
+                    case "echo_unk_chans" :
+                        handle_log_rx.echo_unk_chans = (cmds[2] == "on")
+                        if json_output :
+                            print(json.dumps({"cmd" : cmds[1], "param" : cmds[2]}))
                     case "print_adverts" :
                         handle_advert.print_adverts = (cmds[2] == "on")
                         if json_output :
@@ -1510,6 +2000,21 @@ async def next_cmd(mc, cmds, json_output=False):
                             print(json.dumps({"color" : process_event_message.color}))
                         else:
                             print(f"{'on' if process_event_message.color else 'off'}")
+                    case "json_log_rx":
+                        if json_output :
+                            print(json.dumps({"json_log_rx" : handle_log_rx.json_log_rx}))
+                        else:
+                            print(f"{'on' if handle_log_rx.json_log_rx else 'off'}")
+                    case "channel_echoes":
+                        if json_output :
+                            print(json.dumps({"channel_echoes" : handle_log_rx.channel_echoes}))
+                        else:
+                            print(f"{'on' if handle_log_rx.channel_echoes else 'off'}")
+                    case "echo_unk_chans":
+                        if json_output :
+                            print(json.dumps({"echo_unk_chans" : handle_log_rx.echo_unk_chans}))
+                        else:
+                            print(f"{'on' if handle_log_rx.echo_unk_chans else 'off'}")
                     case "print_adverts":
                         if json_output :
                             print(json.dumps({"print_adverts" : handle_advert.print_adverts}))
@@ -1702,11 +2207,17 @@ async def next_cmd(mc, cmds, json_output=False):
                     res = await set_channel(mc, cmds[1], cmds[2])
                 elif len(cmds[3]) != 32:
                     res = None
-                else: 
+                else:
                     res = await set_channel(mc, cmds[1], cmds[2], bytes.fromhex(cmds[3]))
                 if res is None:
                     print("Error setting channel")
 
+            case "scope":
+                argnum = 1
+                res = await set_scope(mc, cmds[1])
+                if res is None:
+                    print(f"Error while setting scope")
+
             case "remove_channel":
                 argnum = 1
                 res = await set_channel(mc, cmds[1], "", bytes.fromhex(16*"00"))
@@ -1722,8 +2233,8 @@ async def next_cmd(mc, cmds, json_output=False):
             case "msg" | "m" | "{" : # sends to a contact from name
                 argnum = 2
                 dest = None
-                
-                if len(cmds[1]) == 12: # possibly an hex prefix 
+
+                if len(cmds[1]) == 12: # possibly an hex prefix
                     try:
                         dest = bytes.fromhex(cmds[1])
                     except ValueError:
@@ -1773,7 +2284,7 @@ async def next_cmd(mc, cmds, json_output=False):
                 argnum = 2
                 dest = None
 
-                if len(cmds[1]) == 12: # possibly an hex prefix 
+                if len(cmds[1]) == 12: # possibly an hex prefix
                     try:
                         dest = bytes.fromhex(cmds[1])
                     except ValueError:
@@ -1800,11 +2311,18 @@ async def next_cmd(mc, cmds, json_output=False):
 
             case "trace" | "tr":
                 argnum = 1
-                res = await mc.commands.send_trace(path=cmds[1])
+                path = cmds[1]
+                plen = int(len(path)/2)
+                if plen > 1 and path.count(",") == 0:
+                    path = cmds[1][0:2]
+                    for i in range(1, plen):
+                        path = path + "," + cmds[1][2*i:2*i+2]
+
+                res = await mc.commands.send_trace(path=path)
                 if res and res.type != EventType.ERROR:
                     tag= int.from_bytes(res.payload['expected_ack'], byteorder="little")
                     timeout = res.payload["suggested_timeout"] / 1000 * 1.2
-                    ev = await mc.wait_for_event(EventType.TRACE_DATA, 
+                    ev = await mc.wait_for_event(EventType.TRACE_DATA,
                         attribute_filters={"tag": tag},
                         timeout=timeout)
                     if ev is None:
@@ -1839,7 +2357,7 @@ async def next_cmd(mc, cmds, json_output=False):
                                 if classic :
                                     print("→",end="")
                                 else :
-                                    print(f"{ANSI_NORMAL}🭬",end="")
+                                    print(f"{ANSI_NORMAL}{ARROW_HEAD}",end="")
                                 print(ANSI_END, end="")
                                 if "hash" in t:
                                     print(f"[{t['hash']}]",end="")
@@ -1856,7 +2374,12 @@ async def next_cmd(mc, cmds, json_output=False):
                     else:
                         print(f"Unknown contact {cmds[1]}")
                 else:
-                    res = await mc.commands.send_login(contact, cmds[2])
+                    password = cmds[2]
+                    if password == "$":
+                        sess = PromptSession("Password: ", is_password=True)
+                        password = await sess.prompt_async()
+
+                    res = await mc.commands.send_login(contact, password)
                     logger.debug(res)
                     if res.type == EventType.ERROR:
                         if json_output :
@@ -1938,7 +2461,7 @@ async def next_cmd(mc, cmds, json_output=False):
                             print("Timeout waiting telemetry")
                     else :
                         print(json.dumps(res.payload, indent=4))
-        
+
             case "disc_path" | "dp" :
                 argnum = 1
                 await mc.ensure_contacts()
@@ -1959,6 +2482,71 @@ async def next_cmd(mc, cmds, json_output=False):
                             inp = inp if inp != "" else "direct"
                             print(f"Path for {contact['adv_name']}: out {outp}, in {inp}")
 
+            case "node_discover"|"nd" :
+                argnum = 1
+                prefix_only = True
+
+                if len(cmds) == 1:
+                    argnum = 0
+                    types = 0xFF
+                else:
+                    try: # try to decode type as int
+                        types = int(cmds[1])
+                    except ValueError:
+                        if "all" in cmds[1]:
+                            types = 0xFF
+                        else :
+                            types = 0
+                            if "rep" in cmds[1] or "rpt" in cmds[1]:
+                                types = types | 4
+                            if "cli" in cmds[1] or "comp" in cmds[1]:
+                                types = types | 2
+                            if "room" in cmds[1]:
+                                types = types | 8
+                            if "sens" in cmds[1]:
+                                types = types | 16
+
+                    if "full" in cmds[1]:
+                        prefix_only = False
+
+                res = await mc.commands.send_node_discover_req(types, prefix_only=prefix_only)
+                if res is None or res.type == EventType.ERROR:
+                    print("Error sending discover request")
+                else:
+                    exp_tag = res.payload["tag"].to_bytes(4, "little").hex()
+                    dn = []
+                    while True:
+                        r = await mc.wait_for_event(
+                            EventType.DISCOVER_RESPONSE,
+                            attribute_filters={"tag":exp_tag},
+                            timeout = 5
+                        )
+                        if r is None or r.type == EventType.ERROR:
+                            break
+                        else:
+                            dn.append(r.payload)
+
+                    if json_output:
+                        print(json.dumps(dn))
+                    else:
+                        await mc.ensure_contacts()
+                        print(f"Discovered {len(dn)} nodes:")
+                        for n in dn:
+                            name = f"{n['pubkey'][0:2]} {mc.get_contact_by_key_prefix(n['pubkey'])['adv_name']}"
+                            if name is None:
+                                name = n["pubkey"][0:16]
+                            type = f"t:{n['node_type']}"
+                            if n['node_type'] == 1:
+                                type = "CLI"
+                            elif n['node_type'] == 2:
+                                type = "REP"
+                            elif n['node_type'] == 3:
+                                type = "ROOM"
+                            elif n['node_type'] == 4:
+                                type = "SENS"
+
+                            print(f" {name:16} {type:>4} SNR: {n['SNR_in']:6,.2f}->{n['SNR']:6,.2f} RSSI: ->{n['RSSI']:4}")
+
             case "req_btelemetry"|"rbt" :
                 argnum = 1
                 await mc.ensure_contacts()
@@ -2089,6 +2677,13 @@ async def next_cmd(mc, cmds, json_output=False):
             case "add_pending":
                 argnum = 1
                 contact = mc.pop_pending_contact(cmds[1])
+                if contact is None: # try to find by name
+                    key = None
+                    for c in mc.pending_contacts.items():
+                        if c[1]['adv_name'] == cmds[1]:
+                            key = c[1]['public_key']
+                            contact = mc.pop_pending_contact(key)
+                            break
                 if contact is None:
                     if json_output:
                         print(json.dumps({"error":"Contact does not exist"}))
@@ -2368,7 +2963,7 @@ async def next_cmd(mc, cmds, json_output=False):
                     if json_output:
                         await ps.prompt_async()
                     else:
-                        await ps.prompt_async("Press Enter to continue ...")
+                        await ps.prompt_async("Press Enter to continue ...\n")
                 except (EOFError, KeyboardInterrupt, asyncio.CancelledError):
                     pass
 
@@ -2427,7 +3022,7 @@ async def next_cmd(mc, cmds, json_output=False):
                 await mc.ensure_contacts()
                 contact = mc.get_contact_by_name(cmds[0])
                 if contact is None:
-                    logger.error(f"Unknown command : {cmd}, will exit ...")
+                    logger.error(f"Unknown command : {cmd}, {cmds} not executed ...")
                     return None
 
                 await interactive_loop(mc, to=contact)
@@ -2436,7 +3031,10 @@ async def next_cmd(mc, cmds, json_output=False):
         return cmds[argnum+1:]
 
     except IndexError:
-        logger.error("Error in parameters, returning")
+        logger.error("Error in parameters")
+        return None
+    except EOFError:
+        logger.error("Cancelled")
         return None
 
 async def process_cmds (mc, args, json_output=False) :
@@ -2458,14 +3056,18 @@ async def process_script(mc, file, json_output=False):
         line = line.strip()
         if not (line == "" or line[0] == "#"):
             logger.debug(f"processing {line}")
-            cmds = shlex.split(line)
-            await process_cmds(mc, cmds, json_output)
+            try :
+                cmds = shlex.split(line)
+                await process_cmds(mc, cmds, json_output)
+            except ValueError:
+                logger.error(f"Error processing {line}")
 
 def version():
     print (f"meshcore-cli: command line interface to MeshCore companion radios {VERSION}")
 
 def command_help():
-    print("""  General commands
+    print("""    ?<cmd> may give you some more help about cmd
+  General commands
     chat                   : enter the chat (interactive) mode
     chat_to <ct>           : enter chat with contact                to
     script <filename>      : execute commands in filename
@@ -2476,6 +3078,7 @@ 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
     msg <name> <msg>       : send message to node by name           m  {
     wait_ack               : wait an ack                            wa }
@@ -2497,6 +3100,7 @@ def command_help():
     time <epoch>           : sets time to given epoch
     clock                  : get current time
     clock sync             : sync device clock                      st
+    node_discover <filter> : discovers nodes based on their type    nd
   Contacts
     contacts / list        : gets contact list                      lc
     reload_contacts        : force reloading all contacts           rc
@@ -2515,7 +3119,7 @@ def command_help():
     req_mma <ct>           : requests min/max/avg for a sensor      rm
     req_acl <ct>           : requests access control list for sensor
     pending_contacts       : show pending contacts
-    add_pending <key>      : manually add pending contact from key
+    add_pending <pending>  : manually add pending contact
     flush_pending          : flush pending contact list
   Repeaters
     login <name> <pwd>     : log into a node (rep) with given pwd   l
@@ -2550,6 +3154,43 @@ def usage () :
  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 :
+     - 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
+
+    Note: Some commands like contact_name (aka cn), reset_path (aka rp), forget_password (aka fp) can be chained.
+
+    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
+""")
+
+    if 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 :
+     - cli or comp for companions
+     - rep for repeaters
+     - sens for sensors
+     - room for chat rooms
+
+    nd can be used with no filter parameter ... !!! BEWARE WITH CHAINING !!!
+""")
+
+    else:
+        print(f"Sorry, no help yet for {cmdname}")
+
 async def main(argv):
     """ Do the job """
     json_output = JSON
@@ -2568,7 +3209,7 @@ 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:jDhvSlT:P")
+    opts, args = getopt.getopt(argv, "a:d:s:ht:p:b:fjDhvSlT:P")
     for opt, arg in opts :
         match opt:
             case "-d" : # name specified on cmdline
@@ -2598,25 +3239,34 @@ async def main(argv):
             case "-v":
                 version()
                 return
+            case "-f": # connect to first encountered device
+                address = ""
             case "-l" :
                 print("BLE devices:")
-                devices = await BleakScanner.discover(timeout=timeout)
-                if len(devices) == 0:
-                    print(" No ble device found")
-                for d in devices :
-                    if not d.name is None and d.name.startswith("MeshCore-"):
-                        print(f" {d.address}  {d.name}")
+                try :
+                    devices = await BleakScanner.discover(timeout=timeout)
+                    if len(devices) == 0:
+                        print(" No ble device found")
+                    for d in devices :
+                        if not d.name is None and d.name.startswith("MeshCore-"):
+                            print(f" {d.address}  {d.name}")
+                except BleakError:
+                    print(" No BLE HW")
                 print("\nSerial ports:")
                 ports = serial.tools.list_ports.comports()
                 for port, desc, hwid in sorted(ports):
                     print(f" {port:<18} {desc} [{hwid}]")
                 return
             case "-S" :
-                devices = await BleakScanner.discover(timeout=timeout)
                 choices = []
-                for d in devices:
-                    if not d.name is None and d.name.startswith("MeshCore-"):
-                        choices.append(({"type":"ble","device":d}, f"{d.address:<22} {d.name}"))
+
+                try :
+                    devices = await BleakScanner.discover(timeout=timeout)
+                    for d in devices:
+                        if not d.name is None and d.name.startswith("MeshCore-"):
+                            choices.append(({"type":"ble","device":d}, f"{d.address:<22} {d.name}"))
+                except BleakError:
+                    logger.info("No BLE Device")
 
                 ports = serial.tools.list_ports.comports()
                 for port, desc, hwid in sorted(ports):
@@ -2642,7 +3292,7 @@ async def main(argv):
                 else:
                     logger.error("Invalid choice")
                     return
-                    
+
     if (debug==True):
         logger.setLevel(logging.DEBUG)
     elif (json_output) :
@@ -2660,7 +3310,10 @@ async def main(argv):
         elif address and len(address) == 36 and len(address.split("-")) == 5:
             client = BleakClient(address) # mac uses uuid, we'll pass a client
         else:
-            logger.info(f"Scanning BLE for device matching {address}")
+            if address == "":
+                logger.info(f"Searching first MC BLE device")
+            else:
+                logger.info(f"Scanning BLE for device matching {address}")
             devices = await BleakScanner.discover(timeout=timeout)
             found = False
             for d in devices:
@@ -2685,6 +3338,26 @@ async def main(argv):
             mc = await MeshCore.create_ble(address=address, device=device, client=client, debug=debug, only_error=json_output, pin=pin)
         except ConnectionError :
             logger.info("Error while connecting, retrying once ...")
+            if device is None and client is None: # Search for device
+                logger.info(f"Scanning BLE for device matching {address}")
+                devices = await BleakScanner.discover(timeout=timeout)
+                found = False
+                for d in devices:
+                    if not d.name is None and d.name.startswith("MeshCore-") and\
+                            (address is None or address in d.name) :
+                        address=d.address
+                        device=d
+                        logger.info(f"Found device {d.name} {d.address}")
+                        found = True
+                        break
+                    elif d.address == address : # on a mac, address is an uuid
+                        device = d
+                        logger.info(f"Found device {d.name} {d.address}")
+                        found = True
+                        break
+                if not found :
+                    logger.info(f"Couldn't find device {address}")
+                    return
             try :
                 mc = await MeshCore.create_ble(address=address, device=device, client=client, debug=debug, only_error=json_output, pin=pin)
             except ConnectionError :
@@ -2703,10 +3376,12 @@ async def main(argv):
     handle_message.mc = mc # connect meshcore to handle_message
     handle_advert.mc = mc
     handle_path_update.mc = mc
+    handle_log_rx.mc = mc
 
     mc.subscribe(EventType.ADVERTISEMENT, handle_advert)
     mc.subscribe(EventType.PATH_UPDATE, handle_path_update)
     mc.subscribe(EventType.NEW_CONTACT, handle_new_contact)
+    mc.subscribe(EventType.RX_LOG_DATA, handle_log_rx)
 
     mc.auto_update_contacts = True