ssh-handler 1.3.0__tar.gz → 1.4.1__tar.gz

{ssh_handler-1.3.0/ssh_handler.egg-info → ssh_handler-1.4.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ssh-handler
-Version: 1.3.0
+Version: 1.4.1
 Summary: Extensive SSH/SFTP/SCP/FTP handler built on Paramiko, for test automation, CLIs and PyQt5 tools.
 Author: ssh-handler contributors
 License-Expression: MIT
@@ -304,26 +304,39 @@ with SerialHandler("COM5", baudrate=115200, quiet=True) as ser:
     ser.stream(on_line=print, match=r"login:", stop_on_match=True, save_to="console.log")
 ```
 
-### Serial via RDP / jump host (device on the remote target)
-`pyserial` only opens a *local* port, so when the serial cable is on the remote
-box (reached through your RDP jump), stream it **over SSH** with `serial_stream()`
-— same live match + save, routed through the jump:
+### Serial via RDP / SSH (port on a *remote* machine)
+`pyserial` only opens a *local* port, so when the serial port is on a remote
+machine, stream it **over SSH** with `serial_stream()` — same live match + save.
+It auto-detects the OS from the device name: `COM*` → Windows (PowerShell
+SerialPort reader), `/dev/tty*` → Linux (`stty` + `cat`).
+
+**Windows COM port on the remote machine** (connect SSH straight to that machine
+— it has sshd from `ssh-handler-setup`):
 
 ```python
-rdp_box = SSHConfig(host="10.232.9.22", domain="CORP", username="myuser", password="pw")
-target  = SSHConfig(host="10.120.1.91", username="root", password="pw",
-                    jump_host=rdp_box, host_key_policy="ignore")
+cfg = SSHConfig(host="10.232.9.22", domain="CORP", username="myuser",
+                password="pw", host_key_policy="ignore")
+with SSHHandler(cfg, quiet=True) as ssh:
+    ssh.serial_write("COM5", "version", baudrate=115200)      # write a line
+    ssh.serial_stream("COM5", baudrate=115200,                # read it live
+                      on_line=print, match=r"login:|ERROR",
+                      save_to="com5.log", timeout=120)
+```
 
+**Linux device file on a target reached through the jump:**
+
+```python
+target = SSHConfig(host="10.120.1.91", username="root", password="pw",
+                   jump_host=rdp_box, host_key_policy="ignore")
 with SSHHandler(target, quiet=True) as ssh:
-    ssh.serial_write("/dev/ttyUSB0", "version")          # write to the device
-    ssh.serial_stream("/dev/ttyUSB0", baudrate=115200,   # read it live
-                      on_line=print, match=r"login:|ERROR",
-                      save_to="device_console.log", timeout=120)
+    ssh.serial_stream("/dev/ttyUSB0", baudrate=115200,
+                      on_line=print, match=r"login:", save_to="ttyusb0.log")
 ```
 
-`serial_stream()` sets the line speed with `stty` then streams the device — for
-**Linux targets**. (Windows COM ports on the remote side need a remote helper;
-ask if you need that.)
+> Note: on Windows a COM port can't be shared — don't run `serial_write` while a
+> `serial_stream` on the same port is open (`serial_write` opens/writes/closes).
+> If the port is on **your own laptop**, use the local `SerialHandler("COM5")`
+> above instead — no SSH needed.
 
 ## File transfer (SFTP / SCP / FTP) via RDP
 

{ssh_handler-1.3.0 → ssh_handler-1.4.1}/README.md

@@ -278,26 +278,39 @@ with SerialHandler("COM5", baudrate=115200, quiet=True) as ser:
     ser.stream(on_line=print, match=r"login:", stop_on_match=True, save_to="console.log")
 ```
 
-### Serial via RDP / jump host (device on the remote target)
-`pyserial` only opens a *local* port, so when the serial cable is on the remote
-box (reached through your RDP jump), stream it **over SSH** with `serial_stream()`
-— same live match + save, routed through the jump:
+### Serial via RDP / SSH (port on a *remote* machine)
+`pyserial` only opens a *local* port, so when the serial port is on a remote
+machine, stream it **over SSH** with `serial_stream()` — same live match + save.
+It auto-detects the OS from the device name: `COM*` → Windows (PowerShell
+SerialPort reader), `/dev/tty*` → Linux (`stty` + `cat`).
+
+**Windows COM port on the remote machine** (connect SSH straight to that machine
+— it has sshd from `ssh-handler-setup`):
 
 ```python
-rdp_box = SSHConfig(host="10.232.9.22", domain="CORP", username="myuser", password="pw")
-target  = SSHConfig(host="10.120.1.91", username="root", password="pw",
-                    jump_host=rdp_box, host_key_policy="ignore")
+cfg = SSHConfig(host="10.232.9.22", domain="CORP", username="myuser",
+                password="pw", host_key_policy="ignore")
+with SSHHandler(cfg, quiet=True) as ssh:
+    ssh.serial_write("COM5", "version", baudrate=115200)      # write a line
+    ssh.serial_stream("COM5", baudrate=115200,                # read it live
+                      on_line=print, match=r"login:|ERROR",
+                      save_to="com5.log", timeout=120)
+```
 
+**Linux device file on a target reached through the jump:**
+
+```python
+target = SSHConfig(host="10.120.1.91", username="root", password="pw",
+                   jump_host=rdp_box, host_key_policy="ignore")
 with SSHHandler(target, quiet=True) as ssh:
-    ssh.serial_write("/dev/ttyUSB0", "version")          # write to the device
-    ssh.serial_stream("/dev/ttyUSB0", baudrate=115200,   # read it live
-                      on_line=print, match=r"login:|ERROR",
-                      save_to="device_console.log", timeout=120)
+    ssh.serial_stream("/dev/ttyUSB0", baudrate=115200,
+                      on_line=print, match=r"login:", save_to="ttyusb0.log")
 ```
 
-`serial_stream()` sets the line speed with `stty` then streams the device — for
-**Linux targets**. (Windows COM ports on the remote side need a remote helper;
-ask if you need that.)
+> Note: on Windows a COM port can't be shared — don't run `serial_write` while a
+> `serial_stream` on the same port is open (`serial_write` opens/writes/closes).
+> If the port is on **your own laptop**, use the local `SerialHandler("COM5")`
+> above instead — no SSH needed.
 
 ## File transfer (SFTP / SCP / FTP) via RDP
 

{ssh_handler-1.3.0 → ssh_handler-1.4.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "ssh-handler"
-version = "1.3.0"
+version = "1.4.1"
 description = "Extensive SSH/SFTP/SCP/FTP handler built on Paramiko, for test automation, CLIs and PyQt5 tools."
 readme = "README.md"
 requires-python = ">=3.8"

{ssh_handler-1.3.0 → ssh_handler-1.4.1}/ssh_handler/__init__.py

@@ -22,7 +22,7 @@ dependencies (PyQt5 / scp) don't break the core package.
 
 from __future__ import annotations
 
-__version__ = "1.3.0"
+__version__ = "1.4.1"
 
 from .config import SSHConfig, FTPConfig
 from .core import SSHHandler, ShellSession

{ssh_handler-1.3.0 → ssh_handler-1.4.1}/ssh_handler/core.py

@@ -698,36 +698,85 @@ class SSHHandler:
 
         return self._guard("stream", _do, safe=safe)
 
+    @staticmethod
+    def _ps_encode(script: str) -> str:
+        """Encode a PowerShell script for `powershell -EncodedCommand` (UTF-16LE
+        base64) - sidesteps all quoting issues over SSH -> cmd -> powershell."""
+        import base64
+        return base64.b64encode(script.encode("utf-16-le")).decode("ascii")
+
     def serial_stream(self, device: str = "/dev/ttyUSB0", *, baudrate: int = 115200,
-                      on_line=None, on_match=None, match=None,
+                      mode: str = "auto", on_line=None, on_match=None, match=None,
                       stop_on_match: bool = False, save_to: Optional[str] = None,
                       timeout: Optional[float] = None, stop_event=None,
                       configure: bool = True, safe: Optional[bool] = None):
         """
-        Stream a serial device attached to the **remote** host, over SSH — so it
+        Stream a serial port attached to the **remote** host, over SSH — so it
         works through a jump host (laptop -> RDP machine -> target). Same live
         match + save-to-file model as :meth:`stream`.
 
-        Linux target: sets the line speed with ``stty`` then ``cat``s the device.
-        Use this when the serial cable is plugged into the remote box, not your
-        laptop (pyserial can only open a *local* port).
+        ``mode``:
+          * "auto"    - "COMx" -> windows, otherwise linux (default)
+          * "windows" - read a COM port via a PowerShell SerialPort reader
+          * "linux"   - set speed with ``stty`` then ``cat`` the device file
 
-        >>> ssh.serial_stream("/dev/ttyUSB0", baudrate=115200,
-        ...                   match="login:", save_to="console.log", on_line=print)
+        >>> # Windows COM port on the remote machine:
+        >>> ssh.serial_stream("COM5", baudrate=115200, match="login:",
+        ...                   save_to="console.log", on_line=print)
+        >>> # Linux device file on the remote machine:
+        >>> ssh.serial_stream("/dev/ttyUSB0", baudrate=115200, on_line=print)
         """
-        dev = shlex.quote(device)
-        if configure:
-            cmd = (f"stty -F {dev} {int(baudrate)} raw -echo -echoe -echok "
-                   f"2>/dev/null; cat {dev}")
+        is_windows = (mode == "windows" or
+                      (mode == "auto" and device.upper().startswith("COM")))
+        if is_windows:
+            # Force UTF-8 console output so our UTF-8 reader doesn't get mojibake,
+            # and read whatever bytes are available (robust to any line ending)
+            # rather than ReadLine (which hangs if the device's EOL differs).
+            ps = (
+                "$ErrorActionPreference='SilentlyContinue';"
+                "[Console]::OutputEncoding=[System.Text.Encoding]::UTF8;"
+                f"$p=New-Object System.IO.Ports.SerialPort '{device}',{int(baudrate)},"
+                "'None',8,'One';"
+                "$p.Encoding=[System.Text.Encoding]::UTF8;"
+                "$p.Open();"
+                "while($true){"
+                "if($p.BytesToRead -gt 0){"
+                "$s=$p.ReadExisting();[Console]::Out.Write($s);[Console]::Out.Flush()}"
+                "else{Start-Sleep -Milliseconds 30}}"
+            )
+            cmd = f"powershell -NoProfile -EncodedCommand {self._ps_encode(ps)}"
         else:
-            cmd = f"cat {dev}"
+            dev = shlex.quote(device)
+            if configure:
+                cmd = (f"stty -F {dev} {int(baudrate)} raw -echo -echoe -echok "
+                       f"2>/dev/null; cat {dev}")
+            else:
+                cmd = f"cat {dev}"
         return self.stream(cmd, on_line=on_line, on_match=on_match, match=match,
                            stop_on_match=stop_on_match, save_to=save_to,
                            timeout=timeout, stop_event=stop_event, safe=safe)
 
-    def serial_write(self, device: str, data: str, *, newline: bool = True,
+    def serial_write(self, device: str, data: str, *, baudrate: int = 115200,
+                     mode: str = "auto", newline: bool = True,
                      safe: Optional[bool] = None):
-        """Write a line to a serial device on the remote host (over SSH/jump)."""
+        """
+        Write a line to a serial port on the remote host (over SSH/jump).
+        Opens, writes, and closes the port (don't run while serial_stream holds
+        it open on Windows - the port can't be shared).
+        """
+        is_windows = (mode == "windows" or
+                      (mode == "auto" and device.upper().startswith("COM")))
+        if is_windows:
+            payload = data.replace("'", "''")
+            meth = "WriteLine" if newline else "Write"
+            ps = (
+                f"$p=New-Object System.IO.Ports.SerialPort '{device}',{int(baudrate)},"
+                "'None',8,'One';"
+                f"$p.Open();$p.{meth}('{payload}');Start-Sleep -Milliseconds 200;"
+                "$p.Close()"
+            )
+            cmd = f"powershell -NoProfile -EncodedCommand {self._ps_encode(ps)}"
+            return self.run(cmd, safe=safe)
         payload = data + ("\n" if newline else "")
         dev = shlex.quote(device)
         return self.run(f"printf %s {shlex.quote(payload)} > {dev}", safe=safe)

{ssh_handler-1.3.0 → ssh_handler-1.4.1/ssh_handler.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ssh-handler
-Version: 1.3.0
+Version: 1.4.1
 Summary: Extensive SSH/SFTP/SCP/FTP handler built on Paramiko, for test automation, CLIs and PyQt5 tools.
 Author: ssh-handler contributors
 License-Expression: MIT
@@ -304,26 +304,39 @@ with SerialHandler("COM5", baudrate=115200, quiet=True) as ser:
     ser.stream(on_line=print, match=r"login:", stop_on_match=True, save_to="console.log")
 ```
 
-### Serial via RDP / jump host (device on the remote target)
-`pyserial` only opens a *local* port, so when the serial cable is on the remote
-box (reached through your RDP jump), stream it **over SSH** with `serial_stream()`
-— same live match + save, routed through the jump:
+### Serial via RDP / SSH (port on a *remote* machine)
+`pyserial` only opens a *local* port, so when the serial port is on a remote
+machine, stream it **over SSH** with `serial_stream()` — same live match + save.
+It auto-detects the OS from the device name: `COM*` → Windows (PowerShell
+SerialPort reader), `/dev/tty*` → Linux (`stty` + `cat`).
+
+**Windows COM port on the remote machine** (connect SSH straight to that machine
+— it has sshd from `ssh-handler-setup`):
 
 ```python
-rdp_box = SSHConfig(host="10.232.9.22", domain="CORP", username="myuser", password="pw")
-target  = SSHConfig(host="10.120.1.91", username="root", password="pw",
-                    jump_host=rdp_box, host_key_policy="ignore")
+cfg = SSHConfig(host="10.232.9.22", domain="CORP", username="myuser",
+                password="pw", host_key_policy="ignore")
+with SSHHandler(cfg, quiet=True) as ssh:
+    ssh.serial_write("COM5", "version", baudrate=115200)      # write a line
+    ssh.serial_stream("COM5", baudrate=115200,                # read it live
+                      on_line=print, match=r"login:|ERROR",
+                      save_to="com5.log", timeout=120)
+```
 
+**Linux device file on a target reached through the jump:**
+
+```python
+target = SSHConfig(host="10.120.1.91", username="root", password="pw",
+                   jump_host=rdp_box, host_key_policy="ignore")
 with SSHHandler(target, quiet=True) as ssh:
-    ssh.serial_write("/dev/ttyUSB0", "version")          # write to the device
-    ssh.serial_stream("/dev/ttyUSB0", baudrate=115200,   # read it live
-                      on_line=print, match=r"login:|ERROR",
-                      save_to="device_console.log", timeout=120)
+    ssh.serial_stream("/dev/ttyUSB0", baudrate=115200,
+                      on_line=print, match=r"login:", save_to="ttyusb0.log")
 ```
 
-`serial_stream()` sets the line speed with `stty` then streams the device — for
-**Linux targets**. (Windows COM ports on the remote side need a remote helper;
-ask if you need that.)
+> Note: on Windows a COM port can't be shared — don't run `serial_write` while a
+> `serial_stream` on the same port is open (`serial_write` opens/writes/closes).
+> If the port is on **your own laptop**, use the local `SerialHandler("COM5")`
+> above instead — no SSH needed.
 
 ## File transfer (SFTP / SCP / FTP) via RDP