railmux 0.4.0.dev1__tar.gz → 0.4.0.dev3__tar.gz

{railmux-0.4.0.dev1/src/railmux.egg-info → railmux-0.4.0.dev3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: railmux
-Version: 0.4.0.dev1
+Version: 0.4.0.dev3
 Summary: Terminal UI to navigate, resume, and start Claude Code and Codex sessions
 Author-email: Rightglow <zhang.taian@foxmail.com>
 License-Expression: MIT
@@ -14,14 +14,12 @@ 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
@@ -32,8 +30,6 @@ 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.4.0.dev1 → railmux-0.4.0.dev3}/pyproject.toml

@@ -20,14 +20,12 @@ 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",
@@ -37,8 +35,6 @@ 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]
@@ -54,7 +50,7 @@ dev = [
 ]
 
 [project.scripts]
-railmux = "railmux.cli:main"
+railmux = "railmux.entrypoint:main"
 
 [project.urls]
 Homepage = "https://rightglow.github.io/Railmux/"

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

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

{railmux-0.4.0.dev1 → railmux-0.4.0.dev3}/src/railmux/__main__.py

@@ -1,4 +1,4 @@
-from railmux.cli import main
+from railmux.entrypoint import main
 
 if __name__ == "__main__":
     raise SystemExit(main())

{railmux-0.4.0.dev1 → railmux-0.4.0.dev3}/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,29 +37,9 @@ _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):
@@ -87,8 +67,6 @@ 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):
@@ -174,10 +152,6 @@ 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
@@ -364,18 +338,6 @@ 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.4.0.dev1 → railmux-0.4.0.dev3}/src/railmux/codex_index.py

@@ -13,15 +13,12 @@ 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,
@@ -460,7 +457,9 @@ class CodexIndex:
         try:
             info = path.lstat()
             if (
-                not private_regular_file(info)
+                not stat.S_ISREG(info.st_mode)
+                or info.st_uid != os.getuid()
+                or info.st_mode & 0o077
                 or info.st_size > _PERSISTENT_CACHE_MAX_BYTES
             ):
                 return
@@ -515,7 +514,17 @@ class CodexIndex:
         path = self._cache_path
         if path is None:
             return False
-        return prepare_private_directory(path.parent)
+        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
 
     def _save_persistent_cache(self) -> None:
         path = self._cache_path

{railmux-0.4.0.dev1 → railmux-0.4.0.dev3}/src/railmux/config.py

@@ -6,8 +6,6 @@ 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
@@ -57,7 +55,7 @@ class Config:
 
 
 def default_config_path() -> Path:
-    return _platform_config_path()
+    return Path.home() / ".config" / "railmux" / "config.toml"
 
 
 def _table(data: dict[str, Any], name: str) -> dict[str, Any]:

{railmux-0.4.0.dev1 → railmux-0.4.0.dev3}/src/railmux/discovery.py

@@ -7,8 +7,7 @@ from pathlib import Path
 
 from railmux.atomic_file import atomic_write_text
 from railmux.models import Project
-from railmux.path_codec import _claude_encode_path, decode
-from railmux.platform.config_paths import config_dir
+from railmux.path_codec import decode
 from railmux.session_index import _looks_like_uuid, _scan_session
 
 
@@ -38,7 +37,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 config_dir() / "path-cache.json"
+    return Path.home() / ".config" / "railmux" / "path-cache.json"
 
 
 def _load_path_cache() -> dict[str, str]:
@@ -95,7 +94,7 @@ def list_projects(claude_home: Path) -> list[Project]:
         for entry in scan:
             if not entry.is_dir(follow_symlinks=False):
                 continue
-            if os.name != "nt" and not entry.name.startswith("-"):
+            if not entry.name.startswith("-"):
                 continue
             seen.add(entry.name)
 
@@ -107,16 +106,10 @@ def list_projects(claude_home: Path) -> list[Project]:
             if cached is not None and Path(cached).is_dir():
                 real_path = Path(cached)
             else:
-                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
+                try:
+                    decoded = decode(entry.name)
+                except ValueError:
+                    decoded = None
                 # 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
@@ -163,58 +156,6 @@ 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.4.0.dev1 → railmux-0.4.0.dev3}/src/railmux/display_transport.py

@@ -738,6 +738,22 @@ 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.
 
@@ -764,6 +780,7 @@ 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)
@@ -857,6 +874,7 @@ 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.4.0.dev3/src/railmux/entrypoint.py

@@ -0,0 +1,26 @@
+"""Platform-safe public entry point.
+
+Keep this module free of POSIX-only imports.  The Windows preview must choose
+its delegated runtime before importing the ordinary Railmux CLI, which owns
+``termios`` and the tmux-backed application.
+"""
+from __future__ import annotations
+
+import os
+from collections.abc import Sequence
+
+
+def main(
+    argv: Sequence[str] | None = None,
+    *,
+    platform_name: str | None = None,
+) -> int:
+    current_platform = os.name if platform_name is None else platform_name
+    if current_platform == "nt":
+        from railmux.windows_bootstrap import main as windows_main
+
+        return windows_main(argv)
+
+    from railmux.cli import main as posix_main
+
+    return posix_main(None if argv is None else list(argv))

{railmux-0.4.0.dev1 → railmux-0.4.0.dev3}/src/railmux/fast_display_client.py

@@ -14,12 +14,15 @@ 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
@@ -78,8 +81,6 @@ 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
@@ -319,7 +320,7 @@ def await_remote_attach_status(
         readers = [process.stdout.fileno()]
         if cancel_fd is not None:
             readers.append(cancel_fd)
-        readable = wait_readable(readers, remaining)
+        readable, _writable, _exceptional = select.select(readers, [], [], remaining)
         if not readable:
             return RemoteAttachKind.TIMEOUT
         if cancel_fd is not None and cancel_fd in readable:
@@ -415,7 +416,7 @@ def await_remote_startup(
         readers = [process.stdout.fileno()]
         if cancel_fd is not None:
             readers.append(cancel_fd)
-        readable = wait_readable(readers, remaining)
+        readable, _writable, _exceptional = select.select(readers, [], [], remaining)
         if not readable:
             return RemoteStartup(RemoteStartKind.TIMEOUT)
         if cancel_fd is not None and cancel_fd in readable:
@@ -602,8 +603,20 @@ def _is_soft_keyboard_projection(
     )
 
 
-class RawTerminal(RawConsole):
-    """Backward-compatible name for the platform raw-console port."""
+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 TerminalSurface:
@@ -1877,7 +1890,9 @@ def _wait_reconnect_delay(delay: float, cancel_fd: int) -> None:
         remaining = deadline - time.monotonic()
         if remaining <= 0:
             return
-        readable = wait_readable([cancel_fd], remaining)
+        readable, _writable, _exceptional = select.select(
+            [cancel_fd], [], [], remaining
+        )
         if readable:
             _consume_reconnect_input(cancel_fd)
 
@@ -2398,7 +2413,7 @@ def run(args: argparse.Namespace) -> int:
     touch_keyboard = TermuxTouchKeyboard(
         enabled=not args.no_mouse and termux_touch
     )
-    selector = PortableSelector()
+    selector = selectors.DefaultSelector()
     selector.register(process.stdout.fileno(), selectors.EVENT_READ, "remote")
     selector.register(sys.stdin.fileno(), selectors.EVENT_READ, "local")
     started = time.monotonic()
@@ -2943,9 +2958,7 @@ def run(args: argparse.Namespace) -> int:
     )
     history_info_until = time.monotonic() + _HISTORY_INFO_SECONDS
     try:
-        with RawTerminal(
-            sys.stdin.fileno(), output_fd=sys.stdout.fileno()
-        ):
+        with RawTerminal(sys.stdin.fileno()):
             while True:
                 observed_size = os.get_terminal_size(sys.stdout.fileno())
                 if observed_size != local_size:

{railmux-0.4.0.dev1 → railmux-0.4.0.dev3}/src/railmux/fast_display_server.py

@@ -83,11 +83,6 @@ 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,
@@ -376,7 +371,9 @@ def _build_extended_pyte(pyte: object) -> object:
 
 def _extended_pyte(pyte: object) -> object:
     """Idempotently adapt one imported pyte module for tmux's VT stream."""
-    return _shared_extended_pyte(pyte)
+    if getattr(pyte, "_railmux_extended", False):
+        return pyte
+    return _build_extended_pyte(pyte)
 
 
 @dataclass(frozen=True)
@@ -1890,12 +1887,42 @@ def _style_key(char: object) -> tuple[object, ...]:
 
 def render_rows(screen: object) -> tuple[bytes, ...]:
     """Render independently paintable rows with allowlisted SGR controls."""
-    return _shared_render_rows(screen)
+    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)
 
 
 def terminal_modes_for_screen(screen: object) -> TerminalMode:
     """Project pyte's private-mode set onto the bounded v14 wire allowlist."""
-    return _shared_terminal_modes_for_screen(screen)
+    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
 
 
 def _child_exited(pid: int) -> bool:

{railmux-0.4.0.dev1 → railmux-0.4.0.dev3}/src/railmux/favorites.py

@@ -10,11 +10,10 @@ 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 config_dir() / "favorites.json"
+    return Path.home() / ".config" / "railmux" / "favorites.json"
 
 
 class Favorites:

{railmux-0.4.0.dev1 → railmux-0.4.0.dev3}/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,7 +35,12 @@ permissions.
 
 def help_workspace_path() -> Path:
     """Return Railmux's per-user help workspace, following the XDG spec."""
-    return data_dir() / "help"
+    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"
 
 
 def _source_readme() -> str | None:

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

@@ -0,0 +1,47 @@
+"""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 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."""
+    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