railmux 0.3.3.dev2__tar.gz → 0.4.0.dev2__tar.gz

{railmux-0.3.3.dev2/src/railmux.egg-info → railmux-0.4.0.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.3.3.dev2
+Version: 0.4.0.dev2
 Summary: Terminal UI to navigate, resume, and start Claude Code and Codex sessions
 Author-email: Rightglow <zhang.taian@foxmail.com>
 License-Expression: MIT
@@ -14,12 +14,14 @@ Classifier: Environment :: Console :: Curses
 Classifier: Intended Audience :: Developers
 Classifier: Operating System :: POSIX :: Linux
 Classifier: Operating System :: MacOS
+Classifier: Operating System :: Microsoft :: Windows
 Classifier: Programming Language :: Python :: 3
 Classifier: Programming Language :: Python :: 3.9
 Classifier: Programming Language :: Python :: 3.10
 Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
+Classifier: Programming Language :: Python :: 3.14
 Classifier: Topic :: Software Development
 Classifier: Topic :: Terminals
 Classifier: Topic :: Utilities
@@ -30,6 +32,8 @@ Requires-Dist: packaging>=23.0
 Requires-Dist: tomlkit<1,>=0.13.2
 Requires-Dist: urwid>=2.6.16
 Requires-Dist: tomli>=2.0.1; python_version < "3.11"
+Requires-Dist: pyte<0.9,>=0.8.2; sys_platform == "win32"
+Requires-Dist: pywinpty<4,>=3.0.5; sys_platform == "win32"
 Provides-Extra: ssh
 Requires-Dist: pyte<0.9,>=0.8.2; extra == "ssh"
 Provides-Extra: dev

{railmux-0.3.3.dev2 → railmux-0.4.0.dev2}/pyproject.toml

@@ -20,12 +20,14 @@ classifiers = [
   "Intended Audience :: Developers",
   "Operating System :: POSIX :: Linux",
   "Operating System :: MacOS",
+  "Operating System :: Microsoft :: Windows",
   "Programming Language :: Python :: 3",
   "Programming Language :: Python :: 3.9",
   "Programming Language :: Python :: 3.10",
   "Programming Language :: Python :: 3.11",
   "Programming Language :: Python :: 3.12",
   "Programming Language :: Python :: 3.13",
+  "Programming Language :: Python :: 3.14",
   "Topic :: Software Development",
   "Topic :: Terminals",
   "Topic :: Utilities",
@@ -35,6 +37,8 @@ dependencies = [
   "tomlkit>=0.13.2,<1",
   "urwid>=2.6.16",
   "tomli>=2.0.1; python_version < '3.11'",
+  "pyte>=0.8.2,<0.9; sys_platform == 'win32'",
+  "pywinpty>=3.0.5,<4; sys_platform == 'win32'",
 ]
 
 [project.optional-dependencies]

railmux-0.4.0.dev2/src/railmux/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.4.0.dev2"

{railmux-0.3.3.dev2 → railmux-0.4.0.dev2}/src/railmux/cli.py

@@ -1,18 +1,18 @@
 from __future__ import annotations
 
 import argparse
+import os
 import shutil
 import subprocess
 import sys
-import termios
 import time
 from dataclasses import replace
 from pathlib import Path
 
 from railmux import __version__
 from railmux.config import ConfigError, default_config_path, load_config
-from railmux.diagnostics import is_ssh_session, run_doctor
 from railmux.pane_surface import render_startup_surface
+from railmux.platform import python_support_error
 from railmux.runtime_config import (
     activate_runtime_environment,
     check_executable,
@@ -37,9 +37,29 @@ _LOCAL_WATCHDOG_INTERVAL = 5.0
 _LOCAL_WATCHDOG_FAILURES = 3
 
 
+def _native_windows() -> bool:
+    return os.name == "nt"
+
+
+def is_ssh_session(environment: dict[str, str] | None = None) -> bool:
+    """Lazy compatibility wrapper that keeps POSIX diagnostics import-clean."""
+    from railmux.diagnostics import is_ssh_session as detect
+
+    return detect(environment)
+
+
+def run_doctor(*args: object, **kwargs: object) -> int:
+    """Lazy compatibility wrapper for the established CLI test/repair hook."""
+    from railmux.diagnostics import run_doctor as doctor
+
+    return doctor(*args, **kwargs)
+
+
 def _restore_terminal(attributes: list | None) -> None:
     if attributes is None:
         return
+    import termios
+
     try:
         termios.tcsetattr(sys.stdin.fileno(), termios.TCSADRAIN, attributes)
     except (OSError, termios.error):
@@ -67,6 +87,8 @@ def _run_tmux_client_with_watchdog(
     """Keep one monitor outside tmux so a frozen server cannot trap the TTY."""
     attributes = None
     if sys.stdin.isatty():
+        import termios
+
         try:
             attributes = termios.tcgetattr(sys.stdin.fileno())
         except (OSError, termios.error):
@@ -152,6 +174,10 @@ def _run_tmux_client_with_watchdog(
 
 
 def main(argv: list[str] | None = None) -> int:
+    support_error = python_support_error()
+    if support_error is not None:
+        print(f"error: {support_error}", file=sys.stderr)
+        return 2
     raw_args = list(sys.argv[1:] if argv is None else argv)
     if raw_args and raw_args[0] == "config":
         from railmux.config_cli import main as config_main
@@ -338,6 +364,18 @@ def main(argv: list[str] | None = None) -> int:
             file=sys.stderr,
         )
         return 2
+    if _native_windows():
+        # Native Windows owns no local tmux server. The detached daemon keeps
+        # ConPTY handles alive while this terminal remains a disposable client.
+        activate_runtime_environment(replace(config, tmux_binary="tmux"))
+        if not args.inside_tmux:
+            from railmux.self_update import maybe_upgrade_before_launch
+            from railmux.settings import Settings
+
+            maybe_upgrade_before_launch(raw_args, Settings())
+        from railmux.winlocal.client import main as native_main
+
+        return native_main(raw_args, config=config)
     if config.tmux_binary != "tmux":
         tmux_check = check_executable("tmux", config.tmux_binary)
         if not tmux_check.valid:

{railmux-0.3.3.dev2 → railmux-0.4.0.dev2}/src/railmux/codex_index.py

@@ -13,12 +13,15 @@ import hashlib
 import json
 import math
 import os
-import stat
 import time
 from dataclasses import dataclass, replace
 from pathlib import Path
 
 from railmux.atomic_file import atomic_write_text
+from railmux.platform.file_security import (
+    prepare_private_directory,
+    private_regular_file,
+)
 from railmux.models import (
     AttentionCategory,
     AttentionState,
@@ -457,9 +460,7 @@ class CodexIndex:
         try:
             info = path.lstat()
             if (
-                not stat.S_ISREG(info.st_mode)
-                or info.st_uid != os.getuid()
-                or info.st_mode & 0o077
+                not private_regular_file(info)
                 or info.st_size > _PERSISTENT_CACHE_MAX_BYTES
             ):
                 return
@@ -514,17 +515,7 @@ class CodexIndex:
         path = self._cache_path
         if path is None:
             return False
-        parent = path.parent
-        try:
-            parent.mkdir(mode=0o700, parents=True, exist_ok=True)
-            info = parent.lstat()
-            if not stat.S_ISDIR(info.st_mode) or info.st_uid != os.getuid():
-                return False
-            if info.st_mode & 0o077:
-                os.chmod(parent, stat.S_IMODE(info.st_mode) & ~0o077)
-            return True
-        except OSError:
-            return False
+        return prepare_private_directory(path.parent)
 
     def _save_persistent_cache(self) -> None:
         path = self._cache_path

{railmux-0.3.3.dev2 → railmux-0.4.0.dev2}/src/railmux/config.py

@@ -6,6 +6,8 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import Any
 
+from railmux.platform.config_paths import default_config_path as _platform_config_path
+
 try:
     import tomllib
 except ModuleNotFoundError:  # Python 3.9-3.10
@@ -55,7 +57,7 @@ class Config:
 
 
 def default_config_path() -> Path:
-    return Path.home() / ".config" / "railmux" / "config.toml"
+    return _platform_config_path()
 
 
 def _table(data: dict[str, Any], name: str) -> dict[str, Any]:

{railmux-0.3.3.dev2 → railmux-0.4.0.dev2}/src/railmux/discovery.py

@@ -7,7 +7,8 @@ from pathlib import Path
 
 from railmux.atomic_file import atomic_write_text
 from railmux.models import Project
-from railmux.path_codec import decode
+from railmux.path_codec import _claude_encode_path, decode
+from railmux.platform.config_paths import config_dir
 from railmux.session_index import _looks_like_uuid, _scan_session
 
 
@@ -37,7 +38,7 @@ def _path_cache_file() -> Path:
     Decoding an encoded project name is expensive on an NFS home (see
     path_codec), and the mapping is stable, so we persist it across launches.
     """
-    return Path.home() / ".config" / "railmux" / "path-cache.json"
+    return config_dir() / "path-cache.json"
 
 
 def _load_path_cache() -> dict[str, str]:
@@ -94,7 +95,7 @@ def list_projects(claude_home: Path) -> list[Project]:
         for entry in scan:
             if not entry.is_dir(follow_symlinks=False):
                 continue
-            if not entry.name.startswith("-"):
+            if os.name != "nt" and not entry.name.startswith("-"):
                 continue
             seen.add(entry.name)
 
@@ -106,10 +107,16 @@ def list_projects(claude_home: Path) -> list[Project]:
             if cached is not None and Path(cached).is_dir():
                 real_path = Path(cached)
             else:
-                try:
-                    decoded = decode(entry.name)
-                except ValueError:
-                    decoded = None
+                decoded = None
+                if os.name == "nt":
+                    decoded = _windows_project_path_from_transcript(
+                        Path(entry.path), entry.name
+                    )
+                else:
+                    try:
+                        decoded = decode(entry.name)
+                    except ValueError:
+                        pass
                 # Skip projects whose original directory no longer exists on
                 # this machine (deleted or moved). They can't be launched —
                 # `cd` into a missing dir fails — so don't list them, and drop
@@ -156,6 +163,58 @@ def list_projects(claude_home: Path) -> list[Project]:
     return results
 
 
+def _windows_project_path_from_transcript(
+    claude_dir: Path,
+    encoded_name: str,
+) -> Path | None:
+    """Recover a Windows project cwd from provider-owned transcript metadata.
+
+    Drive letters and UNC roots do not fit the POSIX path backtracker. Claude
+    records the exact cwd in its JSONL, so validate that bounded value against
+    the enclosing encoded directory instead of guessing a Windows path.
+    """
+    try:
+        candidates = sorted(
+            claude_dir.glob("*.jsonl"),
+            key=lambda path: path.stat().st_mtime_ns,
+            reverse=True,
+        )[:8]
+    except OSError:
+        return None
+    for path in candidates:
+        try:
+            with path.open("r", encoding="utf-8", errors="replace") as stream:
+                for _line_number in range(64):
+                    line = stream.readline(64 * 1024 + 1)
+                    if not line:
+                        break
+                    if len(line) > 64 * 1024:
+                        continue
+                    try:
+                        record = json.loads(line)
+                    except (json.JSONDecodeError, ValueError):
+                        continue
+                    raw_cwd = record.get("cwd") if isinstance(record, dict) else None
+                    if (
+                        not isinstance(raw_cwd, str)
+                        or not raw_cwd
+                        or len(raw_cwd) > 32768
+                        or "\0" in raw_cwd
+                    ):
+                        continue
+                    candidate = Path(raw_cwd)
+                    if (
+                        candidate.is_absolute()
+                        and candidate.is_dir()
+                        and _claude_encode_path(str(candidate)).casefold()
+                        == encoded_name.casefold()
+                    ):
+                        return candidate
+        except OSError:
+            continue
+    return None
+
+
 def _count_and_latest_mtime(claude_dir: Path, real_path: Path) -> tuple[int, float]:
     """Count sessions that pass every ``_scan_session`` filter and return the max
     JSONL mtime.  Uses ``_scan_session`` so the count exactly matches the

{railmux-0.3.3.dev2 → railmux-0.4.0.dev2}/src/railmux/display_transport.py

@@ -738,22 +738,6 @@ class AgentDisplayTransport:
     def _with_phase(state: SwapState, phase: str) -> SwapState:
         return SwapState(**{**asdict(state), "phase": phase})
 
-    @staticmethod
-    def _fit_home_to_display(state: SwapState) -> None:
-        """Best-effort preserve the provider's visible geometry at home.
-
-        While a real pane is displayed, its named session contains only the
-        inert placeholder.  Resize that detached home window to the real
-        pane's current size before swapping back.  Otherwise background output
-        is formatted at the placeholder's older (often much narrower) launch
-        geometry and later appears as a narrow discontinuity in scrollback.
-
-        Geometry is presentation-only: failure must never weaken or abort the
-        identity-pinned return transaction.
-        """
-        tmux_ctl.fit_session_to_pane(
-            state.agent_tmux_name, state.agent_pane_id)
-
     def park(self, slot: AgentSlot) -> bool:
         """Move one displayed swap agent home without forgetting its slot.
 
@@ -780,7 +764,6 @@ class AgentDisplayTransport:
         parking = self._with_phase(state, "parking")
         if not _write_marker_pair(parking, slot.key):
             return False
-        self._fit_home_to_display(state)
         if not tmux_ctl.swap_panes(
                 state.agent_pane_id, state.placeholder_pane_id):
             _write_marker_pair(state, slot.key)
@@ -874,7 +857,6 @@ class AgentDisplayTransport:
                 return False
             returning = SwapState(**{**asdict(state), "phase": "returning"})
             _write_marker_pair(returning, slot.key)
-            self._fit_home_to_display(state)
             if not tmux_ctl.swap_panes(
                     state.agent_pane_id, state.placeholder_pane_id):
                 return False

{railmux-0.3.3.dev2 → railmux-0.4.0.dev2}/src/railmux/fast_display_client.py

@@ -14,15 +14,12 @@ import base64
 import json
 import os
 import re
-import select
 import selectors
 import shlex
 import shutil
 import subprocess
 import sys
-import termios
 import time
-import tty
 from collections.abc import Callable
 from dataclasses import dataclass
 from enum import Enum
@@ -81,6 +78,8 @@ from railmux.fast_display_protocol import (
     encode_path_open_request,
     encode_resize,
 )
+from railmux.platform.console import RawConsole
+from railmux.platform.multiplex import PortableSelector, wait_readable
 from railmux.pane_surface import render_startup_surface
 from railmux.ssh_compat import CompatibilityFacts, decide as decide_compatibility
 from railmux.ssh_args import AppendSshArgument, ExtendSshArguments
@@ -320,7 +319,7 @@ def await_remote_attach_status(
         readers = [process.stdout.fileno()]
         if cancel_fd is not None:
             readers.append(cancel_fd)
-        readable, _writable, _exceptional = select.select(readers, [], [], remaining)
+        readable = wait_readable(readers, remaining)
         if not readable:
             return RemoteAttachKind.TIMEOUT
         if cancel_fd is not None and cancel_fd in readable:
@@ -416,7 +415,7 @@ def await_remote_startup(
         readers = [process.stdout.fileno()]
         if cancel_fd is not None:
             readers.append(cancel_fd)
-        readable, _writable, _exceptional = select.select(readers, [], [], remaining)
+        readable = wait_readable(readers, remaining)
         if not readable:
             return RemoteStartup(RemoteStartKind.TIMEOUT)
         if cancel_fd is not None and cancel_fd in readable:
@@ -603,20 +602,8 @@ def _is_soft_keyboard_projection(
     )
 
 
-class RawTerminal:
-    def __init__(self, fd: int) -> None:
-        self.fd = fd
-        self.saved: Optional[list[object]] = None
-
-    def __enter__(self) -> "RawTerminal":
-        self.saved = termios.tcgetattr(self.fd)
-        tty.setraw(self.fd)
-        return self
-
-    def __exit__(self, *_exc: object) -> None:
-        if self.saved is not None:
-            termios.tcsetattr(self.fd, termios.TCSADRAIN, self.saved)
-            self.saved = None
+class RawTerminal(RawConsole):
+    """Backward-compatible name for the platform raw-console port."""
 
 
 class TerminalSurface:
@@ -1890,9 +1877,7 @@ def _wait_reconnect_delay(delay: float, cancel_fd: int) -> None:
         remaining = deadline - time.monotonic()
         if remaining <= 0:
             return
-        readable, _writable, _exceptional = select.select(
-            [cancel_fd], [], [], remaining
-        )
+        readable = wait_readable([cancel_fd], remaining)
         if readable:
             _consume_reconnect_input(cancel_fd)
 
@@ -2413,7 +2398,7 @@ def run(args: argparse.Namespace) -> int:
     touch_keyboard = TermuxTouchKeyboard(
         enabled=not args.no_mouse and termux_touch
     )
-    selector = selectors.DefaultSelector()
+    selector = PortableSelector()
     selector.register(process.stdout.fileno(), selectors.EVENT_READ, "remote")
     selector.register(sys.stdin.fileno(), selectors.EVENT_READ, "local")
     started = time.monotonic()
@@ -2958,7 +2943,9 @@ def run(args: argparse.Namespace) -> int:
     )
     history_info_until = time.monotonic() + _HISTORY_INFO_SECONDS
     try:
-        with RawTerminal(sys.stdin.fileno()):
+        with RawTerminal(
+            sys.stdin.fileno(), output_fd=sys.stdout.fileno()
+        ):
             while True:
                 observed_size = os.get_terminal_size(sys.stdout.fileno())
                 if observed_size != local_size:

{railmux-0.3.3.dev2 → railmux-0.4.0.dev2}/src/railmux/fast_display_server.py

@@ -83,6 +83,11 @@ from railmux.fast_display_protocol import (
     encode_path_open_result,
     encode_update,
 )
+from railmux.terminal_emulator import (
+    extended_pyte as _shared_extended_pyte,
+    render_rows as _shared_render_rows,
+    terminal_modes_for_screen as _shared_terminal_modes_for_screen,
+)
 from railmux.ui.workspace import (
     COMPACT_ENTER_HEIGHT,
     COMPACT_ENTER_WIDTH,
@@ -371,9 +376,7 @@ def _build_extended_pyte(pyte: object) -> object:
 
 def _extended_pyte(pyte: object) -> object:
     """Idempotently adapt one imported pyte module for tmux's VT stream."""
-    if getattr(pyte, "_railmux_extended", False):
-        return pyte
-    return _build_extended_pyte(pyte)
+    return _shared_extended_pyte(pyte)
 
 
 @dataclass(frozen=True)
@@ -1887,42 +1890,12 @@ def _style_key(char: object) -> tuple[object, ...]:
 
 def render_rows(screen: object) -> tuple[bytes, ...]:
     """Render independently paintable rows with allowlisted SGR controls."""
-    rendered_rows: list[bytes] = []
-    for row_index in range(screen.lines):
-        rendered = [b"\033[0m"]
-        previous_style: tuple[object, ...] | None = None
-        row = screen.buffer[row_index]
-        for column in range(screen.columns):
-            char = row[column]
-            style = _style_key(char)
-            if style != previous_style:
-                rendered.append(_style(char))
-                previous_style = style
-            # pyte represents the second cell of a wide glyph as empty data;
-            # the real terminal already advances two columns for the glyph.
-            if char.data:
-                safe_data = "".join(
-                    value
-                    if value >= " "
-                    and value != "\x7f"
-                    and not "\x80" <= value <= "\x9f"
-                    else "�"
-                    for value in char.data
-                )
-                rendered.append(safe_data.encode("utf-8", errors="replace"))
-        rendered.append(b"\033[0m")
-        rendered_rows.append(b"".join(rendered))
-    return tuple(rendered_rows)
+    return _shared_render_rows(screen)
 
 
 def terminal_modes_for_screen(screen: object) -> TerminalMode:
     """Project pyte's private-mode set onto the bounded v14 wire allowlist."""
-    terminal_modes = TerminalMode.NONE
-    if 2004 << 5 in screen.mode:
-        terminal_modes |= TerminalMode.BRACKETED_PASTE
-    if 1004 << 5 in screen.mode:
-        terminal_modes |= TerminalMode.FOCUS_EVENTS
-    return terminal_modes
+    return _shared_terminal_modes_for_screen(screen)
 
 
 def _child_exited(pid: int) -> bool:

{railmux-0.3.3.dev2 → railmux-0.4.0.dev2}/src/railmux/favorites.py

@@ -10,10 +10,11 @@ import json
 from pathlib import Path
 
 from railmux.atomic_file import atomic_write_text
+from railmux.platform.config_paths import config_dir
 
 
 def _favorites_path() -> Path:
-    return Path.home() / ".config" / "railmux" / "favorites.json"
+    return config_dir() / "favorites.json"
 
 
 class Favorites:

{railmux-0.3.3.dev2 → railmux-0.4.0.dev2}/src/railmux/help_workspace.py

@@ -1,12 +1,12 @@
 """Materialise the private, read-only context used by Ask Railmux."""
 from __future__ import annotations
 
-import os
 from importlib import metadata
 from pathlib import Path
 
 from railmux import __version__
 from railmux.atomic_file import atomic_write_text
+from railmux.platform.config_paths import data_dir
 
 
 _FALLBACK_GUIDE = """# Railmux
@@ -35,12 +35,7 @@ permissions.
 
 def help_workspace_path() -> Path:
     """Return Railmux's per-user help workspace, following the XDG spec."""
-    raw = os.environ.get("XDG_DATA_HOME")
-    if raw:
-        candidate = Path(raw).expanduser()
-        if candidate.is_absolute():
-            return candidate / "railmux" / "help"
-    return Path.home() / ".local" / "share" / "railmux" / "help"
+    return data_dir() / "help"
 
 
 def _source_readme() -> str | None:

railmux-0.4.0.dev2/src/railmux/local_clipboard.py

@@ -0,0 +1,101 @@
+"""Best-effort native clipboard writers for explicit user copy actions."""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import sys
+
+
+def command() -> tuple[str, ...] | None:
+    """Return a trusted platform clipboard command, if one is available."""
+    if os.name == "nt":
+        return None
+    if sys.platform == "darwin":
+        if executable := shutil.which("pbcopy"):
+            return (executable,)
+        return None
+    if os.environ.get("WAYLAND_DISPLAY"):
+        if executable := shutil.which("wl-copy"):
+            return (executable,)
+    if os.environ.get("DISPLAY"):
+        if executable := shutil.which("xclip"):
+            return (executable, "-selection", "clipboard")
+        if executable := shutil.which("xsel"):
+            return (executable, "--clipboard", "--input")
+    if os.environ.get("WSL_DISTRO_NAME") or os.environ.get("WSL_INTEROP"):
+        if executable := shutil.which("clip.exe"):
+            return (executable,)
+    return None
+
+
+def copy(data: bytes) -> bool:
+    """Write bytes to the local OS clipboard without invoking a shell."""
+    if os.name == "nt":
+        return _copy_windows(data)
+    writer = command()
+    if writer is None:
+        return False
+    try:
+        result = subprocess.run(
+            writer,
+            input=data,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+            timeout=2.0,
+            check=False,
+        )
+    except (OSError, subprocess.SubprocessError):
+        return False
+    return result.returncode == 0
+
+
+def _copy_windows(data: bytes) -> bool:
+    """Write bounded UTF-8 data as CF_UNICODETEXT using the Win32 API."""
+    import ctypes
+
+    try:
+        text = data.decode("utf-8")
+    except UnicodeDecodeError:
+        return False
+    if "\x00" in text:
+        return False
+    encoded = (text + "\x00").encode("utf-16-le")
+    kernel32 = ctypes.WinDLL("kernel32", use_last_error=True)
+    user32 = ctypes.WinDLL("user32", use_last_error=True)
+    kernel32.GlobalAlloc.argtypes = (ctypes.c_uint, ctypes.c_size_t)
+    kernel32.GlobalAlloc.restype = ctypes.c_void_p
+    kernel32.GlobalLock.argtypes = (ctypes.c_void_p,)
+    kernel32.GlobalLock.restype = ctypes.c_void_p
+    kernel32.GlobalUnlock.argtypes = (ctypes.c_void_p,)
+    kernel32.GlobalFree.argtypes = (ctypes.c_void_p,)
+    user32.SetClipboardData.argtypes = (ctypes.c_uint, ctypes.c_void_p)
+    user32.SetClipboardData.restype = ctypes.c_void_p
+    movable = 0x0002
+    handle = kernel32.GlobalAlloc(movable, len(encoded))
+    if not handle:
+        return False
+    owned_by_clipboard = False
+    try:
+        pointer = kernel32.GlobalLock(handle)
+        if not pointer:
+            return False
+        try:
+            ctypes.memmove(pointer, encoded, len(encoded))
+        finally:
+            kernel32.GlobalUnlock(handle)
+        if not user32.OpenClipboard(None):
+            return False
+        try:
+            if not user32.EmptyClipboard():
+                return False
+            if not user32.SetClipboardData(13, handle):  # CF_UNICODETEXT
+                return False
+            owned_by_clipboard = True
+            return True
+        finally:
+            user32.CloseClipboard()
+    finally:
+        if not owned_by_clipboard:
+            kernel32.GlobalFree(handle)