replx 1.9__tar.gz → 1.10__tar.gz

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

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

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

@@ -1,5 +1,5 @@
 __all__ = ["__version__", "get_version", "__description__"]
-__version__ = "1.9"
+__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.9 → replx-1.10}/replx/cli/__init__.py

@@ -3,7 +3,6 @@ from .config import (
     ConfigManager, AgentPortManager, ConnectionResolver,
 )
 from replx.utils.constants import DEFAULT_AGENT_PORT, MIN_AGENT_PORT, MAX_AGENT_PORT
-from .app import app, main
 
 __all__ = [
     'RuntimeState', 'STATE', 'GLOBAL_OPTIONS',
@@ -11,3 +10,11 @@ __all__ = [
     '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.9 → 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'

{replx-1.9 → replx-1.10}/replx/cli/app.py

@@ -1,13 +1,14 @@
 import sys
+import importlib
 from typing import Optional
 import typer
 from rich.panel import Panel
 
+if __name__ == '__main__':
+    sys.modules['replx.cli.app'] = sys.modules[__name__]
+
 from replx import __version__
 from .helpers.output import OutputHelper, get_panel_box, CONSOLE_WIDTH
-from .helpers.updater import UpdateChecker
-from .helpers.environment import EnvironmentManager
-from .connection import _ensure_connected, _create_agent_client
 from .config import STATE, _set_global_options, _find_env_file, _get_theme_config
 
 
@@ -118,32 +119,43 @@ def _get_console():
     return OutputHelper.make_console(width=CONSOLE_WIDTH)
 
 
-try:
-    import typer.rich_utils
-    
-    def _patched_get_rich_console():
-        return _get_console()
-    
-    typer.rich_utils._get_rich_console = _patched_get_rich_console
-except ImportError:
-    pass
+_RICH_HELP_CONFIGURED = False
 
-try:
-    from typer.core import RichCommand
-    _original_rich_command_format_help = RichCommand.format_help
-    
-    def _format_help_width(self, ctx, formatter):
-        old_console = getattr(self, '_rich_console', None)
-        try:
-            self._rich_console = OutputHelper.make_console(width=CONSOLE_WIDTH)
-            return _original_rich_command_format_help(self, ctx, formatter)
-        finally:
-            if old_console is not None:
-                self._rich_console = old_console
-    
-    RichCommand.format_help = _format_help_width
-except ImportError:
-    pass
+
+def _configure_rich_help_rendering() -> None:
+    global _RICH_HELP_CONFIGURED
+    if _RICH_HELP_CONFIGURED:
+        return
+
+    try:
+        import typer.rich_utils
+
+        def _patched_get_rich_console():
+            return _get_console()
+
+        typer.rich_utils._get_rich_console = _patched_get_rich_console
+    except ImportError:
+        pass
+
+    try:
+        from typer.core import RichCommand
+
+        original_format_help = RichCommand.format_help
+
+        def _format_help_width(self, ctx, formatter):
+            old_console = getattr(self, '_rich_console', None)
+            try:
+                self._rich_console = OutputHelper.make_console(width=CONSOLE_WIDTH)
+                return original_format_help(self, ctx, formatter)
+            finally:
+                if old_console is not None:
+                    self._rich_console = old_console
+
+        RichCommand.format_help = _format_help_width
+    except ImportError:
+        pass
+
+    _RICH_HELP_CONFIGURED = True
 
 
 import click
@@ -303,6 +315,64 @@ app = typer.Typer(
 )
 
 
+_COMMAND_MODULES = {
+    'get': 'file',
+    'cat': 'file',
+    'put': 'file',
+    'ls': 'file',
+    'cp': 'file',
+    'mv': 'file',
+    'rm': 'file',
+    'mkdir': 'file',
+    'touch': 'file',
+    'setup': 'device',
+    'usage': 'device',
+    'scan': 'device',
+    'exec': 'exec',
+    'run': 'exec',
+    'repl': 'exec',
+    'shell': 'exec',
+    'reset': 'exec',
+    'pkg': 'package',
+    'mpy': 'package',
+    'version': 'utility',
+    'status': 'utility',
+    'fg': 'utility',
+    'whoami': 'utility',
+    'disconnect': 'utility',
+    'shutdown': 'utility',
+    'format': 'utility',
+    'init': 'utility',
+    'firmware': 'firmware',
+    'i2c': 'i2c',
+    'gpio': 'gpio',
+    'adc': 'adc',
+    'pwm': 'pwm',
+    'uart': 'uart',
+    'spi': 'spi',
+    'wifi': 'wifi',
+}
+_KNOWN_COMMANDS = set(_COMMAND_MODULES) | {'connect', 'help'}
+_LOADED_COMMAND_MODULES: set[str] = set()
+
+
+def _load_command_module(module_name: str) -> None:
+    if module_name in _LOADED_COMMAND_MODULES:
+        return
+
+    importlib.import_module(f'replx.cli.commands.{module_name}')
+    _LOADED_COMMAND_MODULES.add(module_name)
+
+
+def _load_required_command_module(command_name: Optional[str]) -> None:
+    if not command_name:
+        return
+
+    module_name = _COMMAND_MODULES.get(command_name)
+    if module_name:
+        _load_command_module(module_name)
+
+
 def _print_main_help():
     lines = []
     lines.append("[bold]MicroPython development tool for VSCode[/bold]")
@@ -384,16 +454,7 @@ def _print_main_help():
 
 
 def _get_known_commands() -> set[str]:
-    known = {'connect', 'help', 'version'}
-    for command_info in getattr(app, 'registered_commands', []):
-        name = getattr(command_info, 'name', None)
-        if name:
-            known.add(name)
-        callback = getattr(command_info, 'callback', None)
-        callback_name = getattr(callback, '__name__', None)
-        if callback_name:
-            known.add(callback_name)
-    return known
+    return set(_KNOWN_COMMANDS)
 
 
 @app.callback(invoke_without_command=True)
@@ -426,9 +487,6 @@ def cli(
         _print_main_help()
         raise typer.Exit()
 
-
-from .commands import file, device, exec, package, utility, firmware, i2c, gpio, adc, pwm, uart, spi, wifi
-
 def main():
     if len(sys.argv) == 1:
         OutputHelper.print_panel(
@@ -462,6 +520,8 @@ def main():
         command_str = sys.argv[2]
         
         try:
+            from .connection import _ensure_connected, _create_agent_client
+
             _ensure_connected()
             client = _create_agent_client()
             result = client.send_command('exec', code=command_str)
@@ -559,12 +619,21 @@ def main():
         first_nonopt_idx = next((i for i, a in enumerate(sys.argv[1:], 1) if not a.startswith('-')), None)
         first_nonopt = sys.argv[first_nonopt_idx] if first_nonopt_idx is not None else None
 
+    _load_required_command_module(first_nonopt)
+
     suppressed = {'scan'}
+    if any(x in sys.argv for x in ('--help', '-h')):
+        _configure_rich_help_rendering()
+
     if not any(x in sys.argv for x in ('--help','-h','--version','-v')):
         if (first_nonopt is None) or (first_nonopt not in suppressed):
+            from .helpers.updater import UpdateChecker
+
             UpdateChecker.check_for_updates(__version__)
         
     try:
+        from .helpers.environment import EnvironmentManager
+
         EnvironmentManager.load_env_from_rep()
         app(standalone_mode=False)
         exit_code = 0

{replx-1.9 → replx-1.10}/replx/cli/commands/device.py

@@ -23,7 +23,7 @@ from ..config import (
     _find_env_file, _find_or_create_vscode_dir,
     _read_env_ini,
     _update_connection_config, _find_available_agent_port, _find_running_agent_ports,
-    _get_global_options
+    _get_global_options, AgentPortManager
 )
 from ..connection import (
     _ensure_connected, _create_agent_client
@@ -141,17 +141,30 @@ def _load_jsonc(path: str) -> dict | None:
 
 
 def _get_portable_vscode_root_from_pshome() -> str | None:
+    cached_root = AgentPortManager._read_cached_vscode_root()
+    if cached_root:
+        return cached_root
+
     pshome = os.environ.get("PSHOME", "").strip()
     if not pshome:
         try:
+            run_kwargs = {
+                "capture_output": True,
+                "text": True,
+                "encoding": "utf-8",
+                "errors": "replace",
+                "timeout": 2,
+                "check": False,
+            }
+            if sys.platform.startswith("win"):
+                startupinfo = subprocess.STARTUPINFO()
+                startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+                startupinfo.wShowWindow = 0
+                run_kwargs["startupinfo"] = startupinfo
+                run_kwargs["creationflags"] = getattr(subprocess, "CREATE_NO_WINDOW", 0)
             result = subprocess.run(
                 ["pwsh", "-NoLogo", "-NoProfile", "-Command", "$PSHOME"],
-                capture_output=True,
-                text=True,
-                encoding="utf-8",
-                errors="replace",
-                timeout=2,
-                check=False,
+                **run_kwargs,
             )
             pshome = result.stdout.strip()
         except Exception:
@@ -160,7 +173,9 @@ def _get_portable_vscode_root_from_pshome() -> str | None:
     if not pshome:
         return None
 
-    return os.path.dirname(os.path.dirname(os.path.dirname(pshome)))
+    vscode_root = os.path.dirname(os.path.dirname(os.path.dirname(pshome)))
+    AgentPortManager._write_cached_vscode_root(vscode_root)
+    return vscode_root
 
 
 def _map_vscode_theme_to_replx(vscode_theme: str | None) -> str | None:
@@ -381,6 +396,12 @@ Run this once per project folder to set up your workspace.
         )
         raise typer.Exit(1)
 
+    stored_theme = selected_theme
+    theme_mode = None
+    if auto_theme and not theme:
+        stored_theme = display_theme
+        theme_mode = 'vscode-auto'
+
     if clean:
         _port = _get_global_options().get('port')
         if _port:
@@ -476,7 +497,8 @@ Run this once per project folder to set up your workspace.
                         env_path, port,
                         version=version, core=core, device=device,
                         manufacturer=manufacturer,
-                        theme=selected_theme,
+                        theme=stored_theme,
+                        theme_mode=theme_mode,
                         set_default=True
                     )
 
@@ -542,7 +564,8 @@ Run this once per project folder to set up your workspace.
                             env_path, port,
                             version=STATE.version, core=STATE.core, device=STATE.device,
                             manufacturer=STATE.manufacturer,
-                            theme=selected_theme,
+                            theme=stored_theme,
+                            theme_mode=theme_mode,
                             set_default=True 
                         )
                         
@@ -680,7 +703,8 @@ Run this once per project folder to set up your workspace.
         core=STATE.core,
         device=STATE.device,
         manufacturer=STATE.manufacturer,
-        theme=selected_theme,
+        theme=stored_theme,
+        theme_mode=theme_mode,
         set_default=set_as_default
     )
     

{replx-1.9 → replx-1.10}/replx/cli/commands/exec.py

@@ -29,9 +29,6 @@ from ..connection import (
 
 from ..app import app
 
-from .file import ls, cat, cp, mv, rm, mkdir, touch
-from .device import usage
-
 
 def _wrap_trailing_expression_for_print(code: str) -> str:
     try:
@@ -1637,6 +1634,9 @@ Use familiar commands (ls, cd, cat, etc.) without typing "replx" each time.
         raise typer.Exit()
     
     _ensure_connected()
+
+    from .device import usage
+    from .file import cat, cp, ls, mkdir, mv, rm, touch
     
     SHELL_COMMANDS = {
         'ls', 'cat', 'cp', 'mv', 'rm', 'mkdir', 'touch', 'usage', 'exec', 'repl', 'run',

{replx-1.9 → replx-1.10}/replx/cli/commands/file.py

@@ -1799,6 +1799,16 @@ Upload files or directories from your computer to the device.
     
     client = _create_agent_client()
 
+    def _exit_upload_error(error: RuntimeError) -> None:
+        if OutputHelper.handle_error(error, "Upload"):
+            raise typer.Exit(1)
+        OutputHelper.print_panel(
+            f"Upload failed: [red]{error}[/red]",
+            title="Upload Failed",
+            border_style="red"
+        )
+        raise typer.Exit(1)
+
     def ensure_remote_dir_tree(dir_path: str) -> None:
         normalized = OutputHelper.normalize_remote_path(dir_path).rstrip('/')
         if not normalized:
@@ -1837,7 +1847,10 @@ Upload files or directories from your computer to the device.
 
         target_dir = remote if is_remote_dir else posixpath.dirname(remote_path)
         if target_dir and target_dir != '/':
-            ensure_remote_dir_tree(target_dir)
+            try:
+                ensure_remote_dir_tree(target_dir)
+            except RuntimeError as e:
+                _exit_upload_error(e)
         
         display_remote = remote_path.replace(device_root_fs, "", 1)
         item_type = "Directory" if is_dir else "File"
@@ -1914,6 +1927,8 @@ Upload files or directories from your computer to the device.
                 border_style="green"
             )
         except Exception as e:
+            if isinstance(e, RuntimeError):
+                _exit_upload_error(e)
             OutputHelper.print_panel(
                 f"Upload failed: [red]{str(e)}[/red]",
                 title="Upload Failed",
@@ -1930,7 +1945,10 @@ Upload files or directories from your computer to the device.
             raise typer.Exit(1)
 
         if remote and remote != '/':
-            ensure_remote_dir_tree(remote)
+            try:
+                ensure_remote_dir_tree(remote)
+            except RuntimeError as e:
+                _exit_upload_error(e)
         
         def count_bytes(path):
             if os.path.isfile(path):
@@ -2051,6 +2069,13 @@ Upload files or directories from your computer to the device.
                         ))
                         break 
                         
+                    except RuntimeError as e:
+                        if retry == max_retries - 1:
+                            if OutputHelper.handle_error(e, f"Upload: {remote_path}"):
+                                raise typer.Exit(1)
+                            OutputHelper._console.print(f"[red]Failed to upload {base_name}: {str(e)}[/red]")
+                        else:
+                            time.sleep(0.2)
                     except Exception as e:
                         if retry == max_retries - 1:
                             OutputHelper._console.print(f"[red]Failed to upload {base_name}: {str(e)}[/red]")

{replx-1.9 → replx-1.10}/replx/cli/commands/utility.py

@@ -29,7 +29,6 @@ from ..connection import (
     _get_current_agent_port
 )
 from ..app import app
-from .package import _install_spec_internal
 
 
 def _port_sort_key(port: str) -> tuple:
@@ -1291,6 +1290,8 @@ Completely reset device: format filesystem and install all libraries.
     
     try:
         specs_to_install = ["core.all"]
+
+        from .package import _install_spec_internal
         
         dev_src = os.path.join(StoreManager.pkg_root(), "device", device_name_to_path(STATE.device), "src")
         if os.path.isdir(dev_src):

{replx-1.9 → replx-1.10}/replx/cli/config.py

@@ -204,6 +204,7 @@ class ConfigManager:
                           serial_port: str = None,
                           agent_port: int = None,
                           theme: str = None,
+                          theme_mode: str = None,
                           set_default: bool = False):
 
         def _resolve_os_serial_port_name(port: str) -> str:
@@ -286,6 +287,7 @@ class ConfigManager:
 
         if theme is not None:
             AgentPortManager._write_registered_theme(theme)
+            AgentPortManager._write_registered_theme_mode(theme_mode)
         
         ConfigManager.write(env_path, env_data['connections'], env_data['default'])
     
@@ -296,18 +298,25 @@ class ConfigManager:
 
     @staticmethod
     def get_theme(env_path: str | None = None) -> str:
+        theme_mode = AgentPortManager._read_registered_theme_mode()
+        if theme_mode:
+            return theme_mode
+
         theme = AgentPortManager._read_registered_theme(legacy_env_path=env_path)
         return theme or 'dark'
 
     @staticmethod
-    def set_theme(env_path: str | None, theme: str):
+    def set_theme(env_path: str | None, theme: str, theme_mode: str | None = None):
         AgentPortManager._write_registered_theme(theme)
+        AgentPortManager._write_registered_theme_mode(theme_mode)
 
 
 class AgentPortManager:
 
     _AGENT_PORT_KEY = 'AGENT_PORT'
     _THEME_KEY = 'THEME'
+    _THEME_MODE_KEY = 'THEME_MODE'
+    _VSCODE_ROOT_KEY = 'VSCODE_ROOT'
 
     @staticmethod
     def _kill_agent_process_by_port(port: int) -> bool:
@@ -341,20 +350,49 @@ class AgentPortManager:
 
         return min(running_ports)
 
+    _singleton_cache: Optional[int] = None
+    _singleton_cache_miss: bool = False
+
     @staticmethod
     def _ensure_singleton_running_agent(preferred_port: Optional[int] = None) -> Optional[int]:
         from .agent.client import AgentClient
 
+        # Process-level cache: ``_ensure_connected`` calls this twice in the same
+        # CLI invocation. The set of running agents cannot change between those
+        # back-to-back calls, so reuse the prior result.
+        if AgentPortManager._singleton_cache is not None:
+            return AgentPortManager._singleton_cache
+        if AgentPortManager._singleton_cache_miss:
+            return None
+
+        # Fast path: if the preferred / registered / default port already responds
+        # to a ping, skip the slow scan-and-cleanup phase. Stale agent processes
+        # left from previous sessions can otherwise add ~0.3s per dead candidate
+        # (UDP probe timeout) on every CLI invocation. Singleton enforcement and
+        # zombie cleanup still happen on cold paths (setup / shutdown) where the
+        # priority candidate is unreachable.
+        registered_port = AgentPortManager._read_registered_port()
+        for candidate in (preferred_port, registered_port, DEFAULT_AGENT_PORT):
+            if not isinstance(candidate, int):
+                continue
+            if AgentClient.is_agent_running(port=candidate):
+                AgentPortManager._singleton_cache = candidate
+                if registered_port != candidate:
+                    AgentPortManager._write_registered_port(candidate)
+                return candidate
+
         running_ports = []
         for port in AgentPortManager._get_candidate_agent_ports(preferred_port=preferred_port):
             if AgentClient.is_agent_running(port=port):
                 running_ports.append(port)
 
         if not running_ports:
+            AgentPortManager._singleton_cache_miss = True
             return None
 
         primary_port = AgentPortManager._pick_primary_port(running_ports, preferred_port=preferred_port)
         if primary_port is None:
+            AgentPortManager._singleton_cache_miss = True
             return None
 
         for port in running_ports:
@@ -382,6 +420,7 @@ class AgentPortManager:
             )
 
         AgentPortManager._write_registered_port(primary_port)
+        AgentPortManager._singleton_cache = primary_port
         return primary_port
 
     @staticmethod
@@ -482,6 +521,14 @@ class AgentPortManager:
 
         return None
 
+    @staticmethod
+    def _read_registered_theme_mode() -> Optional[str]:
+        config_entries = AgentPortManager._read_agent_config()
+        theme_mode = config_entries.get(AgentPortManager._THEME_MODE_KEY)
+        if theme_mode:
+            return theme_mode.strip() or None
+        return None
+
     @staticmethod
     def _write_registered_theme(theme: Optional[str]) -> None:
         if theme is None:
@@ -495,6 +542,54 @@ class AgentPortManager:
         entries[AgentPortManager._THEME_KEY] = normalized
         AgentPortManager._write_agent_config(entries)
 
+    @staticmethod
+    def _write_registered_theme_mode(theme_mode: Optional[str]) -> None:
+        entries = AgentPortManager._read_agent_config()
+
+        if theme_mode is None:
+            entries.pop(AgentPortManager._THEME_MODE_KEY, None)
+            AgentPortManager._write_agent_config(entries)
+            return
+
+        normalized = str(theme_mode).strip()
+        if not normalized:
+            entries.pop(AgentPortManager._THEME_MODE_KEY, None)
+            AgentPortManager._write_agent_config(entries)
+            return
+
+        entries[AgentPortManager._THEME_MODE_KEY] = normalized
+        AgentPortManager._write_agent_config(entries)
+
+    @staticmethod
+    def _read_cached_vscode_root() -> Optional[str]:
+        entries = AgentPortManager._read_agent_config()
+        root = entries.get(AgentPortManager._VSCODE_ROOT_KEY)
+        if not root:
+            return None
+
+        settings_path = os.path.join(root, 'data', 'user-data', 'User', 'settings.json')
+        if os.path.exists(settings_path):
+            return root
+
+        return None
+
+    @staticmethod
+    def _write_cached_vscode_root(root: Optional[str]) -> None:
+        if root is None:
+            return
+
+        normalized = str(root).strip()
+        if not normalized:
+            return
+
+        settings_path = os.path.join(normalized, 'data', 'user-data', 'User', 'settings.json')
+        if not os.path.exists(settings_path):
+            return
+
+        entries = AgentPortManager._read_agent_config()
+        entries[AgentPortManager._VSCODE_ROOT_KEY] = normalized
+        AgentPortManager._write_agent_config(entries)
+
     @staticmethod
     def _can_bind_port(port: Optional[int]) -> bool:
         if not isinstance(port, int) or not (MIN_AGENT_PORT <= port <= MAX_AGENT_PORT):
@@ -732,8 +827,8 @@ def _get_default_connection(env_path: str) -> Optional[str]:
 def _get_theme_config(env_path: str | None = None) -> str:
     return ConfigManager.get_theme(env_path)
 
-def _set_theme_config(env_path: str | None, theme: str):
-    return ConfigManager.set_theme(env_path, theme)
+def _set_theme_config(env_path: str | None, theme: str, theme_mode: str | None = None):
+    return ConfigManager.set_theme(env_path, theme, theme_mode)
 
 def _find_available_agent_port(env_path: str) -> int:
     return AgentPortManager.find_available_port(env_path)