replx 1.8__tar.gz → 1.10__tar.gz

{replx-1.8/replx.egg-info → replx-1.10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: replx
-Version: 1.8
+Version: 1.10
 Summary: replx is a fast, modern MicroPython CLI: turbo REPL, robust file sync (put/get), project install, mpy-cross integration, and smart port discovery.
 Author-email: "chanmin.park" <devcamp@gmail.com>
 License-Expression: MIT
@@ -30,11 +30,12 @@ Dynamic: license-file
 [![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-`replx` is a CLI tool for MicroPython development. It uses an agent-based architecture to manage multiple CLI sessions and multiple boards in a consistent workflow.
+`replx` is a CLI tool for MicroPython development. It uses a single local agent process to manage multiple CLI sessions and multiple boards in a consistent workflow.
 
 ## What replx provides
 
 - Shared connection management across terminal sessions
+- Single local agent process per PC with home-scoped port persistence
 - Foreground and background board handling per session
 - Workspace-level default device configuration
 - File operations on device storage
@@ -104,6 +105,7 @@ pip install replx
 
 - `scan`, `status`, `whoami`, and `shutdown` are special commands and do not accept `--port`.
 - Most device commands can omit the port when a foreground or workspace default device is available.
+- The agent listens on a UDP port from `49152-65535` and stores the selected port in `~/.replx/.config` as `AGENT_PORT=...`.
 
 ## License
 

{replx-1.8 → replx-1.10}/README.md

@@ -4,11 +4,12 @@
 [![Python 3.10+](https://img.shields.io/badge/python-3.10+-blue.svg)](https://www.python.org/downloads/)
 [![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
 
-`replx` is a CLI tool for MicroPython development. It uses an agent-based architecture to manage multiple CLI sessions and multiple boards in a consistent workflow.
+`replx` is a CLI tool for MicroPython development. It uses a single local agent process to manage multiple CLI sessions and multiple boards in a consistent workflow.
 
 ## What replx provides
 
 - Shared connection management across terminal sessions
+- Single local agent process per PC with home-scoped port persistence
 - Foreground and background board handling per session
 - Workspace-level default device configuration
 - File operations on device storage
@@ -78,6 +79,7 @@ pip install replx
 
 - `scan`, `status`, `whoami`, and `shutdown` are special commands and do not accept `--port`.
 - Most device commands can omit the port when a foreground or workspace default device is available.
+- The agent listens on a UDP port from `49152-65535` and stores the selected port in `~/.replx/.config` as `AGENT_PORT=...`.
 
 ## License
 

{replx-1.8 → replx-1.10}/replx/__init__.py

@@ -1,5 +1,5 @@
 __all__ = ["__version__", "get_version", "__description__"]
-__version__ = "1.8"
+__version__ = "1.10"
 __description__ = "Fast, modern MicroPython CLI with REPL, file sync, install, and smart port detection."
 __author__ = "PlanX Lab Development Team"
 

replx-1.10/replx/__main__.py

@@ -0,0 +1,14 @@
+"""Allow ``python -m replx ...`` as a fast-startup alias for the ``replx`` script.
+
+On Windows the ``replx.exe`` console-script launcher (installed by pip from
+``[project.scripts]``) goes through a zipapp-style entry that adds ~450ms to
+every invocation. ``python -m replx`` bypasses that launcher and is noticeably
+snappier for users who care about CLI startup latency.
+"""
+
+import sys
+
+from replx.cli.app import main
+
+if __name__ == "__main__":
+    sys.exit(main())

replx-1.10/replx/cli/__init__.py

@@ -0,0 +1,20 @@
+from .config import (
+    RuntimeState, STATE, GLOBAL_OPTIONS,
+    ConfigManager, AgentPortManager, ConnectionResolver,
+)
+from replx.utils.constants import DEFAULT_AGENT_PORT, MIN_AGENT_PORT, MAX_AGENT_PORT
+
+__all__ = [
+    'RuntimeState', 'STATE', 'GLOBAL_OPTIONS',
+    'ConfigManager', 'AgentPortManager', 'ConnectionResolver',
+    'DEFAULT_AGENT_PORT', 'MIN_AGENT_PORT', 'MAX_AGENT_PORT',
+    'app', 'main'
+]
+
+
+def __getattr__(name):
+    if name in {'app', 'main'}:
+        from .app import app, main
+
+        return {'app': app, 'main': main}[name]
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

replx-1.10/replx/cli/agent/__init__.py

@@ -0,0 +1,27 @@
+
+from .protocol import AgentProtocol
+from .client import AgentClient, get_session_id, get_cached_session_id, clear_session_cache
+
+__all__ = [
+    'AgentProtocol',
+    'AgentClient',
+    'get_session_id',
+    'get_cached_session_id',
+    'clear_session_cache',
+    'AgentServer',
+    'agent_main',
+]
+
+
+def __getattr__(name):
+    # The server stack pulls in ``replx.terminal`` (~150ms) plus all command
+    # handlers; CLI clients never need it. Defer until something actually asks.
+    if name == 'AgentServer':
+        from .server import AgentServer
+
+        return AgentServer
+    if name == 'agent_main':
+        from .server import main as agent_main
+
+        return agent_main
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

{replx-1.8 → replx-1.10}/replx/cli/agent/client/core.py

@@ -128,35 +128,64 @@ class AgentClient:
         seq = request['seq']
         request_data = AgentProtocol.encode_message(request)
 
-        self.sock.sendto(request_data, (AGENT_HOST, self.agent_port))
-
-        self.sock.settimeout(5.0)
+        # UDP can drop ACK packets. Retry start request a few times while
+        # waiting for ACK/early stream for this seq.
+        self.sock.settimeout(0.2)
         ack_received = False
         error_response = None
+        completed_during_handshake = False
 
-        while True:
-            try:
-                data, addr = self.sock.recvfrom(MAX_UDP_SIZE)
-                msg = AgentProtocol.decode_message(data)
-                if msg and msg.get('seq') == seq:
-                    if msg.get('type') == 'ack':
-                        ack_received = True
-                        break
-                    elif msg.get('type') == 'response' and msg.get('error'):
-                        error_response = msg
-                        break
-            except socket.timeout:
+        max_attempts = max(1, self.MAX_RETRIES)
+        for attempt in range(max_attempts):
+            self.sock.sendto(request_data, (AGENT_HOST, self.agent_port))
+
+            attempt_deadline = time.time() + 1.5
+            while time.time() < attempt_deadline:
+                try:
+                    data, addr = self.sock.recvfrom(MAX_UDP_SIZE)
+                    msg = AgentProtocol.decode_message(data)
+                    if msg and msg.get('seq') == seq:
+                        msg_type = msg.get('type')
+                        if msg_type == 'ack':
+                            ack_received = True
+                            break
+                        if msg_type == 'response' and msg.get('error'):
+                            error_response = msg
+                            break
+                        # If stream arrives before ACK (ACK loss/reordering),
+                        # treat it as a successful start.
+                        if msg_type == 'stream':
+                            ack_received = True
+                            output = msg.get('output', '')
+                            if output and output_callback:
+                                output_callback(output.encode('utf-8'), 'stdout')
+                            if msg.get('completed'):
+                                error = msg.get('error')
+                                if error and output_callback:
+                                    output_callback(error.encode('utf-8'), 'stderr')
+                                completed_during_handshake = True
+                            break
+                except socket.timeout:
+                    continue
+
+            if ack_received or error_response:
                 break
 
         if error_response:
             raise RuntimeError(error_response['error'])
 
         if not ack_received:
-            raise RuntimeError("No ACK from agent - run_interactive failed to start")
+            raise RuntimeError(f"No ACK from agent - run_interactive failed to start (attempts={max_attempts})")
+
+        if completed_during_handshake:
+            self.sock.settimeout(self.TIMEOUT)
+            return {"run": True, "completed": True}
 
         self.sock.settimeout(0.01)
         input_interval = 0.001
         last_input_time = 0
+        last_stream_time = time.time()
+        stream_timeout = 5.0  # 5 seconds without stream = connection lost
 
         try:
             while True:
@@ -181,6 +210,7 @@ class AgentClient:
                             msg = AgentProtocol.decode_message(data)
                             if msg and msg.get('seq') == seq:
                                 if msg.get('type') == 'stream':
+                                    last_stream_time = time.time()
                                     output = msg.get('output', '')
                                     if output and output_callback:
                                         output_callback(output.encode('utf-8'), 'stdout')
@@ -204,6 +234,10 @@ class AgentClient:
 
                 now = time.time()
 
+                # Check for stream reception timeout (connection loss detection)
+                if now - last_stream_time > stream_timeout:
+                    raise RuntimeError("Connection lost - no data from board for {}s".format(stream_timeout))
+
                 if now - last_input_time >= input_interval:
                     last_input_time = now
                     if input_provider:
@@ -225,6 +259,7 @@ class AgentClient:
                         if msg.get('type') == 'response' and msg.get('error'):
                             _pending_error = msg['error']
                         elif msg.get('type') == 'stream':
+                            last_stream_time = time.time()  # Update on any stream (even empty)
                             output = msg.get('output', '')
                             if output and output_callback:
                                 output_callback(output.encode('utf-8'), 'stdout')

{replx-1.8 → replx-1.10}/replx/cli/agent/client/session.py

@@ -4,14 +4,21 @@ import psutil
 
 def _find_terminal_process() -> Optional[dict]:
     shell_names = {
+        # Windows
         'powershell.exe', 'pwsh.exe', 'cmd.exe', 'bash.exe', 'zsh.exe', 'sh.exe', 'fish.exe',
         'windowsterminal.exe',
+        # Linux / macOS (no .exe)
+        'bash', 'zsh', 'sh', 'fish', 'tcsh', 'csh', 'ksh', 'dash', 'pwsh',
     }
 
     ide_names = {
+        # Windows
         'code.exe',
         'conemu64.exe', 'conemu.exe',
         'pycharm.exe', 'pycharm64.exe', 'idea.exe', 'idea64.exe',
+        # Linux / macOS (no .exe)
+        'code', 'code-oss',
+        'pycharm', 'pycharm64', 'idea', 'idea64',
     }
 
     try:

{replx-1.8 → replx-1.10}/replx/cli/agent/server/connection_manager.py

@@ -217,9 +217,10 @@ class ConnectionManager:
     def __init__(self):
         self._connections: Dict[str, BoardConnection] = {}
         self._connections_lock = threading.RLock()
+        # Per-port events used to serialize concurrent create_serial_connection
+        # calls for the same port (prevents double serial-open race).
+        self._port_creating: Dict[str, threading.Event] = {}
         self._default_port: Optional[str] = None
-        self._board_id_cache: Dict[str, Dict[str, str]] = {}
-        self._cache_lock = threading.Lock()
 
     @property
     def default_port(self) -> Optional[str]:
@@ -299,12 +300,32 @@ class ConnectionManager:
         original_port = str(port).strip() if port is not None else ""
         port_key = self._canon_port(original_port)
 
+        # --- Phase 1: fast check + race serialisation ---
         with self._connections_lock:
             if port_key in self._connections:
                 conn = self._connections[port_key]
                 if conn.is_connected():
                     return conn, None
+            # If another thread is already opening this port, get its event so
+            # we can wait for it instead of opening the same serial port twice.
+            if port_key in self._port_creating:
+                wait_event = self._port_creating[port_key]
+                our_event = None
+            else:
+                our_event = threading.Event()
+                self._port_creating[port_key] = our_event
+                wait_event = None
+
+        if wait_event is not None:
+            # Another thread is opening this port; wait then return its result.
+            wait_event.wait(timeout=30)
+            with self._connections_lock:
+                conn = self._connections.get(port_key)
+                if conn and conn.is_connected():
+                    return conn, None
+            return None, "Connection creation timed out (concurrent attempt)"
 
+        # --- Phase 2: we are the creator ---
         try:
             from replx.transport import create_transport
 
@@ -355,97 +376,17 @@ class ConnectionManager:
 
             with self._connections_lock:
                 self._connections[port_key] = conn
+                self._port_creating.pop(port_key, None)
 
+            our_event.set()  # wake any threads that raced with us
             return conn, None
 
         except Exception as e:
+            with self._connections_lock:
+                self._port_creating.pop(port_key, None)
+            our_event.set()  # unblock waiting threads so they get the error
             return None, str(e)
 
-    def ensure_board_id(self, port: str) -> Optional[str]:
-        conn = self.get_connection(port)
-        if not conn or not conn.repl_protocol:
-            return None
-        
-        if conn.board_id is not None:
-            return conn.board_id
-        
-        try:
-            result = conn.repl_protocol.exec("import machine; print(machine.unique_id().hex())")
-            if result:
-                if isinstance(result, bytes):
-                    result = result.decode('utf-8', errors='ignore')
-                result = result.strip()
-                if result:
-                    conn.board_id = result
-                    self._update_board_id_cache(port, conn.board_id)
-                    return conn.board_id
-        except Exception:
-            pass
-        
-        return None
-    
-    def _update_board_id_cache(self, port: str, board_id: str) -> None:
-        with self._cache_lock:
-            if board_id not in self._board_id_cache:
-                self._board_id_cache[board_id] = {}
-            
-            self._board_id_cache[board_id]["serial_port"] = self._canon_port(port)
-    
-    def find_conflicting_by_board_id(self, port: str) -> Optional[str]:
-        conn = self.get_connection(port)
-        if not conn or not conn.board_id:
-            return None
-        
-        with self._connections_lock:
-            for key, other_conn in self._connections.items():
-                if key == port:
-                    continue
-                
-                if not other_conn.is_connected():
-                    continue
-                
-                if other_conn.board_id is None:
-                    try:
-                        result = other_conn.repl_protocol.exec("import machine; print(machine.unique_id().hex())")
-                        if result:
-                            if isinstance(result, bytes):
-                                result = result.decode('utf-8', errors='ignore')
-                            result = result.strip()
-                            if result:
-                                other_conn.board_id = result
-                    except Exception:
-                        continue
-                
-                if other_conn.board_id and other_conn.board_id == conn.board_id:
-                    return key
-        
-        return None
-    
-    def resolve_board_conflict(self, port: str) -> Optional[str]:
-        board_id = self.ensure_board_id(port)
-        if not board_id:
-            return None
-        
-        conflicting_port = self.find_conflicting_by_board_id(port)
-        if conflicting_port:
-            self.disconnect(conflicting_port)
-            
-            conn = self.get_connection(port)
-            if conn and conn.repl_protocol:
-                try:
-                    transport = conn.repl_protocol.transport
-                    transport.write(CTRL_C)
-                    time.sleep(0.05)
-                    transport.write(CTRL_B)
-                    time.sleep(0.1)
-                    transport.reset_input_buffer()
-                except Exception:
-                    pass
-            
-            return conflicting_port
-        
-        return None
-
     def disconnect(self, port: str) -> bool:
         key = None
         with self._connections_lock:

{replx-1.8 → replx-1.10}/replx/cli/agent/server/core.py

@@ -334,7 +334,7 @@ class AgentServer(
         )
         self._datagram_transport = transport
         self.running = True
-        print(f'replx agent started — listening on {AGENT_HOST}:{self.agent_port} (UDP)')
+        print(f'replx agent started - listening on {AGENT_HOST}:{self.agent_port} (UDP)')
 
         heartbeat_task = asyncio.create_task(
             self._heartbeat_coro(), name='replx-heartbeat'
@@ -452,8 +452,16 @@ class AgentServer(
 
     def _check_and_record_seq(self, client_addr: tuple, seq: int) -> bool:
         with self._last_seq_lock:
-            if client_addr in self.last_seq and seq <= self.last_seq[client_addr]:
-                return False
+            if client_addr in self.last_seq:
+                last = self.last_seq[client_addr]
+                # Only reject exact duplicates from the same UDP source.
+                #
+                # Using strict monotonic ordering across client restarts can
+                # incorrectly drop valid requests (e.g. process restart, seq
+                # wrap, or source-port reuse), which then appears as
+                # "No ACK from agent" on the client.
+                if seq == last:
+                    return False
             self.last_seq[client_addr] = seq
             if len(self.last_seq) > self._MAX_LAST_SEQ:
                 oldest = next(iter(self.last_seq))
@@ -488,6 +496,12 @@ class AgentServer(
         command = msg.get('command')
 
         if not self._check_and_record_seq(client_addr, seq):
+            # Duplicate request (same seq from same UDP source): re-ACK so
+            # client retransmits can recover from a previously lost ACK.
+            self._safe_send(
+                AgentProtocol.encode_message(AgentProtocol.create_ack(seq)),
+                client_addr,
+            )
             return
 
         self._safe_send(
@@ -532,6 +546,11 @@ class AgentServer(
             
             if msg_type == 'request':
                 if not self._check_and_record_seq(client_addr, seq):
+                    # Duplicate request (same seq from same UDP source):
+                    # send ACK again so the client can proceed.
+                    ack = AgentProtocol.create_ack(seq)
+                    ack_data = AgentProtocol.encode_message(ack)
+                    self._safe_send(ack_data, client_addr)
                     return
             
             ack = AgentProtocol.create_ack(seq)

{replx-1.8 → replx-1.10}/replx/cli/agent/server/handlers/exec.py

@@ -232,6 +232,7 @@ class ExecCommandsMixin:
                     conn.interactive.thread = None
                 else:
                     send_error("Interactive session already active on this connection")
+                    conn.release()
                     return
         
         repl = conn.repl_protocol
@@ -242,6 +243,7 @@ class ExecCommandsMixin:
         if script_path:
             if not os.path.exists(script_path):
                 send_error(f"Script not found: {script_path}")
+                conn.release()
                 return
             with open(script_path, 'rb') as f:
                 script_data = f.read()
@@ -249,6 +251,7 @@ class ExecCommandsMixin:
             script_data = script_content.encode('utf-8') if isinstance(script_content, str) else script_content
         else:
             send_error("Either script_path or script_content required")
+            conn.release()
             return
         
         conn.interactive.start(ctx.ppid, seq, client_addr, echo)
@@ -282,19 +285,29 @@ class ExecCommandsMixin:
         output_buffer = bytearray()
         buffer_lock = threading.Lock()
         last_flush_time = [time.time()]
+        last_stream_send_time = [time.time()]
         flush_timer_running = [True]
         BUFFER_FLUSH_SIZE = 4096
         FLUSH_INTERVAL = 0.05
+        KEEPALIVE_INTERVAL = 1.0
         
         def send_stream(output: str = '', completed: bool = False, error: str = None):
-            try:
-                msg = {'type': 'stream', 'seq': seq, 'output': output}
-                if completed:
-                    msg['completed'] = True
-                    msg['error'] = error
-                self._safe_send(AgentProtocol.encode_message(msg), client_addr)
-            except Exception:
-                pass
+            # When script completes (especially with error), retry sending to ensure client receives it
+            retry_count = 5 if completed else 1
+            retry_interval = 0.05  # 50ms between retries for completed messages
+            
+            for attempt in range(retry_count):
+                try:
+                    msg = {'type': 'stream', 'seq': seq, 'output': output}
+                    if completed:
+                        msg['completed'] = True
+                        msg['error'] = error
+                    self._safe_send(AgentProtocol.encode_message(msg), client_addr)
+                    last_stream_send_time[0] = time.time()
+                    if completed and attempt < retry_count - 1:
+                        time.sleep(retry_interval)
+                except Exception:
+                    pass
         
         def flush_buffer():
             with buffer_lock:
@@ -332,6 +345,10 @@ class ExecCommandsMixin:
             while flush_timer_running[0]:
                 time.sleep(FLUSH_INTERVAL)
                 flush_buffer()
+                # Keep interactive session alive for client-side timeout logic,
+                # even when the script is running silently with no output.
+                if time.time() - last_stream_send_time[0] >= KEEPALIVE_INTERVAL:
+                    send_stream('')
         
         flush_thread = threading.Thread(target=flush_timer, daemon=True)
         flush_thread.start()
@@ -403,6 +420,19 @@ class ExecCommandsMixin:
     
     def _cmd_run_stop(self, ctx: CommandContext) -> dict:
         conn = ctx.connection
+
+        # RUN_STOP is in NON_REPL_COMMANDS so ctx.connection is always None.
+        # Resolve the connection directly via explicit_port or active interactive session.
+        if conn is None:
+            if ctx.explicit_port:
+                conn = _find_connection_by_port(self.connection_manager, ctx.explicit_port)
+            if conn is None:
+                # Find any connection that has an active interactive session owned by this ppid
+                for c in self.connection_manager.get_all_connections().values():
+                    if c.interactive.active and c.interactive.is_owner(ctx.ppid):
+                        conn = c
+                        break
+
         if not conn:
             return {"stopped": False, "reason": "Not connected"}
         

{replx-1.8 → replx-1.10}/replx/cli/agent/server/session_manager.py

@@ -217,6 +217,9 @@ class SessionManager:
             else:
                 os.kill(pid, 0)
                 return True
+        except PermissionError:
+            # Process exists but we lack permission to signal it — treat as alive.
+            return True
         except OSError:
             return False