replx 1.2__tar.gz → 1.4__tar.gz

{replx-1.2/replx.egg-info → replx-1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: replx
-Version: 1.2
+Version: 1.4
 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

{replx-1.2 → replx-1.4}/replx/__init__.py

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

{replx-1.2 → replx-1.4}/replx/cli/agent/client/core.py

@@ -33,7 +33,7 @@ class AgentClient:
             self.sock.close()
             self.sock = None
 
-    def send_command(self, command: str, timeout: float = None, **args) -> Dict[str, Any]:
+    def send_command(self, command: str, timeout: float = None, max_retries: int = None, **args) -> Dict[str, Any]:
         if not self.sock:
             self.connect()
 
@@ -58,9 +58,11 @@ class AgentClient:
         request_data = AgentProtocol.encode_message(request)
 
         response = None
-        
-        # For short timeouts (< 1s), don't retry to fail fast (e.g., ping/agent check)
-        max_attempts = 1 if effective_timeout < 1.0 else self.MAX_RETRIES
+
+        if max_retries is not None:
+            max_attempts = max(1, max_retries)
+        else:
+            max_attempts = 1 if effective_timeout < 1.0 else self.MAX_RETRIES
 
         for attempt in range(max_attempts):
             try:
@@ -155,7 +157,6 @@ class AgentClient:
         self.sock.settimeout(0.01)
         input_interval = 0.001
         last_input_time = 0
-        error_check_until = time.time() + 0.1
 
         try:
             while True:
@@ -180,15 +181,15 @@ class AgentClient:
                         except Exception:
                             pass
 
+                _pending_error = None
                 try:
                     data, addr = self.sock.recvfrom(MAX_UDP_SIZE)
                     msg = AgentProtocol.decode_message(data)
 
                     if msg and msg.get('seq') == seq:
-                        if now < error_check_until and msg.get('type') == 'response' and msg.get('error'):
-                            raise RuntimeError(msg['error'])
-
-                        if msg.get('type') == 'stream':
+                        if msg.get('type') == 'response' and msg.get('error'):
+                            _pending_error = msg['error']
+                        elif msg.get('type') == 'stream':
                             output = msg.get('output', '')
                             if output and output_callback:
                                 output_callback(output.encode('utf-8'), 'stdout')
@@ -204,6 +205,9 @@ class AgentClient:
                 except Exception:
                     pass
 
+                if _pending_error:
+                    raise RuntimeError(_pending_error)
+
         except KeyboardInterrupt:
             try:
                 self.send_command(Cmd.RUN_STOP, timeout=0.5)
@@ -324,7 +328,6 @@ class AgentClient:
 
         if background:
             if sys.platform == 'win32':
-                # Windows: Use DETACHED_PROCESS to run without console
                 startupinfo = subprocess.STARTUPINFO()
                 startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
                 startupinfo.wShowWindow = 0
@@ -337,7 +340,6 @@ class AgentClient:
                     startupinfo=startupinfo
                 )
             else:
-                # Unix: Use start_new_session for proper daemon behavior
                 subprocess.Popen(
                     cmd,
                     stdout=subprocess.DEVNULL,
@@ -367,10 +369,9 @@ class AgentClient:
         except Exception:
             pass
 
-        # Wait for agent to stop, but with faster polling
         start_time = time.time()
         while time.time() - start_time < timeout:
-            time.sleep(0.05)  # Shorter sleep for faster response
+            time.sleep(0.05) 
             if not AgentClient.is_agent_running(port=port):
                 return True
 

{replx-1.2 → replx-1.4}/replx/cli/agent/client/session.py

@@ -3,7 +3,6 @@ from typing import Optional
 import psutil
 
 def _find_terminal_process() -> Optional[dict]:
-    # Prefer actual shell processes (per-terminal) over host IDE processes (shared).
     shell_names = {
         'powershell.exe', 'pwsh.exe', 'cmd.exe', 'bash.exe', 'zsh.exe', 'sh.exe', 'fish.exe',
         'windowsterminal.exe',
@@ -15,7 +14,6 @@ def _find_terminal_process() -> Optional[dict]:
         'pycharm.exe', 'pycharm64.exe', 'idea.exe', 'idea64.exe',
     }
 
-    # Fast path: parent pid is typically the actual terminal/shell.
     try:
         parent_pid = os.getppid()
         if parent_pid and parent_pid > 0:
@@ -30,7 +28,6 @@ def _find_terminal_process() -> Optional[dict]:
                     'level': 0,
                 }
     except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess, OSError):
-        # Fall back to a broader traversal.
         pass
 
     try:
@@ -56,7 +53,6 @@ def _find_terminal_process() -> Optional[dict]:
                 }
 
             if name in ide_names and best_ide is None:
-                # Keep as last resort (may be shared across terminals).
                 try:
                     best_ide = {
                         'pid': current.pid,
@@ -87,7 +83,6 @@ def _find_terminal_process() -> Optional[dict]:
             return best_ide
 
     except Exception:
-        # Never allow session id discovery to fail hard.
         pass
 
     return None
@@ -122,26 +117,6 @@ def _find_jupyter_kernel() -> Optional[dict]:
 
     return None
 
-def _detect_environment() -> str:
-    try:
-        __IPYTHON__
-        return 'ipython'
-    except NameError:
-        pass
-
-    env = os.environ
-
-    if any(key.startswith('JPY_') or 'JUPYTER' in key for key in env):
-        return 'jupyter'
-
-    if env.get('TERM_PROGRAM') == 'vscode':
-        return 'vscode_terminal'
-
-    if env.get('SHELL') or env.get('TERM'):
-        return 'terminal'
-
-    return 'unknown'
-
 def get_session_id() -> int:
     terminal = _find_terminal_process()
     if terminal:

{replx-1.2 → replx-1.4}/replx/cli/agent/protocol.py

@@ -6,14 +6,11 @@ from typing import Dict, Any, Optional, List
 
 from replx.utils.constants import MAX_PAYLOAD_SIZE
 
-# Protocol constants
 _MAGIC = b'RPLX'
 _VERSION = 1
 
 
 class AgentProtocol:
-    """UDP protocol for agent client-server communication."""
-
     @staticmethod
     def encode_message(msg: Dict[str, Any]) -> bytes:
         payload = json.dumps(msg).encode('utf-8')

{replx-1.2 → replx-1.4}/replx/cli/agent/server/connection_manager.py

@@ -2,31 +2,27 @@ import re
 import sys
 import time
 import threading
+from concurrent.futures import Future as ConcurrentFuture
 from dataclasses import dataclass, field
 from typing import Optional, Dict, Any, List, Tuple
 
 from replx.protocol import ReplProtocol, create_storage
 from replx.utils import parse_device_banner
+from replx.utils.constants import CTRL_B, CTRL_C
 from replx.utils.exceptions import TransportError
 
 
 def _detect_device_info(transport, core: str, device: str = None) -> Tuple[str, str, str, str]:
-    """Detect device information from transport.
-    
-    Returns:
-        Tuple of (version, core, device, manufacturer)
-    """
-    # Use shorter delays on Unix for faster failure on invalid ports
     delay1 = 0.05 if sys.platform != "win32" else 0.1
     delay2 = 0.1 if sys.platform != "win32" else 0.2
     delay3 = 0.1 if sys.platform != "win32" else 0.2
     
     try:
-        transport.write(b'\r\x03')
+        transport.write(b'\r' + CTRL_C)
         time.sleep(delay1)
         transport.reset_input_buffer()
 
-        transport.write(b'\r\x02')
+        transport.write(b'\r' + CTRL_B)
         time.sleep(delay2)
 
         res = transport.read_available()
@@ -110,6 +106,7 @@ class InteractiveSessionState:
 class ReplSessionState:
     active: bool = False
     ppid: Optional[int] = None
+    reader_future: Optional[ConcurrentFuture] = None
     reader_thread: Optional[threading.Thread] = None
     output_buffer: bytes = b""
     buffer_lock: threading.Lock = field(default_factory=threading.Lock)
@@ -123,6 +120,9 @@ class ReplSessionState:
     def stop(self):
         self.active = False
         self.ppid = None
+        if self.reader_future is not None:
+            self.reader_future.cancel()
+            self.reader_future = None
         if self.reader_thread:
             self.reader_thread.join(timeout=1)
             self.reader_thread = None
@@ -158,7 +158,6 @@ class BoardConnection:
     version: str = "?"
     device_root_fs: str = "/"
     
-    # Unique board ID from machine.unique_id().hex() - lazy evaluated on first command
     board_id: Optional[str] = None
 
     busy: bool = False
@@ -168,7 +167,6 @@ class BoardConnection:
     last_command_time: float = field(default_factory=time.time)
     _busy_lock: threading.Lock = field(default_factory=threading.Lock)
     
-    # Detached script state (per-connection)
     detached_running: bool = False
     _detached_lock: threading.Lock = field(default_factory=threading.Lock)
     _drain_thread: Optional[threading.Thread] = field(default=None, repr=False)
@@ -208,7 +206,6 @@ class BoardConnection:
             self.busy_client = None
     
     def stop_detached(self):
-        """Stop detached script and drain thread for this connection."""
         with self._detached_lock:
             self.detached_running = False
         
@@ -221,7 +218,6 @@ class ConnectionManager:
         self._connections: Dict[str, BoardConnection] = {}
         self._connections_lock = threading.RLock()
         self._default_port: Optional[str] = None
-        # Cache: maps board_id -> {serial_port}
         self._board_id_cache: Dict[str, Dict[str, str]] = {}
         self._cache_lock = threading.Lock()
 
@@ -239,11 +235,6 @@ class ConnectionManager:
 
     @staticmethod
     def _canon_port(port: Optional[str]) -> Optional[str]:
-        """Canonicalize port keys for internal storage/lookup.
-
-        On Windows, COM ports are case-insensitive; we canonicalize COMx to
-        uppercase so all commands behave consistently.
-        """
         if port is None:
             return None
         p = str(port).strip()
@@ -254,7 +245,6 @@ class ConnectionManager:
         return p
 
     def _resolve_existing_key(self, port: str) -> Optional[str]:
-        """Return the stored key matching `port`, possibly case-insensitively on Windows."""
         if port is None:
             return None
         p = self._canon_port(port)
@@ -306,7 +296,6 @@ class ConnectionManager:
         device: str = None,
         baudrate: int = 115200
     ) -> Tuple[BoardConnection, Optional[str]]:
-        # Store port
         original_port = str(port).strip() if port is not None else ""
         port_key = self._canon_port(original_port)
 
@@ -328,13 +317,10 @@ class ConnectionManager:
             repl_protocol = ReplProtocol(transport)
 
             device_root_fs = "/"
-            # Skip filesystem check if detection already failed (version is "?")
-            # This speeds up failure on invalid ports
             if version != "?":
                 try:
                     result = repl_protocol.exec("import os; print(os.getcwd())")
                     if result:
-                        # exec() returns bytes, decode to string
                         if isinstance(result, bytes):
                             result = result.decode('utf-8', errors='ignore')
                         cwd = result.strip() if result else "/"
@@ -357,7 +343,7 @@ class ConnectionManager:
             )
 
             conn = BoardConnection(
-                port=port_key,  # Canonical key (Windows COM ports uppercased)
+                port=port_key,
                 repl_protocol=repl_protocol,
                 file_system=file_system,
                 core=detected_core,
@@ -376,35 +362,21 @@ class ConnectionManager:
             return None, str(e)
 
     def ensure_board_id(self, port: str) -> Optional[str]:
-        """
-        Lazily query and cache the board's unique ID.
-        Uses machine.unique_id().hex() to get a consistent ID.
-        
-        Args:
-            port: The connection key
-            
-        Returns:
-            The board_id string, or None if query failed
-        """
         conn = self.get_connection(port)
         if not conn or not conn.repl_protocol:
             return None
         
-        # Return cached value if already queried
         if conn.board_id is not None:
             return conn.board_id
         
         try:
-            # Query machine.unique_id().hex()
             result = conn.repl_protocol.exec("import machine; print(machine.unique_id().hex())")
             if result:
-                # exec() returns bytes, decode to string
                 if isinstance(result, bytes):
                     result = result.decode('utf-8', errors='ignore')
                 result = result.strip()
                 if result:
                     conn.board_id = result
-                    # Update board_id cache
                     self._update_board_id_cache(port, conn.board_id)
                     return conn.board_id
         except Exception:
@@ -413,9 +385,6 @@ class ConnectionManager:
         return None
     
     def _update_board_id_cache(self, port: str, board_id: str) -> None:
-        """
-        Update the board_id cache with port mapping.
-        """
         with self._cache_lock:
             if board_id not in self._board_id_cache:
                 self._board_id_cache[board_id] = {}
@@ -423,37 +392,22 @@ class ConnectionManager:
             self._board_id_cache[board_id]["serial_port"] = self._canon_port(port)
     
     def find_conflicting_by_board_id(self, port: str) -> Optional[str]:
-        """
-        Find conflicting connection by comparing board IDs.
-        This is called after ensure_board_id() to detect if the same board
-        is already connected via a different transport.
-        
-        Args:
-            port: The current connection key
-            
-        Returns:
-            The conflicting connection's port key, or None if no conflict
-        """
         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():
-                # Skip self
                 if key == port:
                     continue
                 
-                # Skip disconnected
                 if not other_conn.is_connected():
                     continue
                 
-                # Ensure other connection's board_id is queried
                 if other_conn.board_id is None:
                     try:
                         result = other_conn.repl_protocol.exec("import machine; print(machine.unique_id().hex())")
                         if result:
-                            # exec() returns bytes, decode to string
                             if isinstance(result, bytes):
                                 result = result.decode('utf-8', errors='ignore')
                             result = result.strip()
@@ -462,46 +416,28 @@ class ConnectionManager:
                     except Exception:
                         continue
                 
-                # Compare board IDs
                 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]:
-        """
-        Check for board conflicts using board_id and automatically disconnect
-        the conflicting connection.
-        
-        Args:
-            port: The current connection key
-            
-        Returns:
-            The disconnected port key, or None if no conflict was found/resolved
-        """
-        # First, ensure board_id is queried for this connection
         board_id = self.ensure_board_id(port)
         if not board_id:
             return None
         
-        # Find any conflicting connection
         conflicting_port = self.find_conflicting_by_board_id(port)
         if conflicting_port:
-            # Auto-disconnect the older connection
             self.disconnect(conflicting_port)
             
-            # Reset REPL state of the new connection
             conn = self.get_connection(port)
             if conn and conn.repl_protocol:
                 try:
-                    transport = conn.repl_protocol._transport
-                    # Send Ctrl+C to interrupt any ongoing operation
-                    transport.write(b'\x03')
+                    transport = conn.repl_protocol.transport
+                    transport.write(CTRL_C)
                     time.sleep(0.05)
-                    # Send Ctrl+B to enter Normal mode (exit Raw REPL if in it)
-                    transport.write(b'\x02')
+                    transport.write(CTRL_B)
                     time.sleep(0.1)
-                    # Clear any pending data
                     transport.reset_input_buffer()
                 except Exception:
                     pass
@@ -519,23 +455,24 @@ class ConnectionManager:
 
             conn = self._connections.pop(key)
 
-        # Stop detached script first (this waits for drain thread)
         conn.stop_detached()
 
-        # Stop REPL/interactive workers before transport close to release serial handle promptly.
         if conn.repl.active:
             conn.repl.stop()
         if conn.interactive.active:
             conn.interactive.stop()
         
-        # Release busy state
         conn.release()
 
-        # Close transport outside the lock to avoid potential deadlocks
         if conn.repl_protocol:
             try:
-                transport = conn.repl_protocol._transport
+                transport = conn.repl_protocol.transport
                 if transport:
+                    try:
+                        transport.write(CTRL_B)
+                        time.sleep(0.1 if sys.platform == 'win32' else 0.05)
+                    except Exception:
+                        pass
                     transport.close()
             except Exception:
                 pass
@@ -592,13 +529,6 @@ class ConnectionManager:
         return conn.busy if conn else False
 
     def check_health(self, port: str) -> bool:
-        """Check if the connection to the specified port is still healthy.
-        
-        This method actively tests the serial port to detect disconnection.
-        
-        Returns:
-            True if the connection is healthy, False otherwise.
-        """
         conn = self.get_connection(port)
         if not conn or not conn.repl_protocol:
             return False
@@ -608,14 +538,11 @@ class ConnectionManager:
             if not transport:
                 return False
             
-            # Use check_connection which actively probes the port
             if hasattr(transport, 'check_connection'):
                 return transport.check_connection()
             
-            # Fallback: check is_open property
             return transport.is_open
         except TransportError:
-            # Serial port has been disconnected
             return False
         except Exception:
             return False