meshcore-cli 1.3.12__tar.gz → 1.3.16__tar.gz

{meshcore_cli-1.3.12 → meshcore_cli-1.3.16}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: meshcore-cli
-Version: 1.3.12
+Version: 1.3.16
 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

{meshcore_cli-1.3.12 → meshcore_cli-1.3.16}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "meshcore-cli"
-version = "1.3.12"
+version = "1.3.16"
 authors = [
   { name="Florent de Lamotte", email="florent@frizoncorrea.fr" },
 ]

{meshcore_cli-1.3.12 → meshcore_cli-1.3.16}/src/meshcore_cli/meshcore_cli.py

@@ -32,7 +32,7 @@ import re
 from meshcore import MeshCore, EventType, logger
 
 # Version
-VERSION = "v1.3.12"
+VERSION = "v1.3.16"
 
 # default ble address is stored in a config file
 MCCLI_CONFIG_DIR = str(Path.home()) + "/.config/meshcore/"
@@ -1028,7 +1028,7 @@ Some cmds have an help accessible with ?<cmd>. Do ?[Tab] to get a list.
                 if '%' in dest and scope!=None :
                     dest_scope = dest.split("%")[-1]
                     dest = dest[:-len(dest_scope)-1]
-                nc = mc.get_contact_by_name(dest)
+                nc = await get_contact_from_arg(mc, dest)
                 if nc is None:
                     if dest == "public" :
                         nc = {"adv_name" : "public", "type" : 0, "chan_nb" : 0}
@@ -1083,7 +1083,7 @@ Some cmds have an help accessible with ?<cmd>. Do ?[Tab] to get a list.
                         dest_scope = dest.split("%")[-1]
                         dest = dest[:-len(dest_scope)-1]
                         await set_scope (mc, dest_scope)
-                    tct = mc.get_contact_by_name(dest)
+                    tct = await get_contact_from_arg(mc, 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])
@@ -1106,7 +1106,7 @@ Some cmds have an help accessible with ?<cmd>. Do ?[Tab] to get a list.
                         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)
+                    tct = mc.get_contact_from_arg(mc, contact_name)
                     if tct is None:
                         print(f"{contact_name} is not a contact")
                     else:
@@ -1346,9 +1346,7 @@ async def process_contact_chat_line(mc, contact, line):
                 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)
+            ct= await get_contact_from_arg(mc, name)
             if ct is None:
                 if name == "self" or mc.self_info["public_key"].startswith(name):
                     key = mc.self_info["public_key"]
@@ -1847,6 +1845,22 @@ async def print_disc_trace_to (mc, contact):
 
     await next_cmd(mc, ["trace", trace])
 
+
+async def get_contact_from_arg(mc, arg):
+    contact = None
+    await mc.ensure_contacts()
+
+    # first try with key prefix
+    try: # try only if its a valid hex
+        int(arg ,16)
+        contact = mc.get_contact_by_key_prefix(arg)
+    except ValueError:
+        pass
+    if contact is None: # try by name
+        contact = mc.get_contact_by_name(arg)
+
+    return contact
+
 async def next_cmd(mc, cmds, json_output=False):
     """ process next command """
     global ARROW_HEAD, SLASH_START, SLASH_END, INVERT_SLASH
@@ -2497,8 +2511,7 @@ async def next_cmd(mc, cmds, json_output=False):
                         dest = None
 
                 if dest is None:
-                    await mc.ensure_contacts()
-                    dest = mc.get_contact_by_name(cmds[1])
+                    dest = await get_contact_from_arg(mc, cmds[1])
 
                 if dest is None:
                     if json_output :
@@ -2549,8 +2562,7 @@ async def next_cmd(mc, cmds, json_output=False):
                         dest = None
 
                 if dest is None:
-                    await mc.ensure_contacts()
-                    dest = mc.get_contact_by_name(cmds[1])
+                    dest = await get_contact_from_arg(mc, cmds[1])
 
                 if dest is None:
                     if json_output :
@@ -2627,9 +2639,9 @@ async def next_cmd(mc, cmds, json_output=False):
 
             case "login" | "l" :
                 argnum = 2
-                await mc.ensure_contacts()
-                contact = mc.get_contact_by_name(cmds[1])
-                if contact is None:
+                contact = await get_contact_from_arg(mc, cmds[1])
+
+                if contact is None: # still none ? contact not found
                     if json_output :
                         print(json.dumps({"error" : "contact unknown", "name" : cmds[1]}))
                     else:
@@ -2666,42 +2678,57 @@ async def next_cmd(mc, cmds, json_output=False):
 
             case "logout" :
                 argnum = 1
-                await mc.ensure_contacts()
-                contact = mc.get_contact_by_name(cmds[1])
-                res = await mc.commands.send_logout(contact)
-                logger.debug(res)
-                if res.type == EventType.ERROR:
-                    print(f"Error while logout: {res}")
-                elif json_output :
-                    print(json.dumps(res.payload))
+                contact = await get_contact_from_arg(mc, cmds[1])
+                if contact is None:
+                    if json_output :
+                        print(json.dumps({"error" : "unknown contact"}))
+                    else:
+                        print(f"Unknown contact {cmds[1]}")
                 else:
-                    print("Logout ok")
-
+                    res = await mc.commands.send_logout(contact)
+                    logger.debug(res)
+                    if res.type == EventType.ERROR:
+                        print(f"Error while logout: {res}")
+                    elif json_output :
+                        print(json.dumps(res.payload))
+                    else:
+                        print("Logout ok")
+    
             case "contact_timeout" :
                 argnum = 2
-                await mc.ensure_contacts()
-                contact = mc.get_contact_by_name(cmds[1])
-                contact["timeout"] = float(cmds[2])
+                contact = await get_contact_from_arg(mc, cmds[1])
+                if contact is None:
+                    if json_output :
+                        print(json.dumps({"error" : "unknown contact"}))
+                    else:
+                        print(f"Unknown contact {cmds[1]}")
+                else:
+                    contact["timeout"] = float(cmds[2])
 
             case "disc_path" | "dp" :
                 argnum = 1
-                await mc.ensure_contacts()
-                contact = mc.get_contact_by_name(cmds[1])
-                res = await discover_path(mc, contact)
-                if res is None:
-                    print(f"Error while discovering path")
-                else:
+                contact = await get_contact_from_arg(mc, cmds[1])
+                if contact is None:
                     if json_output :
-                        print(json.dumps(res, indent=4))
+                        print(json.dumps({"error" : "unknown contact"}))
                     else:
-                        if "error" in res :
-                            print("Timeout while discovering path")
+                        print(f"Unknown contact {cmds[1]}")
+                else:
+                    res = await discover_path(mc, contact)
+                    if res is None:
+                        print(f"Error while discovering path")
+                    else:
+                        if json_output :
+                            print(json.dumps(res, indent=4))
                         else:
-                            outp = res['out_path']
-                            outp = outp if outp != "" else "direct"
-                            inp = res['in_path']
-                            inp = inp if inp != "" else "direct"
-                            print(f"Path for {contact['adv_name']}: out {outp}, in {inp}")
+                            if "error" in res :
+                                print("Timeout while discovering path")
+                            else:
+                                outp = res['out_path']
+                                outp = outp if outp != "" else "direct"
+                                inp = res['in_path']
+                                inp = inp if inp != "" else "direct"
+                                print(f"Path for {contact['adv_name']}: out {outp}, in {inp}")
 
             case "node_discover"|"nd" :
                 argnum = 1
@@ -2767,143 +2794,174 @@ async def next_cmd(mc, cmds, json_output=False):
             case "req_telemetry"|"rt" :
                 argnum = 1
                 await mc.ensure_contacts()
-                contact = mc.get_contact_by_name(cmds[1])
-                timeout = 0 if not "timeout" in contact else contact["timeout"]
-                res = await mc.commands.req_telemetry_sync(contact, timeout)
-                if res is None :
+                contact = await get_contact_from_arg(mc, cmds[1])
+                if contact is None:
                     if json_output :
-                        print(json.dumps({"error" : "Getting data"}))
+                        print(json.dumps({"error" : "unknown contact"}))
                     else:
-                        print("Error getting data")
-                else :
-                    print(json.dumps({
-                        "name": contact["adv_name"],
-                        "pubkey_pre": contact["public_key"][0:16],
-                        "lpp": res,
-                    }, indent = 4))
+                        print(f"Unknown contact {cmds[1]}")
+                else:
+                    timeout = 0 if not "timeout" in contact else contact["timeout"]
+                    res = await mc.commands.req_telemetry_sync(contact, timeout)
+                    if res is None :
+                        if json_output :
+                            print(json.dumps({"error" : "Getting data"}))
+                        else:
+                            print("Error getting data")
+                    else :
+                        print(json.dumps({
+                            "name": contact["adv_name"],
+                            "pubkey_pre": contact["public_key"][0:16],
+                            "lpp": res,
+                        }, indent = 4))
 
             case "req_status"|"rs" :
                 argnum = 1
-                await mc.ensure_contacts()
-                contact = mc.get_contact_by_name(cmds[1])
-                timeout = 0 if not "timeout" in contact else contact["timeout"]
-                res = await mc.commands.req_status_sync(contact, timeout)
-                if res is None :
+                contact = await get_contact_from_arg(mc, cmds[1])
+                if contact is None:
                     if json_output :
-                        print(json.dumps({"error" : "Getting data"}))
+                        print(json.dumps({"error" : "unknown contact"}))
                     else:
-                        print("Error getting data")
-                else :
-                    print(json.dumps(res, indent=4))
+                        print(f"Unknown contact {cmds[1]}")
+                else:
+                    timeout = 0 if not "timeout" in contact else contact["timeout"]
+                    res = await mc.commands.req_status_sync(contact, timeout)
+                    if res is None :
+                        if json_output :
+                            print(json.dumps({"error" : "Getting data"}))
+                        else:
+                            print("Error getting data")
+                    else :
+                        print(json.dumps(res, indent=4))
 
             case "req_mma" | "rm":
                 argnum = 3
                 await mc.ensure_contacts()
-                contact = mc.get_contact_by_name(cmds[1])
-                if cmds[2][-1] == "s":
-                    from_secs = int(cmds[2][0:-1])
-                elif cmds[2][-1] == "m":
-                    from_secs = int(cmds[2][0:-1]) * 60
-                elif cmds[2][-1] == "h":
-                    from_secs = int(cmds[2][0:-1]) * 3600
-                else :
-                    from_secs = int(cmds[2]) * 60 # same as tdeck
-                if cmds[3][-1] == "s":
-                    to_secs = int(cmds[3][0:-1])
-                elif cmds[3][-1] == "m":
-                    to_secs = int(cmds[3][0:-1]) * 60
-                elif cmds[3][-1] == "h":
-                    to_secs = int(cmds[3][0:-1]) * 3600
-                else :
-                    to_secs = int(cmds[3]) * 60
-                timeout = 0 if not "timeout" in contact else contact["timeout"]
-                res = await mc.commands.req_mma_sync(contact, from_secs, to_secs, timeout)
-                if res is None :
+                contact = await get_contact_from_arg(mc, cmds[1])
+                if contact is None:
                     if json_output :
-                        print(json.dumps({"error" : "Getting data"}))
+                        print(json.dumps({"error" : "unknown contact"}))
                     else:
-                        print("Error getting data")
-                else :
-                    print(json.dumps(res, indent=4))
+                        print(f"Unknown contact {cmds[1]}")
+                else:
+                    if cmds[2][-1] == "s":
+                        from_secs = int(cmds[2][0:-1])
+                    elif cmds[2][-1] == "m":
+                        from_secs = int(cmds[2][0:-1]) * 60
+                    elif cmds[2][-1] == "h":
+                        from_secs = int(cmds[2][0:-1]) * 3600
+                    else :
+                        from_secs = int(cmds[2]) * 60 # same as tdeck
+                    if cmds[3][-1] == "s":
+                        to_secs = int(cmds[3][0:-1])
+                    elif cmds[3][-1] == "m":
+                        to_secs = int(cmds[3][0:-1]) * 60
+                    elif cmds[3][-1] == "h":
+                        to_secs = int(cmds[3][0:-1]) * 3600
+                    else :
+                        to_secs = int(cmds[3]) * 60
+                    timeout = 0 if not "timeout" in contact else contact["timeout"]
+                    res = await mc.commands.req_mma_sync(contact, from_secs, to_secs, timeout)
+                    if res is None :
+                        if json_output :
+                            print(json.dumps({"error" : "Getting data"}))
+                        else:
+                            print("Error getting data")
+                    else :
+                        print(json.dumps(res, indent=4))
 
             case "req_acl" :
                 argnum = 1
-                await mc.ensure_contacts()
-                contact = mc.get_contact_by_name(cmds[1])
-                timeout = 0 if not "timeout" in contact else contact["timeout"]
-                res = await mc.commands.req_acl_sync(contact, timeout)
-                if res is None :
+                contact = await get_contact_from_arg(mc, cmds[1])
+                if contact is None:
                     if json_output :
-                        print(json.dumps({"error" : "Getting data"}))
+                        print(json.dumps({"error" : "unknown contact"}))
                     else:
-                        print("Error getting data")
-                else :
-                    if json_output:
-                        print(json.dumps(res, indent=4))
-                    else:
-                        for e in res:
-                            name = e['key']
-                            ct = mc.get_contact_by_key_prefix(e['key'])
-                            if ct is None:
-                                if mc.self_info["public_key"].startswith(e['key']):
-                                    name = f"{'self':<20} [{e['key']}]"
-                            else:
-                                name = f"{ct['adv_name']:<20} [{e['key']}]"
-                            print(f"{name:{' '}<35}: {e['perm']:02x}")
+                        print(f"Unknown contact {cmds[1]}")
+                else:
+                    timeout = 0 if not "timeout" in contact else contact["timeout"]
+                    res = await mc.commands.req_acl_sync(contact, timeout)
+                    if res is None :
+                        if json_output :
+                            print(json.dumps({"error" : "Getting data"}))
+                        else:
+                            print("Error getting data")
+                    else :
+                        if json_output:
+                            print(json.dumps(res, indent=4))
+                        else:
+                            for e in res:
+                                name = e['key']
+                                ct = mc.get_contact_by_key_prefix(e['key'])
+                                if ct is None:
+                                    if mc.self_info["public_key"].startswith(e['key']):
+                                        name = f"{'self':<20} [{e['key']}]"
+                                else:
+                                    name = f"{ct['adv_name']:<20} [{e['key']}]"
+                                print(f"{name:{' '}<35}: {e['perm']:02x}")
 
             case "req_neighbours"|"rn" :
                 argnum = 1
-                await mc.ensure_contacts()
-                contact = mc.get_contact_by_name(cmds[1])
-                timeout = 0 if not "timeout" in contact else contact["timeout"]
-                res = await mc.commands.fetch_all_neighbours(contact, timeout=timeout)
-                if res is None :
+                contact = await get_contact_from_arg(mc, cmds[1])
+                if contact is None:
                     if json_output :
-                        print(json.dumps({"error" : "Getting data"}))
-                    else:
-                        print("Error getting data")
-                else :
-                    if json_output:
-                        print(json.dumps(res, indent=4))
+                        print(json.dumps({"error" : "unknown contact"}))
                     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 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']}]"
-
-                            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 ''}")
+                        print(f"Unknown contact {cmds[1]}")
+                else:
+                    timeout = 0 if not "timeout" in contact else contact["timeout"]
+                    res = await mc.commands.fetch_all_neighbours(contact, timeout=timeout)
+                    if res is None :
+                        if json_output :
+                            print(json.dumps({"error" : "Getting data"}))
+                        else:
+                            print("Error getting data")
+                    else :
+                        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 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']}]"
+    
+                                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
-                await mc.ensure_contacts()
-                contact = mc.get_contact_by_name(cmds[1])
-                timeout = 0 if not "timeout" in contact else contact["timeout"]
-                res = await mc.commands.req_binary(contact, bytes.fromhex(cmds[2]), timeout)
-                if res is None :
+                contact = await get_contact_from_arg(mc, cmds[1])
+                if contact is None:
                     if json_output :
-                        print(json.dumps({"error" : "Getting binary data"}))
+                        print(json.dumps({"error" : "unknown contact"}))
                     else:
-                        print("Error getting binary data")
-                else :
-                    print(json.dumps(res))
+                        print(f"Unknown contact {cmds[1]}")
+                else:
+                    timeout = 0 if not "timeout" in contact else contact["timeout"]
+                    res = await mc.commands.req_binary(contact, bytes.fromhex(cmds[2]), timeout)
+                    if res is None :
+                        if json_output :
+                            print(json.dumps({"error" : "Getting binary data"}))
+                        else:
+                            print("Error getting binary data")
+                    else :
+                        print(json.dumps(res))
 
             case "contacts" | "list" | "lc":
                 await mc.ensure_contacts(follow=True)
@@ -2968,8 +3026,7 @@ async def next_cmd(mc, cmds, json_output=False):
 
             case "path":
                 argnum = 1
-                res = await mc.ensure_contacts(follow=True)
-                contact = mc.get_contact_by_name(cmds[1])
+                contact = await get_contact_from_arg(mc, cmds[1])
                 if contact is None:
                     if json_output :
                         print(json.dumps({"error" : "contact unknown", "name" : cmds[1]}))
@@ -2993,7 +3050,7 @@ async def next_cmd(mc, cmds, json_output=False):
             case "contact_info" | "ci":
                 argnum = 1
                 res = await mc.ensure_contacts(follow=True)
-                contact = mc.get_contact_by_name(cmds[1])
+                contact = await get_contact_from_arg(mc, cmds[1])
                 if contact is None:
                     if json_output :
                         print(json.dumps({"error" : "contact unknown", "name" : cmds[1]}))
@@ -3004,8 +3061,7 @@ async def next_cmd(mc, cmds, json_output=False):
 
             case "change_path" | "cp":
                 argnum = 2
-                await mc.ensure_contacts()
-                contact = mc.get_contact_by_name(cmds[1])
+                contact = await get_contact_from_arg(mc, cmds[1])
                 if contact is None:
                     if json_output :
                         print(json.dumps({"error" : "contact unknown", "name" : cmds[1]}))
@@ -3027,8 +3083,7 @@ async def next_cmd(mc, cmds, json_output=False):
 
             case "change_flags" | "cf":
                 argnum = 2
-                await mc.ensure_contacts()
-                contact = mc.get_contact_by_name(cmds[1])
+                contact = await get_contact_from_arg(mc, cmds[1])
                 if contact is None:
                     if json_output :
                         print(json.dumps({"error" : "contact unknown", "name" : cmds[1]}))
@@ -3044,8 +3099,7 @@ async def next_cmd(mc, cmds, json_output=False):
 
             case "reset_path" | "rp" :
                 argnum = 1
-                await mc.ensure_contacts()
-                contact = mc.get_contact_by_name(cmds[1])
+                contact = await get_contact_from_arg(mc, cmds[1])
                 if contact is None:
                     if json_output :
                         print(json.dumps({"error" : "contact unknown", "name" : cmds[1]}))
@@ -3064,8 +3118,7 @@ async def next_cmd(mc, cmds, json_output=False):
 
             case "share_contact" | "sc":
                 argnum = 1
-                await mc.ensure_contacts()
-                contact = mc.get_contact_by_name(cmds[1])
+                contact = await get_contact_from_arg(mc, cmds[1])
                 if contact is None:
                     if json_output :
                         print(json.dumps({"error" : "contact unknown", "name" : cmds[1]}))
@@ -3081,8 +3134,7 @@ async def next_cmd(mc, cmds, json_output=False):
 
             case "export_contact"|"ec":
                 argnum = 1
-                await mc.ensure_contacts()
-                contact = mc.get_contact_by_name(cmds[1])
+                contact = await get_contact_from_arg(mc, cmds[1])
                 if contact is None:
                     if json_output :
                         print(json.dumps({"error" : "contact unknown", "name" : cmds[1]}))
@@ -3112,8 +3164,7 @@ async def next_cmd(mc, cmds, json_output=False):
 
             case "upload_contact" | "uc" :
                 argnum = 1
-                await mc.ensure_contacts()
-                contact = mc.get_contact_by_name(cmds[1])
+                contact = await get_contact_from_arg(mc, cmds[1])
                 if contact is None:
                     if json_output :
                         print(json.dumps({"error" : "contact unknown", "name" : cmds[1]}))
@@ -3157,7 +3208,6 @@ async def next_cmd(mc, cmds, json_output=False):
 
             case "remove_contact" :
                 argnum = 1
-                await mc.ensure_contacts()
                 contact = mc.get_contact_by_name(cmds[1])
                 if contact is None:
                     if json_output :
@@ -3279,8 +3329,7 @@ async def next_cmd(mc, cmds, json_output=False):
 
             case "chat_to" | "imto" | "to" :
                 argnum = 1
-                await mc.ensure_contacts()
-                contact = mc.get_contact_by_name(cmds[1])
+                contact = await get_contact_from_arg(mc, cmds[1])
                 await interactive_loop(mc, to=contact)
 
             case "script" :
@@ -3288,8 +3337,7 @@ async def next_cmd(mc, cmds, json_output=False):
                 await process_script(mc, cmds[1], json_output=json_output)
 
             case _ :
-                await mc.ensure_contacts()
-                contact = mc.get_contact_by_name(cmds[0])
+                contact = await get_contact_from_arg(mc, cmds[0])
                 if contact is None:
                     logger.error(f"Unknown command : {cmd}, {cmds} not executed ...")
                     return None
@@ -3429,6 +3477,7 @@ def command_usage() :
     -b <baudrate>   : specify baudrate
     -C              : toggles classic mode for prompt
     -c <on/off>     : disables most of color output if off
+    -r              : repeater mode (raw text CLI, use with -s)
 """)
 
 def get_help_for (cmdname, context="line") :
@@ -3588,6 +3637,230 @@ To remove a channel, use remove_channel, either with channel name or number.
     else:
         print(f"Sorry, no help yet for {cmdname}")
 
+# Repeater mode history file
+MCCLI_REPEATER_HISTORY_FILE = MCCLI_CONFIG_DIR + "repeater_history"
+
+# Repeater command completion dictionary
+REPEATER_COMMANDS = {
+    "ver": None,
+    "board": None,
+    "reboot": None,
+    "advert": None,
+    "clock": {"sync": None},
+    "time": None,
+    "neighbors": None,
+    "stats-core": None,
+    "stats-radio": None,
+    "stats-packets": None,
+    "clear": {"stats": None},
+    "log": {"start": None, "stop": None, "erase": None},
+    "get": {
+        "name": None, "radio": None, "tx": None, "freq": None,
+        "public.key": None, "prv.key": None, "repeat": None, "role": None,
+        "lat": None, "lon": None, "af": None,
+        "rxdelay": None, "txdelay": None, "direct.txdelay": None,
+        "flood.max": None, "flood.advert.interval": None,
+        "advert.interval": None, "guest.password": None,
+        "allow.read.only": None, "multi.acks": None,
+        "int.thresh": None, "agc.reset.interval": None,
+        "bridge.enabled": None, "bridge.delay": None,
+        "bridge.source": None, "bridge.baud": None,
+        "bridge.channel": None, "bridge.secret": None, "bridge.type": None,
+        "adc.multiplier": None, "acl": None,
+    },
+    "set": {
+        "name": None, "radio": None, "tx": None, "freq": None,
+        "prv.key": None, "repeat": {"on": None, "off": None},
+        "lat": None, "lon": None, "af": None,
+        "rxdelay": None, "txdelay": None, "direct.txdelay": None,
+        "flood.max": None, "flood.advert.interval": None,
+        "advert.interval": None, "guest.password": None,
+        "allow.read.only": {"on": None, "off": None},
+        "multi.acks": None, "int.thresh": None, "agc.reset.interval": None,
+        "bridge.enabled": {"on": None, "off": None},
+        "bridge.delay": None, "bridge.source": None,
+        "bridge.baud": None, "bridge.channel": None, "bridge.secret": None,
+        "adc.multiplier": None,
+    },
+    "password": None,
+    "erase": None,
+    "gps": {"on": None, "off": None, "sync": None, "setloc": None, "advert": {"none": None, "share": None, "prefs": None}},
+    "sensor": {"list": None, "get": None, "set": None},
+    "region": {"get": None, "put": None, "remove": None, "save": None, "load": None, "home": None, "allowf": None, "denyf": None},
+    "setperm": None,
+    "tempradio": None,
+    "neighbor.remove": None,
+    "quit": None,
+    "q": None,
+    "help": None,
+}
+
+REPEATER_HELP = f"""
+{ANSI_BCYAN}Repeater CLI Commands:{ANSI_END}
+
+{ANSI_BGREEN}Info:{ANSI_END}
+  ver                 - Firmware version
+  board               - Board name
+  clock               - Show current time
+
+{ANSI_BGREEN}Stats:{ANSI_END}
+  stats-core          - Core stats (uptime, battery, queue)
+  stats-radio         - Radio stats (RSSI, SNR, noise floor)
+  stats-packets       - Packet statistics (sent/recv counts)
+  clear stats         - Reset all statistics
+
+{ANSI_BGREEN}Network:{ANSI_END}
+  neighbors           - Show neighboring repeaters (zero-hop)
+  advert              - Send advertisement now
+
+{ANSI_BGREEN}Logging:{ANSI_END}
+  log start           - Enable packet logging
+  log stop            - Disable packet logging
+  log                 - Dump log file to console
+  log erase           - Erase log file
+
+{ANSI_BGREEN}Configuration (get/set):{ANSI_END}
+  get name            - Node name
+  get radio           - Radio params (freq,bw,sf,cr)
+  get tx              - TX power (dBm)
+  get repeat          - Repeat mode on/off
+  get public.key      - Node public key
+  get advert.interval - Advertisement interval (minutes)
+
+  set name <name>     - Set node name
+  set tx <power>      - Set TX power (dBm)
+  set repeat on|off   - Enable/disable repeating
+  set radio f,bw,sf,cr - Set radio params (reboot to apply)
+  set advert.interval <min> - Set advert interval (60-240 min)
+
+{ANSI_BGREEN}System:{ANSI_END}
+  reboot              - Reboot device
+  erase               - Erase filesystem (serial only)
+
+{ANSI_BYELLOW}Type 'quit' or 'q' to exit, Ctrl+C to abort{ANSI_END}
+"""
+
+async def repeater_loop(port, baudrate):
+    """Interactive loop for repeater text CLI (raw serial commands)"""
+    import serial as pyserial
+
+    print(f"{ANSI_BCYAN}Connecting to repeater at {port} ({baudrate} baud)...{ANSI_END}")
+    try:
+        ser = pyserial.Serial(port, baudrate, timeout=1)
+    except PermissionError:
+        print(f"{ANSI_BRED}Error: Permission denied. Try running with sudo or add user to dialout group.{ANSI_END}")
+        return
+    except Exception as e:
+        print(f"{ANSI_BRED}Error opening serial port: {e}{ANSI_END}")
+        return
+
+    await asyncio.sleep(0.5)  # Wait for connection to stabilize
+    ser.reset_input_buffer()
+
+    # Send initial CR to wake up CLI
+    ser.write(b"\r")
+    await asyncio.sleep(0.2)
+    ser.reset_input_buffer()
+
+    # Try to get device info
+    ser.write(b"ver\r")
+    await asyncio.sleep(0.3)
+    ver_response = ser.read(ser.in_waiting or 256).decode(errors='ignore').strip()
+    device_name = "Repeater"
+    for line in ver_response.split('\n'):
+        line = line.strip()
+        if line and not line.startswith("ver") and ">" not in line[:3]:
+            device_name = line.split('(')[0].strip() if '(' in line else line
+            break
+
+    print(f"{ANSI_BGREEN}Connected!{ANSI_END} Device: {ANSI_BMAGENTA}{device_name}{ANSI_END}")
+    print(f"Type {ANSI_BCYAN}help{ANSI_END} for commands, {ANSI_BCYAN}quit{ANSI_END} to exit, {ANSI_BCYAN}Tab{ANSI_END} for completion")
+    print("-" * 50)
+
+    # Setup history and session
+    try:
+        if os.path.isdir(MCCLI_CONFIG_DIR):
+            our_history = FileHistory(MCCLI_REPEATER_HISTORY_FILE)
+        else:
+            our_history = None
+    except Exception:
+        our_history = None
+
+    session = PromptSession(
+        history=our_history,
+        wrap_lines=False,
+        mouse_support=False,
+        complete_style=CompleteStyle.MULTI_COLUMN
+    )
+
+    # Setup key bindings
+    bindings = KeyBindings()
+
+    @bindings.add("escape")
+    def _(event):
+        event.app.current_buffer.cancel_completion()
+
+    # Build prompt
+    prompt_base = f"{ANSI_BGRAY}{device_name}{ANSI_MAGENTA}>{ANSI_END} "
+
+    # Setup completer
+    completer = NestedCompleter.from_nested_dict(REPEATER_COMMANDS)
+
+    while True:
+        try:
+            cmd = await session.prompt_async(
+                ANSI(prompt_base),
+                completer=completer,
+                complete_while_typing=False,
+                key_bindings=bindings
+            )
+        except (KeyboardInterrupt, EOFError):
+            break
+
+        cmd = cmd.strip()
+
+        if not cmd:
+            continue
+
+        if cmd.lower() in ("quit", "exit", "q"):
+            break
+
+        if cmd.lower() == "help":
+            print(REPEATER_HELP)
+            continue
+
+        if cmd.lower() == "clock sync" or cmd.lower() == "st" or cmd.lower() == "sync_time":
+            cur_time = int(time.time())
+            print(f'{ANSI_GREEN}Syncing clock to'
+                  f' {datetime.datetime.fromtimestamp(cur_time).strftime("%Y-%m-%d %H:%M:%S")}'
+                  f' ({cur_time}){ANSI_END}')
+            cmd = f"time {cur_time}"
+
+        # Send command with CR terminator
+        ser.write(f"{cmd}\r".encode())
+        await asyncio.sleep(0.3)
+
+        # Read response
+        response = ser.read(ser.in_waiting or 4096).decode(errors='ignore')
+        if response:
+            # Clean up echo and format response
+            lines = response.strip().split('\n')
+            for line in lines:
+                line = line.strip()
+                if line and line != cmd:  # Skip echo of command
+                    # Color code certain responses
+                    if line.startswith("OK") or line.startswith("ok"):
+                        print(f"{ANSI_GREEN}{line}{ANSI_END}")
+                    elif line.startswith("Error") or line.startswith("ERR"):
+                        print(f"{ANSI_RED}{line}{ANSI_END}")
+                    elif line.startswith("->"):
+                        print(f"{ANSI_CYAN}{line}{ANSI_END}")
+                    else:
+                        print(line)
+
+    ser.close()
+    print(f"\n{ANSI_BGRAY}Disconnected from repeater.{ANSI_END}")
+
 async def main(argv):
     """ Do the job """
     json_output = JSON
@@ -3598,6 +3871,7 @@ async def main(argv):
     hostname = None
     serial_port = None
     baudrate = 115200
+    repeater_mode = False
     timeout = 2
     pin = None
     first_device = False
@@ -3608,7 +3882,7 @@ async def main(argv):
             address = f.readline().strip()
 
     try:
-        opts, args = getopt.getopt(argv, "a:d:s:ht:p:b:fjDhvSlT:Pc:C")
+        opts, args = getopt.getopt(argv, "a:d:s:ht:p:b:fjDhvSlT:Pc:Cr")
     except getopt.GetoptError:
         print("Unrecognized option, use -h to get more help")
         command_usage()
@@ -3620,6 +3894,8 @@ async def main(argv):
                     process_event_message.color = False
             case "-C":
                 interactive_loop.classic = not interactive_loop.classic
+            case "-r":  # repeater mode (raw text CLI)
+                repeater_mode = True
             case "-d" : # name specified on cmdline
                 address = arg
             case "-a" : # address specified on cmdline
@@ -3707,6 +3983,15 @@ async def main(argv):
     elif (json_output) :
         logger.setLevel(logging.ERROR)
 
+    # Repeater mode - raw text CLI over serial
+    if repeater_mode:
+        if serial_port is None:
+            print("Error: Repeater mode (-r) requires serial port (-s)")
+            command_usage()
+            return
+        await repeater_loop(serial_port, baudrate)
+        return
+
     mc = None
     if not hostname is None : # connect via tcp
         mc = await MeshCore.create_tcp(host=hostname, port=port, debug=debug, only_error=json_output)