com2tty 0.3.0__tar.gz → 0.3.1__tar.gz

{com2tty-0.3.0/src/com2tty.egg-info → com2tty-0.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: com2tty
-Version: 0.3.0
+Version: 0.3.1
 Summary: A Windows COM port to WSL ttyUSB forwarder
 Author-email: yichengs <yichengs.tw+com2tty@gmail.com>
 Project-URL: Homepage, https://github.com/Yi-Cheng-Wang/com2tty
@@ -116,7 +116,8 @@ The following options apply to both modes.
 --version              Print the com2tty version and exit.
 -l, --list             List the serial ports Windows can see (device name,
                        VID:PID, USB bus id, serial number, detected board,
-                       description) and exit.
+                       description) and exit. Supplying a COM port together
+                       with --list is an argument error.
 --json                 With --list: print the port list as a JSON array
                        instead of an aligned table, for scripts and IDE
                        integrations.
@@ -296,6 +297,10 @@ com2tty @myboard --baud 9600
 com2tty @pad
 ```
 
+A literal argument that must begin with `@` is written with a doubled marker:
+`@@value` is passed through as the literal `@value` and is never interpreted as
+a profile reference.
+
 ### Automatic baud-rate detection
 
 When the baud rate is left at its default value of `auto`, com2tty queries the
@@ -348,9 +353,11 @@ when zsh is in use or that file exists, and to
 `~/.config/fish/conf.d/com2tty.fish` when fish is in use or its configuration
 directory exists. Open a new WSL shell or run `source ~/.bashrc` (or
 `source ~/.zshrc`; fish picks the snippet up automatically) after starting
-com2tty for them to take effect. The variables are removed when com2tty exits;
-if a session is killed before it can clean up, the next run removes the stale
-block on startup.
+com2tty for them to take effect. The variables are removed when com2tty exits,
+including when the console window is closed: the WSL helper is reaped together
+with the host process rather than left running, and it is given the chance to
+run its own cleanup before it is forced down. If a session is nonetheless killed
+before it can clean up, the next run removes the stale block on startup.
 
 Second, com2tty detects the connected board type from its USB vendor identifier
 and performs the appropriate hardware reset on the Windows side. For ESP32-class
@@ -373,10 +380,13 @@ inside WSL. When PlatformIO calls `picotool` to flash a `.uf2` image, a wrapper
 transfers the image back to the Windows host over a relay that listens on
 `127.0.0.1:<rfc2217-port + 1>`. The host then triggers BOOTSEL mode, locates the
 board's mass-storage drive, verifies the transferred image against an MD5
-checksum, and writes the image to the drive. The original `picotool` is restored
-when com2tty exits; if a session is killed before it can restore it, the next run
-detects and reverses the leftover interception on startup, so PlatformIO uploads
-are not left broken.
+checksum, and writes the image to the drive. Subcommands that carry no firmware
+image, such as `picotool info`, `picotool reboot`, and `picotool help`, are
+forwarded to the real binary unchanged, so non-flashing uses of `picotool`
+continue to work while the interception is active. The original `picotool` is
+restored when com2tty exits; if a session is killed before it can restore it, the
+next run detects and reverses the leftover interception on startup, so PlatformIO
+uploads are not left broken.
 
 These mechanisms operate without any additional flags. The startup banner reports
 the detected board type, the RFC 2217 port, the UF2 relay port, and the board's
@@ -392,12 +402,14 @@ non-default `--rfc2217-port` if another local service needs the default port. To
 reclaim a port left open by a previous com2tty session, the helper only
 terminates processes whose command line identifies them as a com2tty bridge; an
 unrelated service occupying the port is never killed. A *running* com2tty
-session is never killed either: each session refreshes a heartbeat marker for
-its ports, so a second invocation that reuses the same `--rfc2217-port` reports
-the conflict and leaves the first bridge intact. Two sessions can run
-concurrently by giving the second one a different `--rfc2217-port` and
-`--wsl-tty`; each session removes only its own block from the shell startup
-files when it exits.
+session is never disturbed: before it touches any shared state, a new session
+checks whether its RFC 2217 and UF2 relay ports are already bound and, if so,
+refuses to start rather than overwrite the first session's shell configuration
+or steal its serial endpoint. As a further guard, the WSL helper refuses to
+replace a tty symlink that already points at another live session's pseudo
+terminal. Two sessions can run concurrently by giving the second one a different
+`--rfc2217-port` and `--wsl-tty`; each session removes only its own block from
+the shell startup files when it exits.
 
 ### Gamepad mode
 
@@ -423,7 +435,10 @@ privileges at run time.
 #### Default tier: the /tmp event stream
 
 The default tier writes the evdev event stream to a FIFO under `/tmp`, by default
-`/tmp/com2pad0`, and requires no privileged setup.
+`/tmp/com2pad0`, and requires no privileged setup. This FIFO and its
+force-feedback companion (described below) are created with owner-only
+permissions, so another local user on the WSL instance cannot read the input
+stream or inject events into it.
 
 ```cmd
 com2tty --gamepad
@@ -691,6 +706,11 @@ package; on minimal distributions install it with `sudo apt install psmisc`, or
 select a different port with `--rfc2217-port` (the UF2 relay always uses that
 port plus one).
 
+If com2tty instead refuses to start with a message that a port is already in
+use, a second com2tty session is already bound to that port. Give the new session
+a different `--rfc2217-port`, and a different `--wsl-tty`, to run the two
+concurrently.
+
 The serial-mode environment variables are written to `~/.bashrc`, to `~/.zshrc`
 when zsh is detected or a `~/.zshrc` file exists, and to
 `~/.config/fish/conf.d/com2tty.fish` when fish is detected. Users of other

{com2tty-0.3.0 → com2tty-0.3.1}/README.md

@@ -100,7 +100,8 @@ The following options apply to both modes.
 --version              Print the com2tty version and exit.
 -l, --list             List the serial ports Windows can see (device name,
                        VID:PID, USB bus id, serial number, detected board,
-                       description) and exit.
+                       description) and exit. Supplying a COM port together
+                       with --list is an argument error.
 --json                 With --list: print the port list as a JSON array
                        instead of an aligned table, for scripts and IDE
                        integrations.
@@ -280,6 +281,10 @@ com2tty @myboard --baud 9600
 com2tty @pad
 ```
 
+A literal argument that must begin with `@` is written with a doubled marker:
+`@@value` is passed through as the literal `@value` and is never interpreted as
+a profile reference.
+
 ### Automatic baud-rate detection
 
 When the baud rate is left at its default value of `auto`, com2tty queries the
@@ -332,9 +337,11 @@ when zsh is in use or that file exists, and to
 `~/.config/fish/conf.d/com2tty.fish` when fish is in use or its configuration
 directory exists. Open a new WSL shell or run `source ~/.bashrc` (or
 `source ~/.zshrc`; fish picks the snippet up automatically) after starting
-com2tty for them to take effect. The variables are removed when com2tty exits;
-if a session is killed before it can clean up, the next run removes the stale
-block on startup.
+com2tty for them to take effect. The variables are removed when com2tty exits,
+including when the console window is closed: the WSL helper is reaped together
+with the host process rather than left running, and it is given the chance to
+run its own cleanup before it is forced down. If a session is nonetheless killed
+before it can clean up, the next run removes the stale block on startup.
 
 Second, com2tty detects the connected board type from its USB vendor identifier
 and performs the appropriate hardware reset on the Windows side. For ESP32-class
@@ -357,10 +364,13 @@ inside WSL. When PlatformIO calls `picotool` to flash a `.uf2` image, a wrapper
 transfers the image back to the Windows host over a relay that listens on
 `127.0.0.1:<rfc2217-port + 1>`. The host then triggers BOOTSEL mode, locates the
 board's mass-storage drive, verifies the transferred image against an MD5
-checksum, and writes the image to the drive. The original `picotool` is restored
-when com2tty exits; if a session is killed before it can restore it, the next run
-detects and reverses the leftover interception on startup, so PlatformIO uploads
-are not left broken.
+checksum, and writes the image to the drive. Subcommands that carry no firmware
+image, such as `picotool info`, `picotool reboot`, and `picotool help`, are
+forwarded to the real binary unchanged, so non-flashing uses of `picotool`
+continue to work while the interception is active. The original `picotool` is
+restored when com2tty exits; if a session is killed before it can restore it, the
+next run detects and reverses the leftover interception on startup, so PlatformIO
+uploads are not left broken.
 
 These mechanisms operate without any additional flags. The startup banner reports
 the detected board type, the RFC 2217 port, the UF2 relay port, and the board's
@@ -376,12 +386,14 @@ non-default `--rfc2217-port` if another local service needs the default port. To
 reclaim a port left open by a previous com2tty session, the helper only
 terminates processes whose command line identifies them as a com2tty bridge; an
 unrelated service occupying the port is never killed. A *running* com2tty
-session is never killed either: each session refreshes a heartbeat marker for
-its ports, so a second invocation that reuses the same `--rfc2217-port` reports
-the conflict and leaves the first bridge intact. Two sessions can run
-concurrently by giving the second one a different `--rfc2217-port` and
-`--wsl-tty`; each session removes only its own block from the shell startup
-files when it exits.
+session is never disturbed: before it touches any shared state, a new session
+checks whether its RFC 2217 and UF2 relay ports are already bound and, if so,
+refuses to start rather than overwrite the first session's shell configuration
+or steal its serial endpoint. As a further guard, the WSL helper refuses to
+replace a tty symlink that already points at another live session's pseudo
+terminal. Two sessions can run concurrently by giving the second one a different
+`--rfc2217-port` and `--wsl-tty`; each session removes only its own block from
+the shell startup files when it exits.
 
 ### Gamepad mode
 
@@ -407,7 +419,10 @@ privileges at run time.
 #### Default tier: the /tmp event stream
 
 The default tier writes the evdev event stream to a FIFO under `/tmp`, by default
-`/tmp/com2pad0`, and requires no privileged setup.
+`/tmp/com2pad0`, and requires no privileged setup. This FIFO and its
+force-feedback companion (described below) are created with owner-only
+permissions, so another local user on the WSL instance cannot read the input
+stream or inject events into it.
 
 ```cmd
 com2tty --gamepad
@@ -675,6 +690,11 @@ package; on minimal distributions install it with `sudo apt install psmisc`, or
 select a different port with `--rfc2217-port` (the UF2 relay always uses that
 port plus one).
 
+If com2tty instead refuses to start with a message that a port is already in
+use, a second com2tty session is already bound to that port. Give the new session
+a different `--rfc2217-port`, and a different `--wsl-tty`, to run the two
+concurrently.
+
 The serial-mode environment variables are written to `~/.bashrc`, to `~/.zshrc`
 when zsh is detected or a `~/.zshrc` file exists, and to
 `~/.config/fish/conf.d/com2tty.fish` when fish is detected. Users of other

{com2tty-0.3.0 → com2tty-0.3.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "com2tty"
-version = "0.3.0"
+version = "0.3.1"
 description = "A Windows COM port to WSL ttyUSB forwarder"
 readme = "README.md"
 authors = [

com2tty-0.3.1/src/com2tty/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.3.1"

{com2tty-0.3.0 → com2tty-0.3.1}/src/com2tty/bridge.py

@@ -18,4 +18,4 @@ if __package__ in (None, ""):  # executed as a script inside WSL
 from com2tty.wsl.serial_app import main  # noqa: E402
 
 if __name__ == "__main__":  # pragma: no cover
-    main()
+    sys.exit(main())

{com2tty-0.3.0 → com2tty-0.3.1}/src/com2tty/cli/__init__.py

@@ -232,6 +232,10 @@ def main():
         sys.exit(run_doctor(distro=parsed_args.distro,
                             rfc2217_port=parsed_args.rfc2217_port))
 
+    if parsed_args.list_ports and parsed_args.port:
+        parser.error("--list does not take a COM port; remove the positional "
+                     "argument (it would be silently ignored)")
+
     if parsed_args.list_ports:
         from com2tty.windows.discovery import print_port_list
         print_port_list(as_json=parsed_args.json)

{com2tty-0.3.0 → com2tty-0.3.1}/src/com2tty/cli/profiles.py

@@ -93,10 +93,17 @@ def load_profile_args(name, search_paths=None):
 
 
 def expand_profiles(argv, search_paths=None):
-    """Replace every ``@name`` token in argv with that profile's arguments."""
+    """Replace every ``@name`` token in argv with that profile's arguments.
+
+    A literal argument value that must begin with ``@`` can be escaped by
+    doubling the marker: ``@@value`` is passed through as the literal
+    ``@value`` and is never interpreted as a profile reference.
+    """
     expanded = []
     for token in argv:
-        if token.startswith("@") and len(token) > 1:
+        if token.startswith("@@"):
+            expanded.append(token[1:])
+        elif token.startswith("@") and len(token) > 1:
             expanded.extend(load_profile_args(token[1:], search_paths))
         else:
             expanded.append(token)

{com2tty-0.3.0 → com2tty-0.3.1}/src/com2tty/core/frames.py

@@ -40,6 +40,13 @@ def pack_frame(index, connected, buttons=0, lt=0, rt=0,
                lx=0, ly=0, rx=0, ry=0):
     """Build a 16-byte controller frame. Pure function, testable anywhere."""
     flags = 0x01 if connected else 0x00
+    # Clamp the stick axes to the signed 16-bit range. XInput already reports
+    # values in range, but an out-of-range caller would otherwise make
+    # struct.pack raise and crash the host instead of degrading gracefully
+    # (consistent with the masking applied to the other fields).
+    def _clip16(v):
+        return max(-32768, min(32767, v))
+    lx, ly, rx, ry = _clip16(lx), _clip16(ly), _clip16(rx), _clip16(ry)
     return struct.pack(
         FRAME_FORMAT, FRAME_MAGIC0, FRAME_MAGIC1, index & 0xFF, flags,
         buttons & 0xFFFF, lt & 0xFF, rt & 0xFF,

{com2tty-0.3.0 → com2tty-0.3.1}/src/com2tty/core/protocol.py

@@ -61,8 +61,8 @@ UF2_ACK_LINE = b"[CONTROL] UF2_ACK\n"
 def format_line(name, payload=None):
     """Render one control line (without trailing newline)."""
     if payload is None:
-        return "%s %s" % (CONTROL_PREFIX, name)
-    return "%s %s:%s" % (CONTROL_PREFIX, name, payload)
+        return f"{CONTROL_PREFIX} {name}"
+    return f"{CONTROL_PREFIX} {name}:{payload}"
 
 
 def emit(stream, name, payload=None):
@@ -114,10 +114,14 @@ class ControlDispatcher:
             # a hypothetical UF2_UPLOAD registration.
             for name in sorted(self._handlers, key=len, reverse=True):
                 if body.startswith(name):
-                    payload = None
                     rest = body[len(name):]
-                    if rest.startswith(":"):
-                        payload = rest[1:]
+                    # Require an exact name match or a ``:`` payload separator
+                    # so e.g. a hypothetical ``SETTINGS_RESET`` line is not
+                    # misrouted to the ``SETTINGS`` handler; a non-separator
+                    # remainder falls through to the next (shorter) candidate.
+                    if rest != "" and not rest.startswith(":"):
+                        continue
+                    payload = rest[1:] if rest.startswith(":") else None
                     return self._handlers[name](
                         ControlMessage(name, payload, line_str))
         if self._fallback is not None:

{com2tty-0.3.0 → com2tty-0.3.1}/src/com2tty/windows/bridge_app.py

@@ -279,7 +279,9 @@ def _print_bridge_banner(port, board_type, rfc2217_port, usb_serial, env_setup):
         print(f"{yellow}  [WARNING] Environment variables injected into your WSL shell rc (~/.bashrc, ~/.zshrc){reset}")
         print(f"{yellow}  Please OPEN A NEW WSL TERMINAL or run `source ~/.bashrc` (or ~/.zshrc){reset}")
     else:
-        print(f"{cyan}  Secondary bridge: PlatformIO env vars are owned by the first port.{reset}")
+        print(f"{cyan}  Secondary bridge: PlatformIO env vars were set up once by the{reset}")
+        print(f"{cyan}  primary (first) port -- no shell changes are needed here. Use the{reset}")
+        print(f"{cyan}  primary bridge's terminal output for the `source` instructions.{reset}")
     print(f"{yellow}========================================================================{reset}\n")
 
 

{com2tty-0.3.0 → com2tty-0.3.1}/src/com2tty/windows/doctor.py

@@ -167,6 +167,10 @@ def check_xinput(os_name=os.name):
 
 def run_doctor(distro=None, rfc2217_port=4000):
     """Run all checks, print one line per result, return the exit status."""
+    # Each WSL probe can block for up to 30s if WSL is cold-starting or hung;
+    # without this the tool looks frozen while it waits.
+    print("Running com2tty environment checks (WSL probes can take a few "
+          "seconds each if WSL is starting up)...", flush=True)
     results = [check_wsl_exe()]
     wsl_ok = results[0][0] == OK
     if wsl_ok:

{com2tty-0.3.0 → com2tty-0.3.1}/src/com2tty/windows/gamepad_app.py

@@ -99,8 +99,12 @@ def run_gamepad_bridge(pad_index=0, poll_hz=250, name="Microsoft X-Box 360 pad",
                     break
                 for left, right in reader.feed(data):
                     src.set_rumble(left, right)
-        except Exception:
-            pass
+        except Exception as e:
+            # Don't die silently: without this the rumble channel just stops
+            # with no clue why. Shutdown-time pipe errors are expected, so
+            # only surface a failure while the bridge is meant to be running.
+            if not shutdown_event.is_set():
+                logging.warning(f"Gamepad rumble reader thread stopped: {e}")
 
     t_logs = threading.Thread(target=read_wsl_logs, daemon=True)
     t_out = threading.Thread(target=drain_wsl_stdout, daemon=True)
@@ -146,6 +150,11 @@ def run_gamepad_bridge(pad_index=0, poll_hz=250, name="Microsoft X-Box 360 pad",
     finally:
         shutdown_event.set()
         logging.info("Cleaning up gamepad bridge...")
+        # terminate_wsl_helper closes the helper's stdin, which the helper's
+        # select loop sees as EOF and exits on; the daemon reader threads then
+        # unblock when proc.stdout/stderr reach EOF. Do NOT close those read
+        # pipes here: closing a pipe another thread is blocked reading
+        # deadlocks on Windows (the reader holds the file lock).
         terminate_wsl_helper(proc)
         logging.info("Gamepad bridge stopped successfully.")
     return exit_reason

{com2tty-0.3.0 → com2tty-0.3.1}/src/com2tty/windows/gamepad_host.py

@@ -8,6 +8,7 @@ sends 6-byte rumble frames back over its stdout. Both formats are defined
 in ``com2tty.core.frames``.
 """
 import ctypes
+import os
 
 from ..core.frames import (  # noqa: F401 (re-exports kept for compatibility)
     FRAME_FORMAT,
@@ -61,10 +62,16 @@ class _XINPUT_VIBRATION(ctypes.Structure):
 
 
 def _load_xinput():
+    # Load by absolute System32 path rather than bare name so a stray
+    # ``xinput1_4.dll`` in the current working directory cannot be loaded
+    # in preference to the system copy (DLL hijacking).
+    system_dir = os.path.join(
+        os.environ.get("SystemRoot", r"C:\Windows"), "System32")
     last_err = None
     for name in _XINPUT_DLLS:
+        dll_path = os.path.join(system_dir, name + ".dll")
         try:
-            return getattr(ctypes.windll, name)
+            return ctypes.WinDLL(dll_path)
         except OSError as exc:  # pragma: no cover - depends on host DLLs
             last_err = exc
             continue

{com2tty-0.3.0 → com2tty-0.3.1}/src/com2tty/windows/os_hacks/autoplay.py

@@ -23,8 +23,12 @@ _AUTOPLAY_VALUE_NAME = "DisableAutoplay"
 
 
 def _autoplay_marker_path():
-    import tempfile
-    return os.path.join(tempfile.gettempdir(), AUTOPLAY_MARKER_FILENAME)
+    # Keep the recovery marker in the user's private LocalAppData rather than
+    # the world-writable system temp dir: the static filename there is open to
+    # file-squatting and symlink/junction attacks that could block execution
+    # or feed attacker-controlled values back into the registry restore.
+    base = os.environ.get("LOCALAPPDATA") or os.path.expanduser("~")
+    return os.path.join(base, AUTOPLAY_MARKER_FILENAME)
 
 
 def _restore_autoplay_state(existed, original_value):

{com2tty-0.3.0 → com2tty-0.3.1}/src/com2tty/windows/os_hacks/console.py

@@ -9,6 +9,16 @@ def enable_vt_mode():
     try:
         import ctypes
         kernel32 = ctypes.windll.kernel32
+        # GetStdHandle returns a HANDLE (pointer-sized); without an explicit
+        # restype ctypes truncates it to a 32-bit int before it is handed to
+        # Get/SetConsoleMode.
+        kernel32.GetStdHandle.argtypes = [ctypes.c_uint32]
+        kernel32.GetStdHandle.restype = ctypes.c_void_p
+        kernel32.GetConsoleMode.argtypes = [
+            ctypes.c_void_p, ctypes.POINTER(ctypes.c_uint32)]
+        kernel32.GetConsoleMode.restype = ctypes.c_int  # BOOL
+        kernel32.SetConsoleMode.argtypes = [ctypes.c_void_p, ctypes.c_uint32]
+        kernel32.SetConsoleMode.restype = ctypes.c_int  # BOOL
         handle = kernel32.GetStdHandle(-11)  # STD_OUTPUT_HANDLE
         mode = ctypes.c_uint32()
         if not kernel32.GetConsoleMode(handle, ctypes.byref(mode)):

{com2tty-0.3.0 → com2tty-0.3.1}/src/com2tty/windows/os_hacks/device_watcher.py

@@ -75,6 +75,14 @@ class DeviceChangeWatcher:
             user32 = ctypes.windll.user32
             user32.CreateWindowExW.restype = ctypes.c_void_p
             user32.RegisterDeviceNotificationW.restype = ctypes.c_void_p
+            # DefWindowProcW returns an LRESULT (pointer-sized). Without an
+            # explicit restype ctypes truncates it to a 32-bit int, so the
+            # value the window procedure hands back to the OS is corrupted on
+            # 64-bit Windows.
+            user32.DefWindowProcW.restype = ctypes.c_ssize_t
+            user32.DefWindowProcW.argtypes = [
+                ctypes.c_void_p, ctypes.c_uint,
+                ctypes.c_void_p, ctypes.c_void_p]
 
             hwnd = user32.CreateWindowExW(
                 0, "STATIC", "com2tty-devnotify", 0, 0, 0, 0, 0,

{com2tty-0.3.0 → com2tty-0.3.1}/src/com2tty/windows/os_hacks/explorer.py

@@ -18,8 +18,31 @@ from ...core.constants import EXPLORER_WINDOW_CLASS, UF2_VOLUME_LABELS
 WM_CLOSE = 0x0010
 SW_HIDE = 0
 
-#: How often the background closer re-scans the desktop window list.
-CLOSER_SCAN_INTERVAL = 0.01
+#: How often the background closer re-scans the desktop window list. 100 ms
+#: is imperceptible to the user but enumerating every top-level window at
+#: 100 Hz burned noticeable CPU, especially with many windows open.
+CLOSER_SCAN_INTERVAL = 0.1
+
+
+def _declare_window_apis(ctypes, EnumWindows, EnumWindowsProc, GetClassNameW,
+                         GetWindowTextW, ShowWindow, PostMessageW):
+    """Pin the user32 signatures so 64-bit HWNDs are not truncated.
+
+    Window handles are pointer-sized; passed through ctypes' default 32-bit
+    int argument type they would be clipped on 64-bit Windows, addressing the
+    wrong (or no) window.
+    """
+    EnumWindows.argtypes = [EnumWindowsProc, ctypes.c_void_p]
+    EnumWindows.restype = ctypes.c_bool
+    GetClassNameW.argtypes = [ctypes.c_void_p, ctypes.c_wchar_p, ctypes.c_int]
+    GetClassNameW.restype = ctypes.c_int
+    GetWindowTextW.argtypes = [ctypes.c_void_p, ctypes.c_wchar_p, ctypes.c_int]
+    GetWindowTextW.restype = ctypes.c_int
+    ShowWindow.argtypes = [ctypes.c_void_p, ctypes.c_int]
+    ShowWindow.restype = ctypes.c_bool
+    PostMessageW.argtypes = [
+        ctypes.c_void_p, ctypes.c_uint, ctypes.c_void_p, ctypes.c_void_p]
+    PostMessageW.restype = ctypes.c_bool
 
 
 def close_explorer_for_drive(drive_letter):
@@ -32,6 +55,9 @@ def close_explorer_for_drive(drive_letter):
         GetWindowTextW = ctypes.windll.user32.GetWindowTextW
         ShowWindow = ctypes.windll.user32.ShowWindow
         PostMessageW = ctypes.windll.user32.PostMessageW
+        _declare_window_apis(ctypes, EnumWindows, EnumWindowsProc,
+                             GetClassNameW, GetWindowTextW, ShowWindow,
+                             PostMessageW)
 
         dl = drive_letter[0].upper()
         # Use the parenthesised "(X:)" form Explorer renders in titles; a
@@ -61,7 +87,7 @@ class BootselWindowCloser:
     """Background thread closing BOOTSEL Explorer windows as they appear.
 
     Scans every ``CLOSER_SCAN_INTERVAL`` seconds while a UF2 flash is in
-    progress, so a window AutoPlay manages to open is hidden within ~10 ms.
+    progress, so a window AutoPlay manages to open is hidden within ~100 ms.
     ``target_letters`` is a *live* list: the flash routine appends the
     discovered drive letter once known, and subsequent scans match it too.
     """
@@ -90,6 +116,9 @@ class BootselWindowCloser:
             GetWindowTextW = ctypes.windll.user32.GetWindowTextW
             ShowWindow = ctypes.windll.user32.ShowWindow
             PostMessageW = ctypes.windll.user32.PostMessageW
+            _declare_window_apis(ctypes, EnumWindows, EnumWindowsProc,
+                                 GetClassNameW, GetWindowTextW, ShowWindow,
+                                 PostMessageW)
 
             def foreach_window(hwnd, lParam):
                 class_name = ctypes.create_unicode_buffer(256)

{com2tty-0.3.0 → com2tty-0.3.1}/src/com2tty/windows/serial_host.py

@@ -80,7 +80,16 @@ def get_commstate_baudrate(port, _kernel32=None):
 
     try:
         kernel32 = _kernel32 if _kernel32 is not None else ctypes.windll.kernel32
+        # Declare the Win32 signatures so 64-bit handles/pointers are not
+        # truncated to ctypes' default 32-bit int.
+        kernel32.CreateFileW.argtypes = [
+            ctypes.c_wchar_p, ctypes.c_uint32, ctypes.c_uint32,
+            ctypes.c_void_p, ctypes.c_uint32, ctypes.c_uint32, ctypes.c_void_p]
         kernel32.CreateFileW.restype = ctypes.c_void_p
+        kernel32.GetCommState.argtypes = [ctypes.c_void_p, ctypes.c_void_p]
+        kernel32.GetCommState.restype = ctypes.c_int  # BOOL
+        kernel32.CloseHandle.argtypes = [ctypes.c_void_p]
+        kernel32.CloseHandle.restype = ctypes.c_int  # BOOL
         # The \\.\ prefix is required for COM10 and above, harmless below.
         handle = kernel32.CreateFileW(
             "\\\\.\\" + port, GENERIC_READ | GENERIC_WRITE, 0, None,