railmux 0.3.1.dev202608010__tar.gz → 0.3.2.dev4__tar.gz

{railmux-0.3.1.dev202608010/src/railmux.egg-info → railmux-0.3.2.dev4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.3.1.dev202608010
+Version: 0.3.2.dev4
 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
@@ -127,6 +131,12 @@ not permanent traps: press `o`, or choose **More → Options**, to change them
 later. One-time safety confirmations such as dependency installation and
 session deletion are intentionally asked at the action itself.
 
+For setup outside the full-screen UI, run `railmux config`; it edits the same
+settings as Options and also covers executable paths, SSH history capacity,
+and the runtime locale. Use `railmux config --remote your-server` to configure
+that host without opening or resizing its tmux workspace. See
+[Configuration](#configuration) for the complete interface.
+
 If ordinary SSH cannot keep up with full-screen redraws, install Railmux on
 your local macOS, Linux, or Windows WSL environment and use its responsive,
 locally cached SSH display:

{railmux-0.3.1.dev202608010 → railmux-0.3.2.dev4}/README.md

@@ -85,6 +85,12 @@ not permanent traps: press `o`, or choose **More → Options**, to change them
 later. One-time safety confirmations such as dependency installation and
 session deletion are intentionally asked at the action itself.
 
+For setup outside the full-screen UI, run `railmux config`; it edits the same
+settings as Options and also covers executable paths, SSH history capacity,
+and the runtime locale. Use `railmux config --remote your-server` to configure
+that host without opening or resizing its tmux workspace. See
+[Configuration](#configuration) for the complete interface.
+
 If ordinary SSH cannot keep up with full-screen redraws, install Railmux on
 your local macOS, Linux, or Windows WSL environment and use its responsive,
 locally cached SSH display:

{railmux-0.3.1.dev202608010 → railmux-0.3.2.dev4}/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.3.2.dev4/src/railmux/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.3.2.dev4"

{railmux-0.3.1.dev202608010 → railmux-0.3.2.dev4}/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.1.dev202608010 → railmux-0.3.2.dev4}/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.1.dev202608010 → railmux-0.3.2.dev4}/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.1.dev202608010 → railmux-0.3.2.dev4}/src/railmux/diagnostics.py

@@ -151,6 +151,8 @@ def _tool_diagnostic(
             env=environ,
             capture_output=True,
             text=True,
+            encoding="utf-8",
+            errors="replace",
             timeout=3,
             check=False,
         )
@@ -300,6 +302,8 @@ def collect_doctor_snapshot(
                 env=effective_env,
                 capture_output=True,
                 text=True,
+                encoding="utf-8",
+                errors="replace",
                 timeout=2,
                 check=False,
             )

{railmux-0.3.1.dev202608010 → railmux-0.3.2.dev4}/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,14 +38,14 @@ 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]:
     try:
-        data = json.loads(_path_cache_file().read_text())
+        data = json.loads(_path_cache_file().read_text(encoding="utf-8"))
         return data if isinstance(data, dict) else {}
-    except (OSError, json.JSONDecodeError):
+    except (OSError, UnicodeError, json.JSONDecodeError):
         return {}
 
 
@@ -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.1.dev202608010 → railmux-0.3.2.dev4}/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
@@ -48,6 +45,7 @@ from railmux.fast_display_input import (
     SelectionSegment,
     SgrMouseEvent,
     TermuxTouchKeyboard,
+    TouchKeyboardAction,
     TerminalInputDecoder,
     is_termux_environment,
     page_key_direction,
@@ -80,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
@@ -224,6 +224,33 @@ def compact_status_row(screen: AppliedScreen) -> int | None:
     return None
 
 
+def termux_prompt_touch_action(
+    touch_keyboard: TermuxTouchKeyboard,
+    event: SgrMouseEvent,
+    history: LocalHistoryView,
+    screen: AppliedScreen | None,
+    *,
+    now: float | None = None,
+) -> TouchKeyboardAction:
+    """Classify one translated Termux tap against live screen route authority."""
+    if screen is None:
+        return TouchKeyboardAction()
+    clicked_pane_id = history.pane_id_at_position(event.x - 1, event.y - 1)
+    cursor_pane_id = history.pane_id_at_position(
+        screen.cursor_x,
+        screen.cursor_y,
+    )
+    return touch_keyboard.pointer_event(
+        event,
+        clicked_pane_id=clicked_pane_id,
+        cursor_pane_id=cursor_pane_id,
+        cursor_y=screen.cursor_y,
+        pane_frozen=history.pane_is_frozen(clicked_pane_id),
+        navigation_row=compact_status_row(screen),
+        now=now,
+    )
+
+
 class ProbeError(RuntimeError):
     """A bounded, user-facing SSH display failure."""
 
@@ -292,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:
@@ -388,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:
@@ -575,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:
@@ -1862,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)
 
@@ -2385,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()
@@ -2738,34 +2751,16 @@ def run(args: argparse.Namespace) -> int:
                     latest_screen.cursor_x, latest_screen.cursor_y
                 )
             )
-            clicked_pane_id = (
-                None
-                if latest_screen is None
-                else history.pane_id_at_position(part.x - 1, part.y - 1)
-            )
-            cursor_pane_id = (
-                None
-                if latest_screen is None
-                else history.pane_id_at_position(
-                    latest_screen.cursor_x,
-                    latest_screen.cursor_y,
-                )
-            )
             status_row = (
                 compact_status_row(latest_screen)
                 if latest_screen is not None
                 else None
             )
-            touch_action = touch_keyboard.pointer_event(
+            touch_action = termux_prompt_touch_action(
+                touch_keyboard,
                 part,
-                clicked_pane_id=clicked_pane_id,
-                cursor_pane_id=cursor_pane_id,
-                cursor_y=0 if latest_screen is None else latest_screen.cursor_y,
-                cursor_visible=(
-                    False if latest_screen is None else latest_screen.cursor_visible
-                ),
-                pane_frozen=history.pane_is_frozen(clicked_pane_id),
-                navigation_row=status_row,
+                history,
+                latest_screen,
                 now=time.monotonic(),
             )
             if touch_action.suspend_mouse:
@@ -2948,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.1.dev202608010 → railmux-0.3.2.dev4}/src/railmux/fast_display_input.py

@@ -129,7 +129,6 @@ class TermuxTouchKeyboard:
         clicked_pane_id: str | None,
         cursor_pane_id: str | None,
         cursor_y: int,
-        cursor_visible: bool,
         pane_frozen: bool,
         navigation_row: int | None = None,
         now: float | None = None,
@@ -150,7 +149,6 @@ class TermuxTouchKeyboard:
             or self._active
             or self._close_reassert_pending
             or pane_frozen
-            or not cursor_visible
             or clicked_pane_id is None
             or clicked_pane_id != cursor_pane_id
             or (navigation_row is not None and event.y == navigation_row)
@@ -158,6 +156,11 @@ class TermuxTouchKeyboard:
             or not self._is_plain_left_press(event)
         ):
             return TouchKeyboardAction()
+        # DEC cursor visibility is presentation state, not prompt authority.
+        # Providers may hide the hardware cursor while retaining its exact
+        # input coordinates. The verified live-agent route, matching cursor
+        # route, unfrozen viewport, and bounded row distance remain the
+        # fail-closed authority for yielding one Termux tap.
         requested_at = time.monotonic() if now is None else now
         # A rapid reopen supersedes the delayed ownership reassertion queued by
         # the previous close; Termux must receive this new native prompt tap.

{railmux-0.3.1.dev202608010 → railmux-0.3.2.dev4}/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.1.dev202608010 → railmux-0.3.2.dev4}/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:
@@ -28,10 +29,10 @@ class Favorites:
         if not self._path.is_file():
             return
         try:
-            data = json.loads(self._path.read_text())
+            data = json.loads(self._path.read_text(encoding="utf-8"))
             if isinstance(data, list):
                 self._ids = set(data)
-        except (json.JSONDecodeError, OSError):
+        except (json.JSONDecodeError, OSError, UnicodeError):
             self._ids = set()
 
     def _save(self) -> None: