speak-cli 1.1.2__tar.gz → 1.2.0__tar.gz

speak_cli-1.2.0/.github/workflows/ci.yml

@@ -0,0 +1,39 @@
+name: CI
+
+on:
+  push:
+    branches: [main]
+  pull_request:
+
+jobs:
+  test:
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
+    steps:
+      - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
+      - uses: astral-sh/setup-uv@v5
+      - run: uv sync
+      - run: uv run pytest -q
+
+      - name: Cache Supertonic models
+        uses: actions/cache@v4
+        with:
+          path: ~/.cache/supertonic3
+          key: supertonic3-models-${{ runner.os }}-v1
+
+      - name: Synthesis smoke test (one-shot)
+        run: uv run speak --no-daemon -o smoke1.wav "hello from continuous integration"
+
+      - name: Synthesis smoke test (daemon path)
+        env:
+          SPEAK_IDLE_TIMEOUT: "30"
+        run: uv run speak -o smoke2.wav "daemon transport check"
+
+      - name: Stop daemon
+        if: always()
+        run: uv run speak --stop

{speak_cli-1.1.2 → speak_cli-1.2.0}/.github/workflows/publish.yml

@@ -7,9 +7,15 @@ on:
 
 jobs:
   test:
-    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+    runs-on: ${{ matrix.os }}
     steps:
       - uses: actions/checkout@v4
+        with:
+          fetch-depth: 0
       - uses: astral-sh/setup-uv@v5
       - run: uv sync
       - run: uv run pytest -q

{speak_cli-1.1.2 → speak_cli-1.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: speak-cli
-Version: 1.1.2
+Version: 1.2.0
 Summary: Speak text out loud from the command line using Supertonic 3 (local, offline TTS)
 Project-URL: Repository, https://github.com/MohamedAliRashad/tts-cli
 Project-URL: Issues, https://github.com/MohamedAliRashad/tts-cli/issues
@@ -31,12 +31,13 @@ Description-Content-Type: text/markdown
 
 ```bash
 # If you don't have uv installed, run this first:
-curl -LsSf https://astral.sh/uv/install.sh | sh
+curl -LsSf https://astral.sh/uv/install.sh | sh                              # Linux / macOS
+powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"   # Windows
 
 # if you do just run this command
 uv tool install speak-cli
 ```
-The voice models (~400 MB) download automatically the first time you speak.
+The voice models (~400 MB) download automatically the first time you speak. Works on Linux, macOS, and Windows.
 
 ## How to use ?
 

{speak_cli-1.1.2 → speak_cli-1.2.0}/README.md

@@ -8,12 +8,13 @@
 
 ```bash
 # If you don't have uv installed, run this first:
-curl -LsSf https://astral.sh/uv/install.sh | sh
+curl -LsSf https://astral.sh/uv/install.sh | sh                              # Linux / macOS
+powershell -ExecutionPolicy ByPass -c "irm https://astral.sh/uv/install.ps1 | iex"   # Windows
 
 # if you do just run this command
 uv tool install speak-cli
 ```
-The voice models (~400 MB) download automatically the first time you speak.
+The voice models (~400 MB) download automatically the first time you speak. Works on Linux, macOS, and Windows.
 
 ## How to use ?
 

{speak_cli-1.1.2 → speak_cli-1.2.0}/src/speak_cli/daemon.py

@@ -1,18 +1,19 @@
 """Background daemon: keeps Supertonic models warm, serves synthesis requests.
 
-Run as `python -m speak_cli.daemon`. Single instance is enforced with an
-flock'd lock file; a second copy exits 0 immediately, so racing auto-spawns
-are harmless. Exits on idle timeout to free memory.
+Run as `python -m speak_cli.daemon`. Single instance is enforced with a
+locked lock file (flock on POSIX, msvcrt on Windows); a second copy exits 0
+immediately, so racing auto-spawns are harmless. Exits on idle timeout to
+free memory. Listens on a Unix socket (POSIX) or loopback TCP (Windows).
 """
 
 from __future__ import annotations
 
 import contextlib
-import fcntl
 import json
 import os
 import socket
 import sys
+from typing import IO
 
 from . import ipc
 from .engine import Engine
@@ -27,6 +28,43 @@ def _idle_timeout() -> float:
         return DEFAULT_IDLE_TIMEOUT
 
 
+def _try_lock(lock_file: IO) -> bool:
+    """Take an exclusive non-blocking lock; False if another daemon holds it."""
+    if ipc.WINDOWS:
+        import msvcrt
+
+        try:
+            lock_file.seek(0)
+            msvcrt.locking(lock_file.fileno(), msvcrt.LK_NBLCK, 1)
+            return True
+        except OSError:
+            return False
+    import fcntl
+
+    try:
+        fcntl.flock(lock_file, fcntl.LOCK_EX | fcntl.LOCK_NB)
+        return True
+    except OSError:
+        return False
+
+
+def _bind_server(paths: ipc.RuntimePaths) -> socket.socket:
+    """Bind the platform's listening socket and publish the endpoint."""
+    if ipc.WINDOWS:
+        srv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        srv.bind(("127.0.0.1", 0))
+        port = srv.getsockname()[1]
+        tmp = paths.port.with_suffix(".tmp")
+        tmp.write_text(str(port))
+        tmp.replace(paths.port)  # atomic publish
+        return srv
+    paths.sock.unlink(missing_ok=True)
+    srv = socket.socket(socket.AF_UNIX)  # type: ignore[attr-defined]
+    srv.bind(str(paths.sock))
+    os.chmod(paths.sock, 0o600)
+    return srv
+
+
 def handle_request(conn: socket.socket, engine: Engine) -> bool:
     """Serve one connection. Returns False when asked to shut down."""
     try:
@@ -63,22 +101,15 @@ def main() -> None:
     paths = ipc.runtime_paths()
 
     lock = open(paths.lock, "w")
-    try:
-        fcntl.flock(lock, fcntl.LOCK_EX | fcntl.LOCK_NB)
-    except OSError:
+    if not _try_lock(lock):
         return  # another daemon is already serving
-    lock.write(str(os.getpid()))
-    lock.flush()
 
     print(f"[daemon] starting, pid={os.getpid()}", flush=True)
     engine = Engine()
     engine.prewarm()
     print("[daemon] models loaded and prewarmed", flush=True)
 
-    paths.sock.unlink(missing_ok=True)
-    srv = socket.socket(socket.AF_UNIX)
-    srv.bind(str(paths.sock))
-    os.chmod(paths.sock, 0o600)
+    srv = _bind_server(paths)
     srv.listen(8)
     srv.settimeout(_idle_timeout())
 
@@ -95,8 +126,10 @@ def main() -> None:
                     print("[daemon] shutdown requested", flush=True)
                     break
     finally:
-        paths.sock.unlink(missing_ok=True)
-        paths.lock.unlink(missing_ok=True)
+        with contextlib.suppress(OSError):
+            paths.endpoint.unlink(missing_ok=True)
+        with contextlib.suppress(OSError):
+            paths.lock.unlink(missing_ok=True)  # may be held on Windows; fine
 
 
 if __name__ == "__main__":

{speak_cli-1.1.2 → speak_cli-1.2.0}/src/speak_cli/ipc.py

@@ -2,12 +2,17 @@
 
 Protocol: one request per connection. Client sends a single JSON line;
 daemon replies a JSON header line, then (for "speak") exactly `nbytes` of
-raw WAV. The socket filename embeds the package version, so upgrading the
-package naturally retires old daemons (they exit via idle timeout).
+raw WAV. Filenames embed the package version, so upgrading the package
+naturally retires old daemons (they exit via idle timeout).
+
+Transport: a Unix domain socket on POSIX; on Windows, loopback TCP with the
+daemon's ephemeral port stored in a `daemon-<version>.port` file. The wire
+protocol is identical, and the endpoint file's suffix selects the transport.
 """
 
 from __future__ import annotations
 
+import contextlib
 import json
 import os
 import socket
@@ -19,6 +24,8 @@ from pathlib import Path
 
 from . import __version__
 
+WINDOWS = os.name == "nt"
+
 CONNECT_TIMEOUT = 30.0  # daemon cold-start budget (models already cached)
 REQUEST_TIMEOUT = 300.0  # long texts take a while to synthesize
 
@@ -26,26 +33,42 @@ REQUEST_TIMEOUT = 300.0  # long texts take a while to synthesize
 @dataclass(frozen=True)
 class RuntimePaths:
     dir: Path
-    sock: Path
+    sock: Path  # POSIX endpoint (unix socket)
+    port: Path  # Windows endpoint (file holding the TCP port number)
     lock: Path
     daemon_log: Path
     client_log: Path
 
+    @property
+    def endpoint(self) -> Path:
+        return self.port if WINDOWS else self.sock
 
-def runtime_paths() -> RuntimePaths:
+
+def _state_dirs() -> tuple[Path, Path]:
+    """Return (run_dir, log_dir) for the current platform."""
+    if WINDOWS:
+        local = Path(os.environ.get("LOCALAPPDATA") or Path.home() / "AppData" / "Local")
+        base = local / "speak-cli"
+        return base / "run", base
     runtime = os.environ.get("XDG_RUNTIME_DIR")
     if runtime and os.path.isdir(runtime):
-        base = Path(runtime) / "speak-cli"
+        run_dir = Path(runtime) / "speak-cli"
     else:
-        base = Path.home() / ".cache" / "speak-cli" / "run"
-    base.mkdir(parents=True, exist_ok=True)
-    os.chmod(base, 0o700)
-    log_dir = Path.home() / ".cache" / "speak-cli"
+        run_dir = Path.home() / ".cache" / "speak-cli" / "run"
+    return run_dir, Path.home() / ".cache" / "speak-cli"
+
+
+def runtime_paths() -> RuntimePaths:
+    run_dir, log_dir = _state_dirs()
+    run_dir.mkdir(parents=True, exist_ok=True)
     log_dir.mkdir(parents=True, exist_ok=True)
+    with contextlib.suppress(OSError):
+        os.chmod(run_dir, 0o700)
     return RuntimePaths(
-        dir=base,
-        sock=base / f"daemon-{__version__}.sock",
-        lock=base / f"daemon-{__version__}.lock",
+        dir=run_dir,
+        sock=run_dir / f"daemon-{__version__}.sock",
+        port=run_dir / f"daemon-{__version__}.port",
+        lock=run_dir / f"daemon-{__version__}.lock",
         daemon_log=log_dir / "daemon.log",
         client_log=log_dir / "client.log",
     )
@@ -83,11 +106,38 @@ def recv_exact(sock: socket.socket, n: int) -> bytes:
     return bytes(buf)
 
 
-def _request(sock_path: Path, req: dict) -> bytes:
-    """Send one request; return WAV bytes (or b"" for control commands)."""
-    with socket.socket(socket.AF_UNIX) as s:
+def _connect(endpoint: Path) -> socket.socket:
+    """Connect to a daemon endpoint file (.sock or .port).
+
+    Raises FileNotFoundError if the endpoint file is absent and
+    ConnectionRefusedError if it exists but no daemon answers.
+    """
+    if endpoint.suffix == ".port":
+        try:
+            port = int(endpoint.read_text().strip())
+        except (OSError, ValueError):
+            raise FileNotFoundError(str(endpoint)) from None
+        s = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+        try:
+            s.settimeout(REQUEST_TIMEOUT)
+            s.connect(("127.0.0.1", port))
+        except OSError:
+            s.close()
+            raise ConnectionRefusedError(f"no daemon on port {port}") from None
+        return s
+    s = socket.socket(socket.AF_UNIX)  # type: ignore[attr-defined]
+    try:
         s.settimeout(REQUEST_TIMEOUT)
-        s.connect(str(sock_path))
+        s.connect(str(endpoint))
+    except OSError:
+        s.close()
+        raise
+    return s
+
+
+def _request(endpoint: Path, req: dict) -> bytes:
+    """Send one request; return WAV bytes (or b"" for control commands)."""
+    with contextlib.closing(_connect(endpoint)) as s:
         s.sendall(json.dumps(req).encode() + b"\n")
         header = json.loads(recv_line(s))
         if header.get("status") != "ok":
@@ -98,13 +148,22 @@ def _request(sock_path: Path, req: dict) -> bytes:
 
 def spawn_daemon(paths: RuntimePaths) -> None:
     """Start a detached daemon process; harmless if one is already running."""
+    kwargs: dict = {}
+    if WINDOWS:
+        kwargs["creationflags"] = (
+            subprocess.DETACHED_PROCESS
+            | subprocess.CREATE_NEW_PROCESS_GROUP
+            | getattr(subprocess, "CREATE_NO_WINDOW", 0)
+        )
+    else:
+        kwargs["start_new_session"] = True
     with open(paths.daemon_log, "ab") as log:
         subprocess.Popen(
             [sys.executable, "-m", "speak_cli.daemon"],
             stdin=subprocess.DEVNULL,
             stdout=log,
             stderr=log,
-            start_new_session=True,
+            **kwargs,
         )
 
 
@@ -113,19 +172,17 @@ def get_wav_from_daemon(req: dict) -> bytes:
 
     Raises on any failure — the caller falls back to one-shot synthesis.
     """
-    if os.name != "posix":
-        raise RuntimeError("daemon mode is POSIX-only")
     paths = runtime_paths()
     try:
-        return _request(paths.sock, req)
+        return _request(paths.endpoint, req)
     except (FileNotFoundError, ConnectionRefusedError):
-        # Not running (or crashed leaving a stale socket): clean up and spawn.
-        paths.sock.unlink(missing_ok=True)
+        # Not running (or crashed leaving a stale endpoint): clean up, spawn.
+        paths.endpoint.unlink(missing_ok=True)
         spawn_daemon(paths)
         deadline = time.monotonic() + CONNECT_TIMEOUT
         while True:
             try:
-                return _request(paths.sock, req)
+                return _request(paths.endpoint, req)
             except (FileNotFoundError, ConnectionRefusedError):
                 if time.monotonic() > deadline:
                     raise TimeoutError(
@@ -144,12 +201,12 @@ def stop_daemons() -> int:
     for base in candidates:
         if not base.is_dir():
             continue
-        for sock_path in base.glob("daemon-*.sock"):
+        for endpoint in [*base.glob("daemon-*.sock"), *base.glob("daemon-*.port")]:
             try:
-                _request(sock_path, {"cmd": "shutdown"})
+                _request(endpoint, {"cmd": "shutdown"})
                 stopped += 1
             except OSError:
-                sock_path.unlink(missing_ok=True)  # stale
+                endpoint.unlink(missing_ok=True)  # stale
             except Exception:
                 pass
     return stopped

speak_cli-1.2.0/src/speak_cli/playback.py

@@ -0,0 +1,104 @@
+"""Play WAV bytes through whatever audio facility the system has.
+
+No Python audio dependency on purpose: simpleaudio is unmaintained and
+sounddevice needs a system PortAudio library. On Windows the stdlib's
+winsound plays WAVs natively (PowerShell as a fallback); elsewhere every
+mainstream desktop has at least one of the players below. Each option is
+tried until one succeeds.
+"""
+
+from __future__ import annotations
+
+import os
+import shutil
+import subprocess
+import sys
+import tempfile
+
+
+class PlaybackError(RuntimeError):
+    pass
+
+
+_PLAYERS: list[tuple[str, list[str]]] = [
+    ("paplay", []),
+    ("pw-play", []),
+    ("aplay", ["-q"]),
+    ("afplay", []),
+    ("ffplay", ["-nodisp", "-autoexit", "-loglevel", "quiet"]),
+    ("play", ["-q"]),
+]
+
+
+def _tmp_dir() -> str | None:
+    runtime = os.environ.get("XDG_RUNTIME_DIR")
+    if runtime and os.path.isdir(runtime) and os.access(runtime, os.W_OK):
+        return runtime  # tmpfs: no disk I/O
+    return None
+
+
+def _play_windows(path: str, errors: list[str]) -> bool:
+    try:
+        import winsound
+
+        winsound.PlaySound(path, winsound.SND_FILENAME)
+        return True
+    except Exception as e:
+        errors.append(f"winsound: {e}")
+    powershell = shutil.which("powershell") or shutil.which("pwsh")
+    if powershell:
+        proc = subprocess.run(
+            [powershell, "-NoProfile", "-Command",
+             f"(New-Object Media.SoundPlayer '{path}').PlaySync()"],
+            stdout=subprocess.DEVNULL, stderr=subprocess.PIPE,
+        )
+        if proc.returncode == 0:
+            return True
+        errors.append(f"powershell: exit {proc.returncode}")
+    return False
+
+
+def _play_players(path: str, errors: list[str]) -> str | None:
+    for name, args in _PLAYERS:
+        exe = shutil.which(name)
+        if not exe:
+            continue
+        proc = subprocess.run(
+            [exe, *args, path],
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.PIPE,
+        )
+        if proc.returncode == 0:
+            return name
+        errors.append(f"{name}: exit {proc.returncode}")
+    return None
+
+
+def play(wav_bytes: bytes, verbose: bool = False) -> None:
+    """Play WAV bytes; raises PlaybackError if nothing works."""
+    errors: list[str] = []
+    # delete=False + close before playing: on Windows another process cannot
+    # open a file we still hold open.
+    f = tempfile.NamedTemporaryFile(suffix=".wav", dir=_tmp_dir(), delete=False)
+    try:
+        f.write(wav_bytes)
+        f.close()
+        if sys.platform == "win32" and _play_windows(f.name, errors):
+            if verbose:
+                print("[speak] played via winsound/powershell", flush=True)
+            return
+        player = _play_players(f.name, errors)
+        if player:
+            if verbose:
+                print(f"[speak] played via {player}", flush=True)
+            return
+    finally:
+        try:
+            os.unlink(f.name)
+        except OSError:
+            pass
+    detail = "; ".join(errors) if errors else "no audio player found on PATH"
+    raise PlaybackError(
+        f"could not play audio ({detail}). "
+        "Use --out FILE to save the audio to a WAV file instead."
+    )

speak_cli-1.2.0/tests/test_ipc_paths.py

@@ -0,0 +1,87 @@
+import sys
+
+import pytest
+
+from speak_cli import __version__, ipc
+
+posix_only = pytest.mark.skipif(sys.platform == "win32", reason="POSIX-only")
+windows_only = pytest.mark.skipif(sys.platform != "win32", reason="Windows-only")
+
+
+@posix_only
+def test_runtime_paths_created(tmp_path, monkeypatch):
+    monkeypatch.setenv("XDG_RUNTIME_DIR", str(tmp_path))
+    paths = ipc.runtime_paths()
+    assert paths.dir.is_dir()
+    assert (paths.dir.stat().st_mode & 0o777) == 0o700
+    assert paths.sock.name == f"daemon-{__version__}.sock"
+    assert paths.sock.parent == paths.dir
+    assert paths.endpoint == paths.sock
+
+
+@posix_only
+def test_runtime_paths_fallback_without_xdg(tmp_path, monkeypatch):
+    monkeypatch.delenv("XDG_RUNTIME_DIR", raising=False)
+    monkeypatch.setenv("HOME", str(tmp_path))
+    paths = ipc.runtime_paths()
+    assert str(paths.dir).startswith(str(tmp_path))
+    assert paths.dir.is_dir()
+
+
+@windows_only
+def test_runtime_paths_windows(tmp_path, monkeypatch):
+    monkeypatch.setenv("LOCALAPPDATA", str(tmp_path))
+    paths = ipc.runtime_paths()
+    assert paths.dir.is_dir()
+    assert str(paths.dir).startswith(str(tmp_path))
+    assert paths.port.name == f"daemon-{__version__}.port"
+    assert paths.endpoint == paths.port
+
+
+def test_endpoint_missing_raises_filenotfound(tmp_path):
+    endpoint = tmp_path / "daemon-0.0.0.port"
+    with pytest.raises(FileNotFoundError):
+        ipc._connect(endpoint)
+
+
+def test_stale_port_file_raises_connection_refused(tmp_path):
+    endpoint = tmp_path / "daemon-0.0.0.port"
+    endpoint.write_text("1")  # port 1: nothing listens there
+    with pytest.raises(ConnectionRefusedError):
+        ipc._connect(endpoint)
+
+
+def test_garbage_port_file_raises_filenotfound(tmp_path):
+    endpoint = tmp_path / "daemon-0.0.0.port"
+    endpoint.write_text("not-a-number")
+    with pytest.raises(FileNotFoundError):
+        ipc._connect(endpoint)
+
+
+def test_tcp_transport_round_trip(tmp_path):
+    """Exercises the Windows .port transport end-to-end (works on any OS)."""
+    import json
+    import socket
+    import threading
+
+    srv = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
+    srv.bind(("127.0.0.1", 0))
+    srv.listen(1)
+    endpoint = tmp_path / "daemon-0.0.0.port"
+    endpoint.write_text(str(srv.getsockname()[1]))
+    payload = b"RIFFfakewav" * 100
+
+    def serve():
+        conn, _ = srv.accept()
+        with conn:
+            req = json.loads(ipc.recv_line(conn))
+            assert req["cmd"] == "speak"
+            header = json.dumps({"status": "ok", "nbytes": len(payload)})
+            conn.sendall(header.encode() + b"\n" + payload)
+        srv.close()
+
+    t = threading.Thread(target=serve)
+    t.start()
+    out = ipc._request(endpoint, {"cmd": "speak", "text": "hi"})
+    t.join()
+    assert out == payload

speak_cli-1.1.2/src/speak_cli/playback.py

@@ -1,61 +0,0 @@
-"""Play WAV bytes through whatever audio player the system has.
-
-No Python audio dependency on purpose: simpleaudio is unmaintained and
-sounddevice needs a system PortAudio library. Every mainstream desktop has
-at least one of the players below; each is tried until one exits 0.
-"""
-
-from __future__ import annotations
-
-import os
-import shutil
-import subprocess
-import tempfile
-
-
-class PlaybackError(RuntimeError):
-    pass
-
-
-_PLAYERS: list[tuple[str, list[str]]] = [
-    ("paplay", []),
-    ("pw-play", []),
-    ("aplay", ["-q"]),
-    ("afplay", []),
-    ("ffplay", ["-nodisp", "-autoexit", "-loglevel", "quiet"]),
-    ("play", ["-q"]),
-]
-
-
-def _tmp_dir() -> str | None:
-    runtime = os.environ.get("XDG_RUNTIME_DIR")
-    if runtime and os.path.isdir(runtime) and os.access(runtime, os.W_OK):
-        return runtime  # tmpfs: no disk I/O
-    return None
-
-
-def play(wav_bytes: bytes, verbose: bool = False) -> None:
-    """Play WAV bytes; raises PlaybackError if no player works."""
-    errors: list[str] = []
-    with tempfile.NamedTemporaryFile(suffix=".wav", dir=_tmp_dir()) as f:
-        f.write(wav_bytes)
-        f.flush()
-        for name, args in _PLAYERS:
-            exe = shutil.which(name)
-            if not exe:
-                continue
-            proc = subprocess.run(
-                [exe, *args, f.name],
-                stdout=subprocess.DEVNULL,
-                stderr=subprocess.PIPE,
-            )
-            if proc.returncode == 0:
-                if verbose:
-                    print(f"[speak] played via {name}", flush=True)
-                return
-            errors.append(f"{name}: exit {proc.returncode}")
-    detail = "; ".join(errors) if errors else "no audio player found on PATH"
-    raise PlaybackError(
-        f"could not play audio ({detail}). "
-        "Use --out FILE to save the audio to a WAV file instead."
-    )

speak_cli-1.1.2/tests/test_ipc_paths.py

@@ -1,18 +0,0 @@
-from speak_cli import __version__, ipc
-
-
-def test_runtime_paths_created(tmp_path, monkeypatch):
-    monkeypatch.setenv("XDG_RUNTIME_DIR", str(tmp_path))
-    paths = ipc.runtime_paths()
-    assert paths.dir.is_dir()
-    assert (paths.dir.stat().st_mode & 0o777) == 0o700
-    assert paths.sock.name == f"daemon-{__version__}.sock"
-    assert paths.sock.parent == paths.dir
-
-
-def test_runtime_paths_fallback_without_xdg(tmp_path, monkeypatch):
-    monkeypatch.delenv("XDG_RUNTIME_DIR", raising=False)
-    monkeypatch.setenv("HOME", str(tmp_path))
-    paths = ipc.runtime_paths()
-    assert str(paths.dir).startswith(str(tmp_path))
-    assert paths.dir.is_dir()