replx 1.2__tar.gz → 1.3__tar.gz

replx-1.3/PKG-INFO

@@ -0,0 +1,25 @@
+Metadata-Version: 2.4
+Name: replx
+Version: 1.3
+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
+Project-URL: Homepage, https://github.com/PlanXLab/replx
+Project-URL: Repository, https://github.com/PlanXLab/replx
+Project-URL: Issues, https://github.com/PlanXLab/replx/issues
+Keywords: micropython,repl,serial,pyserial,typer,mpy-cross,deploy
+Classifier: Environment :: Console
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3 :: Only
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Software Development :: Embedded Systems
+Classifier: Topic :: System :: Hardware :: Universal Serial Bus (USB)
+Requires-Python: >=3.10
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: typer>=0.12
+Requires-Dist: rich>=13.0
+Requires-Dist: pyserial>=3.5
+Requires-Dist: mpy-cross>=1.26
+Requires-Dist: psutil>=5.9.0
+Dynamic: license-file

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

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

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

@@ -59,7 +59,6 @@ class AgentClient:
 
         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
 
         for attempt in range(max_attempts):
@@ -324,7 +323,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 +335,6 @@ class AgentClient:
                     startupinfo=startupinfo
                 )
             else:
-                # Unix: Use start_new_session for proper daemon behavior
                 subprocess.Popen(
                     cmd,
                     stdout=subprocess.DEVNULL,
@@ -367,10 +364,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.3}/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.3}/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.3}/replx/cli/agent/server/connection_manager.py

@@ -11,12 +11,6 @@ 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
@@ -168,7 +162,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 +201,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 +213,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 +230,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 +240,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 +291,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 +312,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 +338,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 +357,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 +380,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 +387,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 +411,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')
                     time.sleep(0.05)
-                    # Send Ctrl+B to enter Normal mode (exit Raw REPL if in it)
                     transport.write(b'\x02')
                     time.sleep(0.1)
-                    # Clear any pending data
                     transport.reset_input_buffer()
                 except Exception:
                     pass
@@ -519,19 +450,15 @@ 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
@@ -592,13 +519,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 +528,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

{replx-1.2 → replx-1.3}/replx/cli/agent/server/core.py

@@ -217,8 +217,6 @@ class AgentServer(
         if not port:
             raise ValueError("Port is required")
         
-        # Use ConnectionManager's create_serial_connection which properly detects device info
-        # before entering raw REPL mode
         board_conn, error = self.connection_manager.create_serial_connection(
             port=port,
             core=core,
@@ -278,12 +276,7 @@ class AgentServer(
         gc_counter = 0
         while self.running:
             time.sleep(HEARTBEAT_INTERVAL)
-            # IMPORTANT: While REPL/interactive session is active, suspend all
-            # heartbeat maintenance work (including zombie cleanup) to avoid
-            # interfering with long-running terminal interactions.
             all_conns = self.connection_manager.get_all_connections()
-            if all_conns and any(conn.interactive.active or conn.repl.active for conn in all_conns.values()):
-                continue
 
             zombie_check_counter += 1
             gc_counter += 1

{replx-1.2 → replx-1.3}/replx/cli/agent/server/handlers/exec.py

@@ -12,11 +12,6 @@ from ..connection_manager import BoardConnection
 
 
 def _normalize_port(port: str) -> str:
-    """Normalize port name for comparison.
-    
-    Windows: case-insensitive (COM10 == com10)
-    Linux/macOS: case-sensitive (/dev/ttyACM0 != /dev/TTYACM0)
-    """
     if sys.platform.startswith("win"):
         return port.upper()
     else:
@@ -24,16 +19,13 @@ def _normalize_port(port: str) -> str:
 
 
 def _find_connection_by_port(connection_manager, port: str) -> Optional[BoardConnection]:
-    """Find a connection by port, honoring Windows' case-insensitive semantics."""
     if not port:
         return None
 
-    # Try exact match first (preserve original port case where possible)
     conn = connection_manager.get_connection(port)
     if conn:
         return conn
 
-    # Windows: try normalized key, then case-insensitive scan
     if sys.platform.startswith("win"):
         normalized = _normalize_port(port)
         conn = connection_manager.get_connection(normalized)
@@ -69,7 +61,6 @@ class ExecCommandsMixin:
         elif ctx.ppid:
             conn = self._get_active_connection(ctx.ppid)
         
-        # Check if any connection is running a detached script
         all_connections = self.connection_manager.get_all_connections()
         any_detached = any(c.is_detached() for c in all_connections.values())
         
@@ -92,7 +83,6 @@ class ExecCommandsMixin:
                 "board_id": conn.board_id
             }
         
-        # If explicit port was requested but not found, do not fall back
         if ctx.explicit_port:
             return {
                 "running": True,
@@ -110,7 +100,11 @@ class ExecCommandsMixin:
             }
 
         if all_connections:
-            first_port, first_conn = next(iter(all_connections.items()))
+            default_port = getattr(self, '_default_port', None)
+            if default_port and default_port in all_connections:
+                first_port, first_conn = default_port, all_connections[default_port]
+            else:
+                first_port, first_conn = next(iter(all_connections.items()))
             is_this_detached = first_conn.is_detached()
             return {
                 "running": True,
@@ -149,7 +143,6 @@ class ExecCommandsMixin:
         self.connection_manager.disconnect_all()        
         self.session_manager.clear_all_sessions()
         
-        # Close socket to unblock _serve loop immediately
         if self.server_socket:
             try:
                 self.server_socket.close()
@@ -163,7 +156,6 @@ class ExecCommandsMixin:
         if not conn or not conn.repl_protocol:
             raise RuntimeError("Not connected")
         
-        # Stop any detached script on this connection before reset
         if conn.is_detached():
             self._stop_detached_script(conn)
         
@@ -215,7 +207,6 @@ class ExecCommandsMixin:
                 send_error("Interactive session already active on this connection")
                 return
         
-        # Reset board before running to ensure clean state
         repl = conn.repl_protocol
         if conn.is_detached():
             self._stop_detached_script(conn)
@@ -245,7 +236,6 @@ class ExecCommandsMixin:
         thread.start()
     
     def _safe_reset_repl(self, repl):
-        """Reset REPL to clean state after execution."""
         try:
             repl.interrupt()
             time.sleep(0.05)
@@ -294,15 +284,13 @@ class ExecCommandsMixin:
         def data_consumer(chunk: bytes):
             if not chunk:
                 return
-            # Filter control chars and raw REPL prompt
             filtered = chunk.replace(EOF_MARKER, b'').replace(b'\r', b'')
-            # Remove leading '>' (raw REPL prompt) from first chunk only
             if first_chunk[0] and filtered.startswith(b'>'):
                 filtered = filtered[1:]
                 first_chunk[0] = False
             elif first_chunk[0]:
                 first_chunk[0] = False
-            # Remove trailing '>' (raw REPL prompt after execution)
+
             if filtered.endswith(b'>'):
                 filtered = filtered[:-1]
             if not filtered:
@@ -360,7 +348,6 @@ class ExecCommandsMixin:
                 repl._exec(script_data, interactive=False, echo=False, detach=False, 
                           data_consumer=data_consumer)
             except ProtocolError as e:
-                # Store error but don't duplicate - will be sent via completed message
                 conn.interactive.error = str(e)
             finally:
                 input_thread_running[0] = False
@@ -368,7 +355,6 @@ class ExecCommandsMixin:
                 flush_buffer()
             
             conn.interactive.completed = True
-            # Send completion with error (error will be shown in panel, not duplicated in output)
             send_stream(completed=True, error=conn.interactive.error)
             self._safe_reset_repl(repl)
                 
@@ -383,7 +369,6 @@ class ExecCommandsMixin:
         finally:
             input_thread_running[0] = False
             flush_timer_running[0] = False
-            # Wait for threads to finish
             if input_thread.is_alive():
                 input_thread.join(timeout=0.5)
             conn.interactive.stop()
@@ -432,21 +417,16 @@ class ExecCommandsMixin:
         
         repl = conn.repl_protocol
         
-        # Reset board before running to ensure clean state (unlike exec which preserves state)
-        # Stop any detached script first
         if conn.is_detached():
             self._stop_detached_script(conn)
         
-        # Perform soft reset
         repl.reset()
         
-        # Wait for board to stabilize after reset
         time.sleep(0.1)
         
-        # Load script
         if script_path:
             if not os.path.exists(script_path):
-                raise FileNotFoundError(f"Script not found: {script_path}")
+                raise RuntimeError(f"Script not found: {script_path}")
             with open(script_path, 'rb') as f:
                 script_data = f.read()
             display_name = script_path
@@ -457,19 +437,16 @@ class ExecCommandsMixin:
             raise RuntimeError("Either script_path or script_content required")
         
         if detach:
-            # Non-interactive mode: send script and return immediately
             conn.busy = True
             conn.busy_command = 'detached_script'
             
             try:
-                # Ensure we're in normal REPL mode
                 try:
                     repl._leave_repl()
                 except Exception:
                     pass
                 repl._in_raw_repl = False
                 
-                # Clear any pending state
                 repl.interrupt()
                 time.sleep(0.05)
                 repl.interrupt()
@@ -478,7 +455,6 @@ class ExecCommandsMixin:
                 time.sleep(0.1)
                 repl.drain()
                 
-                # Enter paste mode and send script
                 repl.enter_paste_mode()
                 time.sleep(0.2)
                 repl.drain()
@@ -499,7 +475,6 @@ class ExecCommandsMixin:
                 conn.release()
                 raise RuntimeError(f"Script send failed: {e}")
         else:
-            # Blocking mode: execute and wait for result
             try:
                 script_code = script_data.decode('utf-8', errors='replace')
                 output = repl.exec(script_code)