hex-zmq-servers 0.1.21.1__tar.gz → 0.2.0__tar.gz

{hex_zmq_servers-0.1.21.1/hex_zmq_servers.egg-info → hex_zmq_servers-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hex_zmq_servers
-Version: 0.1.21.1
+Version: 0.2.0
 Summary: HEXFELLOW ZMQ Servers
 Author-email: Dong Zhaorui <joray.dong@hexfellow.com>
 Maintainer-email: jecjune <zejun.chen@hexfellow.com>, Dong Zhaorui <joray.dong@hexfellow.com>
@@ -27,7 +27,7 @@ License-File: LICENSE
 Requires-Dist: pyzmq>=27.0.1
 Requires-Dist: opencv-python>=4.2
 Requires-Dist: mujoco>=3.3.3
-Requires-Dist: berxel_py_warpper>=2.0
+Requires-Dist: berxel_py_wrapper>=2.0
 Requires-Dist: hex_device>=1.1.3
 Requires-Dist: dynamixel-sdk==3.8.4
 Dynamic: license-file

{hex_zmq_servers-0.1.21.1 → hex_zmq_servers-0.2.0}/hex_zmq_servers/__init__.py

@@ -11,35 +11,35 @@ from .hex_launch import HexLaunch, HEX_LOG_LEVEL, hex_log, hex_err
 from .device_base import HexDeviceBase
 from .zmq_base import HexRate, hex_zmq_ts_now, hex_zmq_ts_delta_ms
 from .zmq_base import HexSafeValue, HexZMQClientBase, HexZMQServerBase, hex_server_helper
-from .zmq_base import HexDummyZMQClient, HexDummyZMQServer
+from .zmq_base import HexZMQDummyClient, HexZMQDummyServer
 
 from .cam import HexCamBase, HexCamClientBase, HexCamServerBase
-from .cam import HexDummyCam, HexDummyCamClient, HexDummyCamServer
-from .cam import HexBerxelCam, HexBerxelCamClient, HexBerxelCamServer
+from .cam import HexCamDummy, HexCamDummyClient, HexCamDummyServer
+from .cam import HexCamBerxel, HexCamBerxelClient, HexCamBerxelServer
 
 from .mujoco import HexMujocoBase, HexMujocoClientBase, HexMujocoServerBase
-from .mujoco import HexArcherD6yMujoco, HexArcherD6yMujocoClient, HexArcherD6yMujocoServer
-from .mujoco import HexE3DesktopMujoco, HexE3DesktopMujocoClient, HexE3DesktopMujocoServer
+from .mujoco import HexMujocoArcherD6y, HexMujocoArcherD6yClient, HexMujocoArcherD6yServer
+from .mujoco import HexMujocoE3Desktop, HexMujocoE3DesktopClient, HexMujocoE3DesktopServer
 
 from .robot import HexRobotBase, HexRobotClientBase, HexRobotServerBase
-from .robot import HexDummyRobot, HexDummyRobotClient, HexDummyRobotServer
-from .robot import HexGelloRobot, HexGelloRobotClient, HexGelloRobotServer
-from .robot import HexHexArmRobot, HexHexArmRobotClient, HexHexArmRobotServer
+from .robot import HexRobotDummy, HexRobotDummyClient, HexRobotDummyServer
+from .robot import HexRobotGello, HexRobotGelloClient, HexRobotGelloServer
+from .robot import HexRobotHexarm, HexRobotHexarmClient, HexRobotHexarmServer
 
 import os
 
 file_dir = os.path.dirname(os.path.abspath(__file__))
 HEX_ZMQ_SERVERS_PATH_DICT = {
     "zmq_dummy": f"{file_dir}/zmq_base.py",
-    "cam_dummy": f"{file_dir}/cam/dummy/dummy_cam_srv.py",
-    "cam_berxel": f"{file_dir}/cam/berxel/berxel_cam_srv.py",
+    "cam_dummy": f"{file_dir}/cam/dummy/cam_dummy_srv.py",
+    "cam_berxel": f"{file_dir}/cam/berxel/cam_berxel_srv.py",
     "mujoco_archer_d6y":
-    f"{file_dir}/mujoco/archer_d6y/archer_d6y_mujoco_srv.py",
+    f"{file_dir}/mujoco/archer_d6y/mujoco_archer_d6y_srv.py",
     "mujoco_e3_desktop":
-    f"{file_dir}/mujoco/e3_desktop/e3_desktop_mujoco_srv.py",
-    "robot_dummy": f"{file_dir}/robot/dummy/dummy_robot_srv.py",
-    "robot_gello": f"{file_dir}/robot/gello/gello_robot_srv.py",
-    "robot_hex_arm": f"{file_dir}/robot/hex_arm/hex_arm_robot_srv.py",
+    f"{file_dir}/mujoco/e3_desktop/mujoco_e3_desktop_srv.py",
+    "robot_dummy": f"{file_dir}/robot/dummy/robot_dummy_srv.py",
+    "robot_gello": f"{file_dir}/robot/gello/robot_gello_srv.py",
+    "robot_hexarm": f"{file_dir}/robot/hexarm/robot_hexarm_srv.py",
 }
 HEX_ZMQ_CONFIGS_PATH_DICT = {
     "zmq_dummy": f"{file_dir}/config/zmq_dummy.json",
@@ -49,7 +49,7 @@ HEX_ZMQ_CONFIGS_PATH_DICT = {
     "mujoco_e3_desktop": f"{file_dir}/config/mujoco_e3_desktop.json",
     "robot_dummy": f"{file_dir}/config/robot_dummy.json",
     "robot_gello": f"{file_dir}/config/robot_gello.json",
-    "robot_hex_arm": f"{file_dir}/config/robot_hex_arm.json",
+    "robot_hexarm": f"{file_dir}/config/robot_hexarm.json",
 }
 
 __all__ = [
@@ -75,44 +75,44 @@ __all__ = [
     "HexZMQClientBase",
     "HexZMQServerBase",
     "hex_server_helper",
-    "HexDummyZMQClient",
-    "HexDummyZMQServer",
+    "HexZMQDummyClient",
+    "HexZMQDummyServer",
 
     # camera
     "HexCamBase",
     "HexCamClientBase",
     "HexCamServerBase",
-    "HexDummyCam",
-    "HexDummyCamClient",
-    "HexDummyCamServer",
-    "HexBerxelCam",
-    "HexBerxelCamClient",
-    "HexBerxelCamServer",
+    "HexCamDummy",
+    "HexCamDummyClient",
+    "HexCamDummyServer",
+    "HexCamBerxel",
+    "HexCamBerxelClient",
+    "HexCamBerxelServer",
 
     # mujoco
     "HexMujocoBase",
     "HexMujocoClientBase",
     "HexMujocoServerBase",
-    "HexArcherD6yMujoco",
-    "HexArcherD6yMujocoClient",
-    "HexArcherD6yMujocoServer",
-    "HexE3DesktopMujoco",
-    "HexE3DesktopMujocoClient",
-    "HexE3DesktopMujocoServer",
+    "HexMujocoArcherD6y",
+    "HexMujocoArcherD6yClient",
+    "HexMujocoArcherD6yServer",
+    "HexMujocoE3Desktop",
+    "HexMujocoE3DesktopClient",
+    "HexMujocoE3DesktopServer",
 
     # robot
     "HexRobotBase",
     "HexRobotClientBase",
     "HexRobotServerBase",
-    "HexDummyRobot",
-    "HexDummyRobotClient",
-    "HexDummyRobotServer",
-    "HexGelloRobot",
-    "HexGelloRobotClient",
-    "HexGelloRobotServer",
-    "HexHexArmRobot",
-    "HexHexArmRobotClient",
-    "HexHexArmRobotServer",
+    "HexRobotDummy",
+    "HexRobotDummyClient",
+    "HexRobotDummyServer",
+    "HexRobotGello",
+    "HexRobotGelloClient",
+    "HexRobotGelloServer",
+    "HexRobotHexarm",
+    "HexRobotHexarmClient",
+    "HexRobotHexarmServer",
 ]
 
 # print("#### Thanks for using hex_zmq_servers :D ####")

{hex_zmq_servers-0.1.21.1 → hex_zmq_servers-0.2.0}/hex_zmq_servers/cam/__init__.py

@@ -7,8 +7,8 @@
 ################################################################
 
 from .cam_base import HexCamBase, HexCamClientBase, HexCamServerBase
-from .dummy import HexDummyCam, HexDummyCamClient, HexDummyCamServer
-from .berxel import HexBerxelCam, HexBerxelCamClient, HexBerxelCamServer
+from .dummy import HexCamDummy, HexCamDummyClient, HexCamDummyServer
+from .berxel import HexCamBerxel, HexCamBerxelClient, HexCamBerxelServer
 
 __all__ = [
     # base
@@ -17,12 +17,12 @@ __all__ = [
     "HexCamServerBase",
 
     # dummy
-    "HexDummyCam",
-    "HexDummyCamClient",
-    "HexDummyCamServer",
+    "HexCamDummy",
+    "HexCamDummyClient",
+    "HexCamDummyServer",
 
     # berxel
-    "HexBerxelCam",
-    "HexBerxelCamClient",
-    "HexBerxelCamServer",
+    "HexCamBerxel",
+    "HexCamBerxelClient",
+    "HexCamBerxelServer",
 ]

{hex_zmq_servers-0.1.21.1 → hex_zmq_servers-0.2.0}/hex_zmq_servers/cam/berxel/__init__.py

@@ -6,12 +6,12 @@
 # Date  : 2025-09-12
 ################################################################
 
-from .berxel_cam import HexBerxelCam
-from .berxel_cam_cli import HexBerxelCamClient
-from .berxel_cam_srv import HexBerxelCamServer
+from .cam_berxel import HexCamBerxel
+from .cam_berxel_cli import HexCamBerxelClient
+from .cam_berxel_srv import HexCamBerxelServer
 
 __all__ = [
-    "HexBerxelCam",
-    "HexBerxelCamClient",
-    "HexBerxelCamServer",
+    "HexCamBerxel",
+    "HexCamBerxelClient",
+    "HexCamBerxelServer",
 ]

hex_zmq_servers-0.1.21.1/hex_zmq_servers/cam/berxel/berxel_cam.py → hex_zmq_servers-0.2.0/hex_zmq_servers/cam/berxel/cam_berxel.py

@@ -11,7 +11,7 @@ import numpy as np
 
 from ..cam_base import HexCamBase
 from ...zmq_base import HexSafeValue
-from berxel_py_warpper import *
+from berxel_py_wrapper import *
 
 CAMERA_CONFIG = {
     "serial_number": 'P100RYB4C03M2B322',
@@ -22,7 +22,7 @@ CAMERA_CONFIG = {
 }
 
 
-class HexBerxelCam(HexCamBase):
+class HexCamBerxel(HexCamBase):
 
     def __init__(
         self,

hex_zmq_servers-0.1.21.1/hex_zmq_servers/cam/berxel/berxel_cam_cli.py → hex_zmq_servers-0.2.0/hex_zmq_servers/cam/berxel/cam_berxel_cli.py

@@ -17,7 +17,7 @@ NET_CONFIG = {
 }
 
 
-class HexBerxelCamClient(HexCamClientBase):
+class HexCamBerxelClient(HexCamClientBase):
 
     def __init__(
         self,

hex_zmq_servers-0.1.21.1/hex_zmq_servers/cam/berxel/berxel_cam_srv.py → hex_zmq_servers-0.2.0/hex_zmq_servers/cam/berxel/cam_berxel_srv.py

@@ -10,7 +10,7 @@ import numpy as np
 
 try:
     from ..cam_base import HexCamServerBase
-    from .berxel_cam import HexBerxelCam
+    from .cam_berxel import HexCamBerxel
 except (ImportError, ValueError):
     import sys
     from pathlib import Path
@@ -19,7 +19,7 @@ except (ImportError, ValueError):
     if str(project_root) not in sys.path:
         sys.path.insert(0, str(project_root))
     from hex_zmq_servers.cam.cam_base import HexCamServerBase
-    from hex_zmq_servers.cam.berxel.berxel_cam import HexBerxelCam
+    from hex_zmq_servers.cam.berxel.cam_berxel import HexCamBerxel
 
 NET_CONFIG = {
     "ip": "127.0.0.1",
@@ -38,7 +38,7 @@ CAMERA_CONFIG = {
 }
 
 
-class HexBerxelCamServer(HexCamServerBase):
+class HexCamBerxelServer(HexCamServerBase):
 
     def __init__(
         self,
@@ -48,7 +48,7 @@ class HexBerxelCamServer(HexCamServerBase):
         HexCamServerBase.__init__(self, net_config)
 
         # camera
-        self._device = HexBerxelCam(params_config)
+        self._device = HexCamBerxel(params_config)
 
     def _process_request(self, recv_hdr: dict, recv_buf: np.ndarray):
         if recv_hdr["cmd"] == "is_working":
@@ -73,4 +73,4 @@ if __name__ == "__main__":
     args = parser.parse_args()
     cfg = json.loads(args.cfg)
 
-    hex_server_helper(cfg, HexBerxelCamServer)
+    hex_server_helper(cfg, HexCamBerxelServer)

{hex_zmq_servers-0.1.21.1 → hex_zmq_servers-0.2.0}/hex_zmq_servers/cam/cam_base.py

@@ -74,7 +74,6 @@ class HexCamClientBase(HexZMQClientBase):
                     self._rgb_seq = hdr["args"]
                 return hdr, img
             else:
-                print(f"\033[91m{cmd} is not {req_cmd}\033[0m")
                 return None, None
         except KeyError:
             print(f"\033[91m{hdr['cmd']} requires `cmd`\033[0m")

{hex_zmq_servers-0.1.21.1 → hex_zmq_servers-0.2.0}/hex_zmq_servers/cam/dummy/__init__.py

@@ -6,12 +6,12 @@
 # Date  : 2025-09-12
 ################################################################
 
-from .dummy_cam import HexDummyCam
-from .dummy_cam_cli import HexDummyCamClient
-from .dummy_cam_srv import HexDummyCamServer
+from .cam_dummy import HexCamDummy
+from .cam_dummy_cli import HexCamDummyClient
+from .cam_dummy_srv import HexCamDummyServer
 
 __all__ = [
-    "HexDummyCam",
-    "HexDummyCamClient",
-    "HexDummyCamServer",
+    "HexCamDummy",
+    "HexCamDummyClient",
+    "HexCamDummyServer",
 ]

hex_zmq_servers-0.1.21.1/hex_zmq_servers/cam/dummy/dummy_cam.py → hex_zmq_servers-0.2.0/hex_zmq_servers/cam/dummy/cam_dummy.py

@@ -16,7 +16,7 @@ from ...zmq_base import (
 )
 
 
-class HexDummyCam(HexCamBase):
+class HexCamDummy(HexCamBase):
 
     def __init__(self, params_config: dict = {}):
         HexCamBase.__init__(self)

hex_zmq_servers-0.1.21.1/hex_zmq_servers/cam/dummy/dummy_cam_cli.py → hex_zmq_servers-0.2.0/hex_zmq_servers/cam/dummy/cam_dummy_cli.py

@@ -17,7 +17,7 @@ NET_CONFIG = {
 }
 
 
-class HexDummyCamClient(HexCamClientBase):
+class HexCamDummyClient(HexCamClientBase):
 
     def __init__(
         self,

hex_zmq_servers-0.1.21.1/hex_zmq_servers/cam/dummy/dummy_cam_srv.py → hex_zmq_servers-0.2.0/hex_zmq_servers/cam/dummy/cam_dummy_srv.py

@@ -10,7 +10,7 @@ import numpy as np
 
 try:
     from ..cam_base import HexCamServerBase
-    from .dummy_cam import HexDummyCam
+    from .cam_dummy import HexCamDummy
 except (ImportError, ValueError):
     import sys
     from pathlib import Path
@@ -19,7 +19,7 @@ except (ImportError, ValueError):
     if str(project_root) not in sys.path:
         sys.path.insert(0, str(project_root))
     from hex_zmq_servers.cam.cam_base import HexCamServerBase
-    from hex_zmq_servers.cam.dummy.dummy_cam import HexDummyCam
+    from hex_zmq_servers.cam.dummy.cam_dummy import HexCamDummy
 
 NET_CONFIG = {
     "ip": "127.0.0.1",
@@ -30,7 +30,7 @@ NET_CONFIG = {
 }
 
 
-class HexDummyCamServer(HexCamServerBase):
+class HexCamDummyServer(HexCamServerBase):
 
     def __init__(
         self,
@@ -40,7 +40,7 @@ class HexDummyCamServer(HexCamServerBase):
         HexCamServerBase.__init__(self, net_config)
 
         # camera
-        self._device = HexDummyCam(params_config)
+        self._device = HexCamDummy(params_config)
 
     def _process_request(self, recv_hdr: dict, recv_buf: np.ndarray):
         if recv_hdr["cmd"] == "is_working":
@@ -62,4 +62,4 @@ if __name__ == "__main__":
     args = parser.parse_args()
     cfg = json.loads(args.cfg)
 
-    hex_server_helper(cfg, HexDummyCamServer)
+    hex_server_helper(cfg, HexCamDummyServer)

{hex_zmq_servers-0.1.21.1 → hex_zmq_servers-0.2.0}/hex_zmq_servers/config/robot_dummy.json

@@ -7,7 +7,9 @@
         "server_num_workers": 4
     },
     "params": {
-        "dofs": 7,
+        "dofs": [
+            7
+        ],
         "limits": [
             [
                 [

hex_zmq_servers-0.1.21.1/hex_zmq_servers/config/robot_hex_arm.json → hex_zmq_servers-0.2.0/hex_zmq_servers/config/robot_hexarm.json

@@ -19,7 +19,7 @@
             75.0,
             15.0,
             15.0,
-            0.0
+            20.0
         ],
         "mit_kd": [
             12.5,
@@ -28,7 +28,7 @@
             6.0,
             0.31,
             0.31,
-            0.0
+            1.0
         ],
         "sens_ts": true
     }

{hex_zmq_servers-0.1.21.1 → hex_zmq_servers-0.2.0}/hex_zmq_servers/hex_launch.py

@@ -7,7 +7,8 @@
 ################################################################
 
 import json
-import os, sys, signal, asyncio
+import os, sys, signal, subprocess, threading, time
+import termios
 
 from datetime import datetime
 from pathlib import Path
@@ -38,10 +39,45 @@ class HexLaunch:
     ):
         self.__node_cfgs = node_cfgs
         self.__state: Dict[str, dict] = {}
-        self.__stop_event = asyncio.Event()
+        self.__stop_event = threading.Event()
         self.__log_dir = Path(log_dir)
         self.__log_dir.mkdir(parents=True, exist_ok=True)
         self.__min_level = min_level
+        # lock state for node messages
+        self.__state_lock = threading.Lock()
+        self.__shutdown_called = False
+        # terminal attrs
+        self.__terminal_attrs = None
+        self.__record_terminal_attrs()
+
+    def __record_terminal_attrs(self):
+        """record terminal attrs"""
+        try:
+            self.__terminal_attrs = termios.tcgetattr(sys.stdin.fileno())
+            self.__terminal_attrs[3] |= (termios.ICANON | termios.ECHO)
+            try:
+                self.__terminal_attrs[6][termios.VMIN] = 1
+                self.__terminal_attrs[6][termios.VTIME] = 0
+            except Exception:
+                pass
+            print("[launcher] Terminal settings recorded")
+        except Exception as e:
+            print(f"[launcher] Failed to record terminal attrs: {e}")
+
+    def __restore_terminal_attrs(self):
+        """restore terminal attrs"""
+        if self.__terminal_attrs is not None:
+            try:
+                termios.tcsetattr(
+                    sys.stdin.fileno(),
+                    termios.TCSADRAIN,
+                    self.__terminal_attrs,
+                )
+                print("[launcher] Terminal attrs restored")
+            except Exception as e:
+                print(f"[launcher] Failed to restore terminal attrs: {e}")
+        else:
+            print("[launcher] No terminal attrs to restore")
 
     def __build_cmd(self, node_cfg: dict):
         # python path
@@ -80,10 +116,10 @@ class HexLaunch:
                 else:
                     dict_raw[key] = value
 
-    async def __stream_printer(
+    def __stream_printer(
         self,
         prefix: str,
-        stream: asyncio.StreamReader,
+        stream,
         is_stderr: bool,
         logfile_path: Path | None,
         min_level: int,
@@ -92,9 +128,10 @@ class HexLaunch:
                                     encoding="utf-8") if logfile_path else None
         try:
             while True:
-                raw = await stream.readline()
+                raw = stream.readline()
                 if not raw:
-                    break
+                    time.sleep(0.001)
+                    continue
                 line = raw.decode(errors="replace").rstrip("\n")
 
                 record_flag = True
@@ -139,19 +176,19 @@ class HexLaunch:
             if logfile:
                 logfile.close()
 
-    async def __start_node(self, node_cfg: dict):
+    def __start_node(self, node_cfg: dict):
         name = node_cfg.get("name", node_cfg.get("node_path"))
         env = os.environ.copy()
         env.update(node_cfg.get("env", {}) or {})
         cwd = node_cfg.get("cwd") or None
         cmd = self.__build_cmd(node_cfg)
 
-        proc = await asyncio.create_subprocess_exec(
-            *cmd,
+        proc = subprocess.Popen(
+            cmd,
             cwd=cwd,
             env=env,
-            stdout=asyncio.subprocess.PIPE,
-            stderr=asyncio.subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
             preexec_fn=os.setsid,
         )
 
@@ -164,53 +201,75 @@ class HexLaunch:
         log_path.parent.mkdir(parents=True, exist_ok=True)
         err_path.parent.mkdir(parents=True, exist_ok=True)
 
-        log_task = asyncio.create_task(
-            self.__stream_printer(name, proc.stdout, False, log_path,
-                                  self.__min_level))
-        err_task = asyncio.create_task(
-            self.__stream_printer(name, proc.stderr, True, err_path,
-                                  self.__min_level))
-
-        return {"proc": proc, "tasks": (log_task, err_task), "cfg": node_cfg}
-
-    async def __monitor_loop(self):
+        log_thread = threading.Thread(target=self.__stream_printer,
+                                      args=(name, proc.stdout, False, log_path,
+                                            self.__min_level),
+                                      daemon=True)
+        err_thread = threading.Thread(target=self.__stream_printer,
+                                      args=(name, proc.stderr, True, err_path,
+                                            self.__min_level),
+                                      daemon=True)
+        log_thread.start()
+        err_thread.start()
+
+        return {
+            "proc": proc,
+            "threads": (log_thread, err_thread),
+            "cfg": node_cfg
+        }
+
+    def __monitor_loop(self):
         print(f"[launcher] Started {len(self.__node_cfgs)} nodes")
         for node in self.__node_cfgs:
             print(
                 f"[launcher] Starting {node.get('name', node.get('node_path'))}"
             )
-            entry = await self.__start_node(node)
-            self.__state[node.get("name", node.get("node_path"))] = entry
+            entry = self.__start_node(node)
+            with self.__state_lock:
+                self.__state[node.get("name", node.get("node_path"))] = entry
 
         try:
-            while self.__state:
-                for name, entry in list(self.__state.items()):
+            while not self.__stop_event.is_set():
+                with self.__state_lock:
+                    if not self.__state:
+                        break
+                    state_items = list(self.__state.items())
+
+                for name, entry in state_items:
                     proc = entry["proc"]
                     cfg_node = entry["cfg"]
 
-                    if proc.returncode is not None:
+                    if proc.poll() is not None:
                         print(
                             f"[launcher] Node {name} exited {proc.returncode}")
-                        for t in entry["tasks"]:
-                            t.cancel()
+                        # Threads will stop automatically when stream ends
 
                         if cfg_node.get("respawn"):
                             delay = cfg_node.get("respawn_delay", 1)
                             print(
                                 f"[launcher] Respawning {name} in {delay}s...")
-                            await asyncio.sleep(delay)
-                            new_entry = await self.__start_node(cfg_node)
-                            self.__state[name] = new_entry
+                            time.sleep(delay)
+                            new_entry = self.__start_node(cfg_node)
+                            with self.__state_lock:
+                                self.__state[name] = new_entry
                         else:
-                            del self.__state[name]
+                            with self.__state_lock:
+                                del self.__state[name]
 
-                await asyncio.sleep(0.5)
-        except asyncio.CancelledError:
+                time.sleep(0.5)
+        except KeyboardInterrupt:
             pass
 
     def __shutdown(self, signame):
+        if self.__shutdown_called:
+            return
+        self.__shutdown_called = True
+
         print(f"[launcher] Got signal {signame}, shutting down children...")
-        for name, entry in self.__state.items():
+        with self.__state_lock:
+            state_items = list(self.__state.items())
+
+        for _, entry in state_items:
             proc = entry["proc"]
             try:
                 os.killpg(os.getpgid(proc.pid), signal.SIGTERM)
@@ -220,19 +279,34 @@ class HexLaunch:
                 except Exception:
                     pass
         self.__stop_event.set()
+        self.__restore_terminal_attrs()
 
-    async def main(self):
-        loop = asyncio.get_running_loop()
+    def run(self):
+        # Set up signal handlers
         for s in (signal.SIGINT, signal.SIGTERM):
-            loop.add_signal_handler(s, lambda s=s: self.__shutdown(s.name))
+            signal.signal(
+                s, lambda signum, frame: self.__shutdown(
+                    signal.Signals(signum).name))
+
+        # Start monitor in a separate thread
+        monitor_thread = threading.Thread(target=self.__monitor_loop,
+                                          daemon=True)
+        monitor_thread.start()
 
-        monitor = asyncio.create_task(self.__monitor_loop())
-        await self.__stop_event.wait()
+        # Wait for stop event or monitor thread to finish
+        while monitor_thread.is_alive() and not self.__stop_event.is_set():
+            self.__stop_event.wait(timeout=0.5)
 
-        await asyncio.sleep(1.0)
-        for name, entry in self.__state.items():
+        # Give processes time to terminate gracefully
+        time.sleep(1.0)
+
+        # Force kill any remaining processes
+        with self.__state_lock:
+            state_items = list(self.__state.items())
+
+        for name, entry in state_items:
             proc = entry["proc"]
-            if proc.returncode is None:
+            if proc.poll() is None:
                 try:
                     os.killpg(os.getpgid(proc.pid), signal.SIGKILL)
                 except Exception:
@@ -240,8 +314,6 @@ class HexLaunch:
                         proc.kill()
                     except Exception:
                         pass
-        monitor.cancel()
-        await asyncio.sleep(0.1)
 
-    def run(self):
-        asyncio.run(self.main())
+        # Wait for monitor thread to finish
+        monitor_thread.join(timeout=0.5)