micrOSDevToolKit 2.9.1__py3-none-any.whl → 2.26.1__py3-none-any.whl

micrOS/source/Server.py

@@ -13,7 +13,7 @@ Designed by Marcell Ban aka BxNxM GitHub
 import uasyncio as asyncio
 from utime import ticks_ms, ticks_diff
 from Config import cfgget
-from Debug import console_write, errlog_add
+from Debug import console_write, syslog
 from Network import ifconfig
 from Tasks import Manager
 from Shell import Shell
@@ -27,11 +27,20 @@ except:
 if cfgget('webui'):
     from Web import WebEngine
 else:
-    # Create dummy web engine - Laizy loading
+    # Create dummy web engine - Lazy loading
     class WebEngine:
         __slots__ = []
         def __init__(self, *args, **kwargs):
             pass
+        @staticmethod
+        def register(*args, **kwargs) -> None:
+            """Child class can implement"""
+            syslog(f"[WARN] webui disabled, skip register: {kwargs.get('endpoint')}")
+        @staticmethod
+        def web_mounts(*args, **kwargs) -> dict:
+            """Child class can implement"""
+            syslog(f"[WARN] webui disabled, skip web_mounts: {kwargs.get('endpoint')}")
+            return {}
 
 #########################################################
 #         SOCKET SERVER-CLIENT HANDLER CLASSES          #
@@ -63,19 +72,25 @@ class Client:
         console_write("|" + "-" * Client.INDENT + msg)
         Client.INDENT += 1 if Client.INDENT < 50 else 0       # Auto indent
 
-    async def read(self):
+    async def read(self, decoding='utf8', timeout_seconds=0):
         """
         [Base] Implements client read function, reader size: 2048
-        - set timeout counter
-        - read input from client (run: return False)
-        - connection error handling (stop: return True)
-        - exit command handling (stop: return True)
+        :return tuple: read_error, data
+        - read_error is set to true upon timeout or other exception
+        - data holds bytes or decoded string read from the socket
         """
         Client.console(f"[Client] read {self.client_id}")
         self.last_msg_t = ticks_ms()
         try:
-            request = await self.reader.read(self.read_bytes)
-            request = request.decode('utf8').strip()
+            if timeout_seconds:
+                request = await asyncio.wait_for(self.reader.read(self.read_bytes), timeout_seconds)
+            else:
+                request = await self.reader.read(self.read_bytes)
+            if decoding:
+                request = request.decode(decoding)
+        except asyncio.TimeoutError:
+            Client.console(f"[Client] Stream read timeout ({self.client_id}), timeout={timeout_seconds}s")
+            return True, ''
         except Exception as e:
             Client.console(f"[Client] Stream read error ({self.client_id}): {e}")
             collect()           # gc collection: "fix" for memory allocation failed, allocating 2049 bytes
@@ -83,8 +98,6 @@ class Client:
 
         # Input handling
         Client.console(f"[Client] raw request ({self.client_id}): |{request}|")
-        if request in ('exit', ''):
-            return True, request
         return False, request
 
     async def a_send(self, response, encode='utf8'):
@@ -99,7 +112,7 @@ class Client:
             except Exception as e:
                 # Maintain ACTIVE_CLIS - remove closed connection by peer.
                 await self.close()
-                errlog_add(f"[WARN] Client.a_send (auto-drop) {self.client_id}: {e}")
+                syslog(f"[WARN] Client.a_send (auto-drop) {self.client_id}: {e}")
                 return          # Abort async send (no drain)
             # Send buffered data with async task - hacky
             try:
@@ -114,7 +127,7 @@ class Client:
             console_write("[Client] NoCon: response>dev/nul")
 
     def send(self, response):
-        # Implement in child class - synchronous send method
+        # Optional - Implement in child class - synchronous send (all) method
         pass
 
     async def close(self):
@@ -142,7 +155,7 @@ class Client:
         if Client.ACTIVE_CLIS.get(client_id, None) is not None:
             Client.ACTIVE_CLIS.pop(client_id)
         # Update server task output (? test ?)
-        Manager().server_task_msg(','.join(list(Client.ACTIVE_CLIS)))
+        Manager().task_msg('server', ','.join(list(Client.ACTIVE_CLIS)))
 
     def __del__(self):
         """Client GC collect"""
@@ -158,32 +171,23 @@ class WebCli(Client, WebEngine):
 
     async def run_web(self):
         # Update server task output
-        Manager().server_task_msg(','.join(list(Client.ACTIVE_CLIS)))
+        Manager().task_msg('server', ','.join(list(Client.ACTIVE_CLIS)))
 
         # Run async connection handling
         while self.connected:
             try:
                 # Read request msg from client
-                state, request = await self.read()
-                if state:
+                state, request = await self.read(decoding=None)
+                if state or not request:
+                    break
+                if not await self.response(request):
                     break
-                await self.response(request)
             except Exception as e:
-                errlog_add(f"[ERR] Client.run_web: {e}")
+                syslog(f"[ERR] Client.run_web: {e}")
                 break
         # Close connection
         await self.close()
 
-    @staticmethod
-    def register(endpoint, callback):
-        # AUTO ENABLE webui when register (endpoint) called and webui is False
-        if not cfgget('webui'):
-            from Config import cfgput
-            if cfgput('webui', True):  # SET webui to True
-                from machine import reset
-                reset()  # HARD RESET (REBOOT)
-        WebEngine.REST_ENDPOINTS[endpoint] = callback
-
 
 class ShellCli(Client, Shell):
 
@@ -196,7 +200,9 @@ class ShellCli(Client, Shell):
 
     def send(self, response):
         """
-        Send response to client with non-async function
+        Synchronous send function (with drain task)
+        - not used in Shell or ShellCli
+        - Note: it is a support function for synchronous scenarios: Server.reply_all
         """
         if self.connected:
             if self.prompt() != response:
@@ -209,7 +215,7 @@ class ShellCli(Client, Shell):
             except:
                 # Maintain ACTIVE_CLIS - remove closed connection by peer.
                 Client.drop_client(self.client_id)
-                errlog_add(f"[WARN] ShellCli.send (auto-drop) {self.client_id}")
+                syslog(f"[WARN] ShellCli.send (auto-drop) {self.client_id}")
             # Send buffered data with async task - hacky
             if self.drain_event.is_set():
                 self.drain_event.clear()        # set drain busy (False)
@@ -219,8 +225,7 @@ class ShellCli(Client, Shell):
 
     async def __wait_for_drain(self):
         """
-        Handle drain serialization
-        - solve output data duplicate
+        Handle drain serialization - for synchronous send function
         """
         try:
             # send write buffer
@@ -233,55 +238,45 @@ class ShellCli(Client, Shell):
         # set drain free
         self.drain_event.set()                  # set drain free (True)
 
-    async def close(self):
-        Client.console(f"[ShellCli] Close connection {self.client_id}")
-        self.send("Bye!\n")
-        # Reset shell state machine
-        self.reset()
-        await asyncio.sleep_ms(50)
-        # Used from Client parent class
-        await super().close()
-
-    async def __shell_cmd(self, request):
+    async def a_send(self, response, encode='utf8'):
         """
-        Handle micrOS shell commands
+        Async send for Shell (new line + prompt$)
         """
-        # Run micrOS shell with request string
-        try:
-            # Handle micrOS shell
-            Client.console("[ShellCli] --- #Run shell")
-            state = self.shell(request)
-            if state:
-                return False      # exit_loop
-            return True           # exit_loop : Close session when shell returns False (auth Failed, etc.)
-        except Exception as e:
-            Client.console(f"[ShellCli] Shell exception: {e}")
-            if "ECONNRESET" in str(e):
-                return True       # exit_loop
-        self.send("[HA] Critical error - disconnect & hard reset")
-        errlog_add("[ERR] Socket critical error - reboot")
-        self.reboot()
+        if self.prompt() != response:
+            # [format] Add new line if not prompt
+            response = f"{response}\n"
+        await super().a_send(response, encode)
 
     async def run_shell(self):
         # Update server task output
-        Manager().server_task_msg(','.join(list(Client.ACTIVE_CLIS)))
+        Manager().task_msg('server', ','.join(list(Client.ACTIVE_CLIS)))
         # Init prompt
-        self.send(self.prompt())
+        await self.a_send(self.prompt())
         # Run async connection handling
+        _exit = False
         while self.connected:
             try:
                 # Read request msg from client
                 state, request = await self.read()
-                if state:
-                    break
-                _exit = await self.__shell_cmd(request)
-                if _exit:
-                    collect()
+                if state or request in ('exit', ''):
                     break
+                # Run micrOS shell with request string
+                Client.console("[ShellCli] --- #Run shell")
+                # Shell -> True (OK) or False (NOK) -> NOK->Close session (auth Failed, etc.)
+                _exit = not await self.shell(request)
             except Exception as e:
-                errlog_add(f"[ERR] handle_client: {e}")
+                syslog(f"[ERR] Shell client: {e}")
+                if "ECONNRESET" in str(e):
+                    _exit = True  # exit_loop
+                else:
+                    await self.a_send("[HA] Critical error - disconnect & hard reset")
+                    syslog("[ERR] Socket critical error - reboot")
+                    await self.reboot()
+            if _exit:
+                collect()
                 break
         # Close connection
+        await self.a_send("Bye!")
         await self.close()
 
 
@@ -418,8 +413,11 @@ class Server:
         """
         for _, cli in Client.ACTIVE_CLIS.items():
             if cli.connected:
-                cli.send(msg)
+                cli.send(f"~~~ {msg}")
 
     def __del__(self):
         Client.console("[ socket server ] <<destructor>>")
-        self.server.close()
+        if self.server:
+            self.server.close()
+        if self.web:
+            self.web.close()

micrOS/source/Shell.py

@@ -11,12 +11,12 @@ Designed by Marcell Ban aka BxNxM
 #################################################################
 #                           IMPORTS                             #
 #################################################################
-from os import listdir
 from sys import modules
 from machine import reset as hard_reset, soft_reset
 from Config import cfgget, cfgput
+from Files import OSPath, ilist_fs, path_join
 from Tasks import lm_exec
-from Debug import errlog_add
+from Debug import syslog
 
 
 #################################################################
@@ -25,7 +25,7 @@ from Debug import errlog_add
 
 class Shell:
     __slots__ = ['__devfid', '__auth_mode', '__hwuid', '__auth_ok', '__conf_mode']
-    MICROS_VERSION = '2.9.1-0'
+    MICROS_VERSION = '2.26.1-0'
 
     def __init__(self):
         """
@@ -43,57 +43,53 @@ class Shell:
         try:
             cfgput('version', Shell.MICROS_VERSION)
         except Exception as e:
-            errlog_add(f"[ERR] micrOS version export failed (config): {e}")
+            syslog(f"[ERR] micrOS version export failed (config): {e}")
 
-    def send(self, msg):
-        """
-        Must be defined by child class...
-        """
-        pass
+    async def a_send(self, msg):
+        """ Must be defined by child class... """
+        raise NotImplementedError("Child class must implement a_send method")
 
     def reset(self):
         """Reset shell state"""
         self.__auth_ok = False
         self.__conf_mode = False
 
-    def reboot(self, hard=False):
-        """Reboot micropython VM"""
-        self.send(f"{'[HARD] ' if hard else ''}Reboot micrOS system.")
-        self.send("Bye!")
+    async def reboot(self, hard=False):
+        """ Reboot micropython VM """
+        await self.a_send(f"{'[HARD] ' if hard else ''}Reboot micrOS system.\nBye!")
         if hard:
             hard_reset()
         soft_reset()
 
     def prompt(self):
-        """Generate prompt"""
+        """ Generate prompt """
         auth = "[password] " if self.__auth_mode and not self.__auth_ok else ""
         mode = "[configure] " if self.__conf_mode else ""
         return f"{auth}{mode}{self.__devfid} $ "
 
-    def __auth(self, msg_list):
-        """Authorize user"""
+    async def __auth(self, msg_list):
+        """ Authorize user """
         # Set user auth state
         if self.__auth_mode and not self.__auth_ok:
             # check password
-            usrpwd = cfgget('appwd')
-            if usrpwd == msg_list[0].strip():
+            if cfgget('appwd') == msg_list[0].strip():
                 self.__auth_ok = True
-                self.send("AuthOk")
+                await self.a_send("AuthOk")
                 return True, []
-            self.send("AuthFailed\nBye!")
+            await self.a_send("AuthFailed\nBye!")
             return False, []
         return True, msg_list
 
-    def shell(self, msg):
+    async def shell(self, msg):
         """
         micrOS Shell main - input string handling
         :param msg: incoming shell command (command or load module call)
         """
-        state = self.__shell(msg)
-        self.send(self.prompt())
+        state = await self.__shell(msg)
+        await self.a_send(self.prompt())
         return state
 
-    def __shell(self, msg):
+    async def __shell(self, msg):
         """
         Socket server - interpreter shell
         :param msg: socket input string
@@ -109,6 +105,8 @@ class Shell:
             # No msg to work with
             return True
         msg_list = msg.strip().split()
+        # INTERCON embedding: conf mode and remote call request check
+        is_local_cmd = self.__conf_mode or not msg_list[-1].startswith(">>")
 
         ##########################################
         #   [1] Handle built-in shell commands   #
@@ -116,75 +114,80 @@ class Shell:
         ##########################################
 
         # Hello message
-        if msg_list[0] == 'hello':
+        if is_local_cmd and msg_list[0] == 'hello':
             # For low level device identification - hello msg
-            self.send(f"hello:{self.__devfid}:{self.__hwuid}")
+            await self.a_send(f"hello:{self.__devfid}:{self.__hwuid}")
             return True
 
         # [!] AUTH
-        state, msg_list = self.__auth(msg_list)
+        state, msg_list = await self.__auth(msg_list)
         if not state:
             return False
         if len(msg_list) == 0:
             return True
 
         # Version handling
-        if msg_list[0] == 'version':
+        if is_local_cmd and msg_list[0] == 'version':
             # For micrOS system version info
-            self.send(str(Shell.MICROS_VERSION))
+            await self.a_send(str(Shell.MICROS_VERSION))
             return True
 
         # Reboot micropython VM
-        if msg_list[0] == 'reboot':
+        if is_local_cmd and msg_list[0] == 'reboot':
             hard = False
             if len(msg_list) >= 2 and "-h" in msg_list[1]:
                 # reboot / reboot -h
                 hard = True
-            self.reboot(hard)
+            await self.reboot(hard)
 
-        if msg_list[0].startswith('webrepl'):
+        if is_local_cmd and msg_list[0].startswith('webrepl'):
             if len(msg_list) == 2 and '-u' in msg_list[1]:
-                Shell.webrepl(msg_obj=self.send, update=True)
-            Shell.webrepl(msg_obj=self.send)
+                await Shell.webrepl(msg_obj=self.a_send, update=True)
+            return await Shell.webrepl(msg_obj=self.a_send)
 
         # CONFIGURE MODE STATE: ACCESS FOR NODE_CONFIG.JSON
-        if msg_list[0].startswith('conf'):
+        if is_local_cmd and msg_list[0].startswith('conf'):
             self.__conf_mode = True
             return True
-        if msg_list[0].startswith('noconf'):
+        if is_local_cmd and msg_list[0].startswith('noconf'):
             self.__conf_mode = False
             return True
 
         # HELP MSG
-        if msg_list[0] == "help":
-            self.send("[MICROS]   - built-in shell commands")
-            self.send("   hello   - hello msg - for device identification")
-            self.send("   modules - show active Load Modules")
-            self.send("   version - returns micrOS version")
-            self.send("   exit    - exit from shell socket prompt")
-            self.send("   reboot  - system soft reboot (vm), hard reboot (hw): reboot -h")
-            self.send("   webrepl - start webrepl, for file transfers use with --update")
-            self.send("[CONF] Configure mode - built-in shell commands")
-            self.send("  conf       - Enter conf mode")
-            self.send("    dump       - Dump all data")
-            self.send("    key        - Get value")
-            self.send("    key value  - Set value")
-            self.send("  noconf     - Exit conf mode")
-            self.send("[TASK] postfix: &x - one-time,  &&x - periodic, x: wait ms [x min: 20ms]")
-            self.send("  task list         - list tasks with <tag>s")
-            self.send("  task kill <tag>   - stop task")
-            self.send("  task show <tag>   - show task output")
-            self.send("[EXEC] Command mode (LMs):")
-            self.send("   help lm  - list ALL LoadModules")
+        if is_local_cmd and msg_list[0] == "help":
+            await self.a_send("[MICROS]")
+            await self.a_send("   hello     - hello msg - for device identification")
+            await self.a_send("   modules   - show active Load Modules")
+            await self.a_send("   version   - returns micrOS version")
+            await self.a_send("   exit      - exit shell session")
+            await self.a_send("   reboot    - system soft reboot (vm), hard reboot (hw): reboot -h")
+            await self.a_send("   webrepl   - start webrepl, for file transfers use with --update")
+            await self.a_send("[CONF] Configuration mode")
+            await self.a_send("  conf       - Enter conf mode")
+            await self.a_send("    dump       - Dump all data, filter: dump <str>")
+            await self.a_send("    key        - Get value")
+            await self.a_send("    key value  - Set value")
+            await self.a_send("  noconf     - Exit conf mode")
+            await self.a_send("[TASK] Task operations")
+            await self.a_send("  task list         - list tasks by tags")
+            await self.a_send("  task kill <tag>   - stop task")
+            await self.a_send("  task show <tag>   - show task output")
+            await self.a_send("[EXEC] Command mode, syntax(...): <module> <function> <params> <postfix>")
+            await self.a_send("  Postfix hints:")
+            await self.a_send("    ... &<x>            - start one-shot task")
+            await self.a_send("    ... &&<x>           - start periodic task, where <x>: delay ms [x min: 20ms]")
+            await self.a_send("    ... >json           - request json formatted output")
+            await self.a_send("    ... >>hostname      - remote command execution (intercon)")
+            await self.a_send("  help lm           - list ALL available LoadModules")
             if "lm" in str(msg_list):
-                return Shell._show_lm_funcs(msg_obj=self.send)
-            return Shell._show_lm_funcs(msg_obj=self.send, active_only=True)
+                return await Shell._show_lm_funcs(msg_obj=self.a_send)
+            return await Shell._show_lm_funcs(msg_obj=self.a_send, active_only=True)
 
         # [2] EXECUTE:
         # @1 Configure mode
-        if self.__conf_mode and len(msg_list) > 0:
+        if is_local_cmd and self.__conf_mode and len(msg_list) > 0:
             # Lock thread under config handling is threads available
-            return Shell._configure(self.send, msg_list)
+            return await Shell._configure(self.a_send, msg_list)
         # @2 Command mode
         """
         INPUT MSG STRUCTURE
@@ -193,43 +196,43 @@ class Shell:
         """
         try:
             # Execute command via InterpreterCore
-            self.send(lm_exec(arg_list=msg_list)[1])
+            await self.a_send(lm_exec(arg_list=msg_list)[1])
             return True
         except Exception as e:
-            self.send(f"[ERROR] shell.lm_exec internal error: {e}")
+            await self.a_send(f"[ERROR] shell.lm_exec internal error: {e}")
             return False
 
     #################################################################
     #                     CONFIGURE MODE HANDLER                    #
     #################################################################
     @staticmethod
-    def _configure(msg_obj, msg_list):
+    async def _configure(msg_obj, msg_list):
         """
         :param msg_obj: shell output stream function reference (write object)
         :param msg_list: socket input param list
         :return: execution status
         """
-        def dump():
+        async def dump():
             nonlocal msg_obj, msg_list
             if msg_list[0] == 'dump':
                 search = msg_list[1] if len(msg_list) == 2 else None
                 # DUMP DATA
                 for _key, value in cfgget().items():
                     if search is None or search in _key:
-                        msg_obj(f"  {_key}{' ' * (10 - len(_key))}:{' ' * 7} {value}")
+                        await msg_obj(f"  {_key}{' ' * (10 - len(_key))}:{' ' * 7} {value}")
                 return True
             return False
 
         # [CONFIG] Get value
         if len(msg_list) == 1:
-            if dump():                      # Simple dump without param filter
+            if await dump():                      # Simple dump without param filter
                 return True
             # GET SINGLE PARAMETER VALUE
-            msg_obj(cfgget(msg_list[0]))
+            await msg_obj(cfgget(msg_list[0]))
             return True
         # [CONFIG] Set value
         if len(msg_list) >= 2:
-            if dump():                      # Dump with search option
+            if await dump():                      # Dump with search option
                 return True
             # Deserialize params
             key = msg_list[0]
@@ -237,68 +240,73 @@ class Shell:
             try:
                 output = cfgput(key, " ".join(msg_list[1:]), type_check=True)
             except Exception as e:
-                msg_obj(f"node_config write error: {e}")
+                await msg_obj(f"node_config write error: {e}")
                 output = False
             # Evaluation and reply
-            msg_obj('Saved' if output else 'Invalid key' if cfgget(key) is None else 'Failed to save')
+            await msg_obj('Saved' if output else 'Invalid key' if cfgget(key) is None else 'Failed to save')
         return True
 
     #################################################################
     #                   COMMAND MODE & LMS HANDLER                  #
     #################################################################
     @staticmethod
-    def _show_lm_funcs(msg_obj, active_only=False):
+    async def _show_lm_funcs(msg_obj, active_only=False):
         """
         Dump LM modules with functions - in case of [py] files
         Dump LM module with help function call - in case of [mpy] files
         """
-        def _help(mod):
-            for lm_path in (i for i in mod if i.startswith('LM_') and (i.endswith('py'))):
+        async def _help(mods):
+            nonlocal mpath
+            for lm_path in mods:
                 lm_name = lm_path.replace('LM_', '').split('.')[0]
                 try:
-                    msg_obj(f"   {lm_name}")
+                    await msg_obj(f"  {lm_name}")
                     if lm_path.endswith('.mpy'):
-                        msg_obj(f"   {' ' * len(lm_path.replace('LM_', '').split('.')[0])}help")
+                        await msg_obj(f"  {' ' * len(lm_path.replace('LM_', '').split('.')[0])}help")
                         continue
-                    with open(lm_path, 'r') as f:
+                    with open(path_join(mpath, lm_path), 'r') as f:
                         line = "micrOSisTheBest"
                         while line:
                             line = f.readline()
                             ldata = line.strip()
                             if ldata.startswith('def ') and not ldata.split()[1].startswith("_") and 'self' not in ldata:
-                                msg_obj(f"   {' ' * len(lm_name)}{ldata.replace('def ', '').split('(')[0]}")
+                                await msg_obj(f"  {' ' * len(lm_name)}{ldata.replace('def ', '').split('(')[0]}")
                 except Exception as e:
-                    msg_obj(f"[{lm_path}] SHOW LM PARSER WARNING: {e}")
+                    await msg_obj(f"[{lm_path}] SHOW LM PARSER WARNING: {e}")
                     return False
             return True
 
+        await msg_obj("")
         # [1] list active modules (default in shell)
+        mpath = OSPath.MODULES
         if active_only:
             mod_keys = modules.keys()
-            active_modules = (dir_mod for dir_mod in listdir() if dir_mod.split('.')[0] in mod_keys)
-            return _help(active_modules)
+            active_modules = (dir_mod for dir_mod in ilist_fs(path=mpath, type_filter='f', select="LM")
+                              if dir_mod.split('.')[0] in mod_keys)
+            return await _help(active_modules)
         # [2] list all LMs on file system (ALL - help lm) - manual
-        return _help(listdir())
+        return await _help(ilist_fs(path=mpath, type_filter='f', select="LM"))
 
     @staticmethod
-    def webrepl(msg_obj, update=False):
+    async def webrepl(msg_obj, update=False):
         from Network import ifconfig
 
-        msg_obj(" Start micropython WEBREPL - file transfer and debugging")
-        msg_obj("  [i] restart machine shortcut: import reset")
-        msg_obj(f"  Connect over http://micropython.org/webrepl/#{ifconfig()[1][0]}:8266/")
-        msg_obj(f"  \t[!] webrepl password: {cfgget('appwd')}")
+        await msg_obj(" Start micropython WEBREPL - file transfer and debugging")
+        await msg_obj("  [i] restart machine shortcut: import reset")
+        await msg_obj(f"  Connect over http://micropython.org/webrepl/#{ifconfig()[1][0]}:8266/")
+        await msg_obj(f"  \t[!] webrepl password: {cfgget('appwd')}")
         if update:
-            msg_obj(" Restart node then start webrepl...")
-            msg_obj(" Bye!")
+            await msg_obj(" Restart node then start webrepl...")
+            await msg_obj(" Bye!")
             # Set .if_mode->webrepl (start webrepl after reboot and poll update status...)
             with open('.if_mode', 'w') as f:
                 f.write('webrepl')
             hard_reset()
         try:
             import webrepl
-            msg_obj(webrepl.start(password=cfgget('appwd')))
+            await msg_obj(webrepl.start(password=cfgget('appwd')))
         except Exception as e:
             _err_msg = f"[ERR] while starting webrepl: {e}"
-            msg_obj(_err_msg)
-            errlog_add(_err_msg)
+            await msg_obj(_err_msg)
+            syslog(_err_msg)
+        return True