replx 1.1.1__tar.gz → 1.3__tar.gz

{replx-1.1.1 → replx-1.3}/LICENSE

@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2024 chanmin.park
+Copyright (c) 2024-2026 chanmin.park
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal

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.1.1 → replx-1.3}/pyproject.toml

@@ -10,13 +10,13 @@ readme = "README.md"
 authors = [{ name = "chanmin.park", email = "devcamp@gmail.com" }]
 requires-python = ">=3.10"
 keywords = ["micropython", "repl", "serial", "pyserial", "typer", "mpy-cross", "deploy"]
-license = { file = "LICENSE" }
+license = "MIT"
+license-files = ["LICENSE"]
 
 classifiers = [
   "Environment :: Console",
   "Programming Language :: Python :: 3",
   "Programming Language :: Python :: 3 :: Only",
-  "License :: OSI Approved :: MIT License",
   "Operating System :: OS Independent",
   "Topic :: Software Development :: Embedded Systems",
   "Topic :: System :: Hardware :: Universal Serial Bus (USB)",
@@ -27,19 +27,26 @@ dependencies = [
   "rich>=13.0",
   "pyserial>=3.5",
   "mpy-cross>=1.26",
+  "psutil>=5.9.0",
 ]
 
+[project.optional-dependencies]
+
 [project.urls]
 Homepage = "https://github.com/PlanXLab/replx"
 Repository = "https://github.com/PlanXLab/replx"
 Issues = "https://github.com/PlanXLab/replx/issues"
 
 [project.scripts]
-replx = "replx.replx:main"
+replx = "replx.cli.app:main"
+rx = "replx.cli.app:main"
 
 [tool.setuptools.packages.find]
 where = ["."]
 include = ["replx*"]
 
+[tool.setuptools.package-data]
+replx = ["typehints/**/*.pyi"]
+
 [tool.setuptools.dynamic]
 version = { attr = "replx.__init__.__version__" }

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

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

replx-1.3/replx/cli/__init__.py

@@ -0,0 +1,13 @@
+from .config import (
+    RuntimeState, STATE, GLOBAL_OPTIONS,
+    ConfigManager, AgentPortManager, ConnectionResolver,
+)
+from replx.utils.constants import DEFAULT_AGENT_PORT, MAX_AGENT_PORT
+from .app import app, main
+
+__all__ = [
+    'RuntimeState', 'STATE', 'GLOBAL_OPTIONS',
+    'ConfigManager', 'AgentPortManager', 'ConnectionResolver',
+    'DEFAULT_AGENT_PORT', 'MAX_AGENT_PORT',
+    'app', 'main'
+]

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

@@ -0,0 +1,14 @@
+
+from .protocol import AgentProtocol
+from .client import AgentClient, get_session_id, get_cached_session_id, clear_session_cache
+from .server import AgentServer, main as agent_main
+
+__all__ = [
+    'AgentProtocol',
+    'AgentClient',
+    'get_session_id',
+    'get_cached_session_id',
+    'clear_session_cache',
+    'AgentServer',
+    'agent_main',
+]

replx-1.3/replx/cli/agent/client/__init__.py

@@ -0,0 +1,14 @@
+
+from .core import AgentClient
+from .session import (
+    get_session_id,
+    get_cached_session_id,
+    clear_session_cache
+)
+
+__all__ = [
+    'AgentClient',
+    'get_session_id',
+    'get_cached_session_id',
+    'clear_session_cache'
+]

replx-1.3/replx/cli/agent/client/core.py

@@ -0,0 +1,373 @@
+import os
+import sys
+import socket
+import time
+from typing import Dict, Any, Optional, Callable
+
+from replx.utils.constants import DEFAULT_AGENT_PORT, AGENT_HOST, MAX_UDP_SIZE
+from replx.commands import Cmd
+from replx.cli.agent.protocol import AgentProtocol
+from .session import get_cached_session_id
+
+LOCAL_PATH_PARAMS = frozenset({'local_path', 'local'})
+
+
+class AgentClient:    
+    TIMEOUT = 5.0
+    MAX_RETRIES = 3
+
+    def __init__(self, port: int = None, device_port: str = None):
+        self.agent_port = port or DEFAULT_AGENT_PORT
+        self.device_port = device_port
+        self.sock: Optional[socket.socket] = None
+
+        self._ppid = get_cached_session_id()
+
+    def connect(self):
+        if not self.sock:
+            self.sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
+            self.sock.settimeout(self.TIMEOUT)
+
+    def disconnect(self):
+        if self.sock:
+            self.sock.close()
+            self.sock = None
+
+    def send_command(self, command: str, timeout: float = None, **args) -> Dict[str, Any]:
+        if not self.sock:
+            self.connect()
+
+        effective_timeout = timeout if timeout else self.TIMEOUT
+
+        if timeout:
+            self.sock.settimeout(timeout)
+
+        port_to_use = args.pop('port', None) or self.device_port
+
+        for param in LOCAL_PATH_PARAMS:
+            if param in args and args[param]:
+                args[param] = os.path.abspath(args[param])
+
+        request = AgentProtocol.create_request(
+            command,
+            ppid=self._ppid,
+            port=port_to_use,
+            **args
+        )
+        seq = request['seq']
+        request_data = AgentProtocol.encode_message(request)
+
+        response = None
+        
+        max_attempts = 1 if effective_timeout < 1.0 else self.MAX_RETRIES
+
+        for attempt in range(max_attempts):
+            try:
+                self.sock.sendto(request_data, (AGENT_HOST, self.agent_port))
+
+                start_time = time.time()
+                while time.time() - start_time < effective_timeout:
+                    try:
+                        data, addr = self.sock.recvfrom(MAX_UDP_SIZE)
+
+                        msg = AgentProtocol.decode_message(data)
+                        if not msg or msg.get('seq') != seq:
+                            continue
+
+                        if msg.get('type') == 'ack':
+                            continue
+
+                        if msg.get('type') == 'response':
+                            response = msg
+                            break
+
+                    except socket.timeout:
+                        break
+
+                if response:
+                    break
+
+                if attempt < max_attempts - 1 and effective_timeout >= 1.0:
+                    time.sleep(0.1 * (attempt + 1))
+
+            except socket.timeout:
+                if attempt < max_attempts - 1:
+                    continue
+                raise RuntimeError(f"Agent timeout after {max_attempts} attempts")
+
+        if not response:
+            raise RuntimeError("No response from agent")
+
+        if response.get('error'):
+            raise RuntimeError(response['error'])
+
+        return response.get('result', {})
+
+    def run_interactive(self, script_path: str = None, script_content: str = None,
+                        echo: bool = False,
+                        output_callback: Callable[[bytes, str], None] = None,
+                        input_provider: Callable[[], Optional[bytes]] = None,
+                        stop_check: Callable[[], bool] = None) -> Dict[str, Any]:
+        if not self.sock:
+            self.connect()
+
+        if script_path:
+            script_path = os.path.abspath(script_path)
+
+        request = AgentProtocol.create_request(
+            'run_interactive',
+            ppid=self._ppid,
+            port=self.device_port,
+            script_path=script_path,
+            script_content=script_content,
+            echo=echo
+        )
+        seq = request['seq']
+        request_data = AgentProtocol.encode_message(request)
+
+        self.sock.sendto(request_data, (AGENT_HOST, self.agent_port))
+
+        self.sock.settimeout(5.0)
+        ack_received = False
+        error_response = None
+
+        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:
+                break
+
+        if error_response:
+            raise RuntimeError(error_response['error'])
+
+        if not ack_received:
+            raise RuntimeError("No ACK from agent - run_interactive failed to start")
+
+        self.sock.settimeout(0.01)
+        input_interval = 0.001
+        last_input_time = 0
+        error_check_until = time.time() + 0.1
+
+        try:
+            while True:
+                if stop_check and stop_check():
+                    try:
+                        self.send_command(Cmd.RUN_STOP, timeout=0.5)
+                    except Exception:
+                        pass
+                    break
+
+                now = time.time()
+
+                if now - last_input_time >= input_interval:
+                    last_input_time = now
+                    if input_provider:
+                        try:
+                            input_data = input_provider()
+                            if input_data:
+                                input_msg = AgentProtocol.create_input(seq, input_data, ppid=self._ppid, port=self.device_port)
+                                input_data_encoded = AgentProtocol.encode_message(input_msg)
+                                self.sock.sendto(input_data_encoded, (AGENT_HOST, self.agent_port))
+                        except Exception:
+                            pass
+
+                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':
+                            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')
+                                break
+
+                except socket.timeout:
+                    pass
+                except Exception:
+                    pass
+
+        except KeyboardInterrupt:
+            try:
+                self.send_command(Cmd.RUN_STOP, timeout=0.5)
+            except Exception:
+                pass
+            raise
+
+        self.sock.settimeout(self.TIMEOUT)
+
+        return {"run": True, "completed": True}
+
+    def send_command_streaming(self, command: str, timeout: float = None,
+                                progress_callback: Callable[[Dict[str, Any]], None] = None,
+                                **args) -> Dict[str, Any]:
+        if not self.sock:
+            self.connect()
+
+        effective_timeout = timeout if timeout else 60.0
+
+        port_to_use = args.pop('port', None) or self.device_port
+
+        for param in LOCAL_PATH_PARAMS:
+            if param in args and args[param]:
+                args[param] = os.path.abspath(args[param])
+
+        request = AgentProtocol.create_request(
+            command,
+            ppid=self._ppid,
+            port=port_to_use,
+            **args
+        )
+        seq = request['seq']
+        request_data = AgentProtocol.encode_message(request)
+
+        self.sock.sendto(request_data, (AGENT_HOST, self.agent_port))
+
+        self.sock.settimeout(0.1)
+
+        ack_received = False
+        response = None
+        start_time = time.time()
+
+        while time.time() - start_time < effective_timeout:
+            try:
+                data, addr = self.sock.recvfrom(MAX_UDP_SIZE)
+                msg = AgentProtocol.decode_message(data)
+
+                if not msg or msg.get('seq') != seq:
+                    continue
+
+                msg_type = msg.get('type')
+
+                if msg_type == 'ack':
+                    ack_received = True
+                    continue
+
+                elif msg_type == 'stream':
+                    if progress_callback:
+                        stream_data = msg.get('data', {})
+                        progress_callback(stream_data)
+                    continue
+
+                elif msg_type == 'response':
+                    response = msg
+                    break
+
+            except socket.timeout:
+                if not ack_received and time.time() - start_time > 5.0:
+                    raise RuntimeError("No response from agent")
+                continue
+            except Exception as e:
+                raise RuntimeError(f"Communication error: {e}")
+
+        self.sock.settimeout(self.TIMEOUT)
+
+        if not response:
+            raise RuntimeError("No response from agent (timeout)")
+
+        if response.get('error'):
+            raise RuntimeError(response['error'])
+
+        return response.get('result', {})
+
+    def ping(self) -> bool:
+        try:
+            result = self.send_command(Cmd.PING, timeout=0.3)
+            return result.get('pong', False)
+        except Exception:
+            return False
+
+    def __enter__(self):
+        self.connect()
+        return self
+
+    def __exit__(self, _exc_type, _exc_val, _exc_tb):
+        self.disconnect()
+
+    @staticmethod
+    def is_agent_running(port: int = None) -> bool:
+        try:
+            client = AgentClient(port=port)
+            return client.ping()
+        except Exception:
+            return False
+
+    @staticmethod
+    def start_agent(port: int = None, background: bool = True) -> bool:
+        if AgentClient.is_agent_running(port=port):
+            return False
+
+        import subprocess
+        python_exe = sys.executable
+        agent_module = 'replx.cli.agent.server'
+
+        cmd = [python_exe, '-m', agent_module]
+        if port:
+            cmd.append(str(port))
+
+        if background:
+            if sys.platform == 'win32':
+                startupinfo = subprocess.STARTUPINFO()
+                startupinfo.dwFlags |= subprocess.STARTF_USESHOWWINDOW
+                startupinfo.wShowWindow = 0
+
+                subprocess.Popen(
+                    cmd,
+                    creationflags=subprocess.CREATE_NEW_PROCESS_GROUP | subprocess.DETACHED_PROCESS,
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL,
+                    startupinfo=startupinfo
+                )
+            else:
+                subprocess.Popen(
+                    cmd,
+                    stdout=subprocess.DEVNULL,
+                    stderr=subprocess.DEVNULL,
+                    stdin=subprocess.DEVNULL,
+                    start_new_session=True,
+                    close_fds=True
+                )
+        else:
+            subprocess.Popen(cmd)
+
+        for i in range(30):
+            time.sleep(0.1)
+            if AgentClient.is_agent_running(port=port):
+                return True
+
+        raise RuntimeError("Failed to start agent (timeout)")
+
+    @staticmethod
+    def stop_agent(port: int = None, timeout: float = 1.5) -> bool:
+        if not AgentClient.is_agent_running(port=port):
+            return False
+
+        try:
+            client = AgentClient(port=port)
+            client.send_command(Cmd.SHUTDOWN, timeout=0.5)
+        except Exception:
+            pass
+
+        start_time = time.time()
+        while time.time() - start_time < timeout:
+            time.sleep(0.05) 
+            if not AgentClient.is_agent_running(port=port):
+                return True
+
+        return not AgentClient.is_agent_running(port=port)

replx-1.3/replx/cli/agent/client/session.py

@@ -0,0 +1,148 @@
+import os
+from typing import Optional
+import psutil
+
+def _find_terminal_process() -> Optional[dict]:
+    shell_names = {
+        'powershell.exe', 'pwsh.exe', 'cmd.exe', 'bash.exe', 'zsh.exe', 'sh.exe', 'fish.exe',
+        'windowsterminal.exe',
+    }
+
+    ide_names = {
+        'code.exe',
+        'conemu64.exe', 'conemu.exe',
+        'pycharm.exe', 'pycharm64.exe', 'idea.exe', 'idea64.exe',
+    }
+
+    try:
+        parent_pid = os.getppid()
+        if parent_pid and parent_pid > 0:
+            parent = psutil.Process(parent_pid)
+            pname = (parent.name() or '').lower()
+            if pname in shell_names:
+                return {
+                    'pid': parent.pid,
+                    'name': parent.name(),
+                    'create_time': parent.create_time(),
+                    'cwd': None,
+                    'level': 0,
+                }
+    except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess, OSError):
+        pass
+
+    try:
+        current = psutil.Process()
+        best_ide = None
+
+        for level in range(12):
+            if current is None:
+                break
+
+            try:
+                name = (current.name() or '').lower()
+            except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
+                break
+
+            if name in shell_names:
+                return {
+                    'pid': current.pid,
+                    'name': current.name(),
+                    'create_time': current.create_time(),
+                    'cwd': None,
+                    'level': level,
+                }
+
+            if name in ide_names and best_ide is None:
+                try:
+                    best_ide = {
+                        'pid': current.pid,
+                        'name': current.name(),
+                        'create_time': current.create_time(),
+                        'cwd': None,
+                        'level': level,
+                    }
+                except Exception:
+                    best_ide = None
+
+            try:
+                if current.ppid() == 0:
+                    break
+            except Exception:
+                break
+
+            try:
+                parent = current.parent()
+            except Exception:
+                parent = None
+
+            if parent is None:
+                break
+            current = parent
+
+        if best_ide is not None:
+            return best_ide
+
+    except Exception:
+        pass
+
+    return None
+
+def _find_jupyter_kernel() -> Optional[dict]:
+    try:
+        current = psutil.Process()
+        for level in range(10):
+            if current is None:
+                break
+
+            cmdline = ' '.join(current.cmdline()).lower()
+
+            if any(keyword in cmdline for keyword in ['jupyter', 'ipykernel', 'ipython']):
+                return {
+                    'pid': current.pid,
+                    'name': current.name(),
+                    'cmdline': cmdline,
+                    'level': level
+                }
+
+            if current.ppid() == 0:
+                break
+
+            parent = current.parent()
+            if parent is None:
+                break
+            current = parent
+
+    except (psutil.NoSuchProcess, psutil.AccessDenied, psutil.ZombieProcess):
+        pass
+
+    return None
+
+def get_session_id() -> int:
+    terminal = _find_terminal_process()
+    if terminal:
+        return terminal['pid']
+
+    jupyter = _find_jupyter_kernel()
+    if jupyter:
+        return jupyter['pid']
+
+    ppid = os.getppid()
+    if ppid and ppid > 0:
+        return ppid
+
+    workspace_hash = abs(hash(os.getcwd())) % (10**8)
+    return workspace_hash
+
+_session_id_cache: Optional[int] = None
+
+def get_cached_session_id() -> int:
+    global _session_id_cache
+
+    if _session_id_cache is None:
+        _session_id_cache = get_session_id()
+
+    return _session_id_cache
+
+def clear_session_cache():
+    global _session_id_cache
+    _session_id_cache = None