python-voiceio 0.8.0__tar.gz → 0.8.1__tar.gz

{python_voiceio-0.8.0/python_voiceio.egg-info → python_voiceio-0.8.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-voiceio
-Version: 0.8.0
+Version: 0.8.1
 Summary: Voice dictation for Linux. Speak → text, locally, instantly.
 Author: Hugo Montenegro
 License-Expression: MIT

{python_voiceio-0.8.0 → python_voiceio-0.8.1}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-voiceio"
-version = "0.8.0"
+version = "0.8.1"
 description = "Voice dictation for Linux. Speak → text, locally, instantly."
 readme = "README.md"
 license = "MIT"

{python_voiceio-0.8.0 → python_voiceio-0.8.1/python_voiceio.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-voiceio
-Version: 0.8.0
+Version: 0.8.1
 Summary: Voice dictation for Linux. Speak → text, locally, instantly.
 Author: Hugo Montenegro
 License-Expression: MIT

{python_voiceio-0.8.0 → python_voiceio-0.8.1}/python_voiceio.egg-info/SOURCES.txt

@@ -26,6 +26,7 @@ tests/test_health.py
 tests/test_hints.py
 tests/test_history.py
 tests/test_ibus_pending.py
+tests/test_ibus_ping.py
 tests/test_ibus_typer.py
 tests/test_llm.py
 tests/test_llm_api.py

{python_voiceio-0.8.0 → python_voiceio-0.8.1}/tests/test_app_wiring.py

@@ -274,14 +274,16 @@ class TestEngineLifecycle:
         vio._engine_proc = proc
         return vio, proc
 
-    def test_idle_engine_death_not_recovered(self):
-        """ibus-daemon reaping a dormant engine must NOT trigger the
-        activate/dormant dance (it grabbed the input source every cycle)."""
+    def test_idle_engine_death_respawns_without_activation(self):
+        """ibus-daemon reaping a dormant engine must respawn it registered
+        but NEVER activated — the activate/dormant dance grabbed the input
+        source every cycle, and leaving the engine dead let ibus-daemon
+        exec-spawn a socket-stealing duplicate on accidental activation."""
         vio, proc = self._vio_ibus(proc_poll=-15)
         with patch.object(vio, "_ensure_ibus_engine") as ensure, \
              patch.object(vio, "_health_typer_upkeep"):
             vio._check_health()
-        ensure.assert_not_called()
+        ensure.assert_called_once_with(activate=False)
         assert vio._engine_proc is None
 
     def test_mid_recording_engine_death_recovered(self):
@@ -290,7 +292,7 @@ class TestEngineLifecycle:
         vio._state = _State.RECORDING
         with patch.object(vio, "_ensure_ibus_engine") as ensure:
             vio._check_health()
-        ensure.assert_called_once()
+        ensure.assert_called_once_with()  # default activate=True
 
     def test_single_missed_ping_tolerated(self):
         """One missed ping on a loaded system is not a zombie."""
@@ -310,9 +312,28 @@ class TestEngineLifecycle:
              patch.object(vio, "_health_typer_upkeep"):
             vio._check_health()
             vio._check_health()
-        ensure.assert_called_once()
+        ensure.assert_called_once_with(activate=False)
         proc.kill.assert_called_once()
 
+    def test_dormant_spawn_never_touches_input_source(self):
+        """activate=False must not run `ibus engine voiceio` or gsettings —
+        idle spawns that claimed the source were the focus churn that wiped
+        visible preedits and stole the keyboard mid-typing."""
+        vio, _, _ = _make_vio()
+        with patch("voiceio.app.subprocess.run") as run, \
+             patch("voiceio.app.subprocess.Popen") as popen, \
+             patch.object(vio, "_kill_stale_engine"), \
+             patch("voiceio.ibus.SOCKET_PATH") as sock_path, \
+             patch("voiceio.ibus.READY_PATH"):
+            sock_path.exists.return_value = True
+            run.return_value = MagicMock(returncode=0, stdout="xkb:us::eng\n")
+            vio._spawn_ibus_engine(activate=False)
+        assert vio._engine_proc is not None  # engine process was spawned
+        run_cmds = [c[0][0] for c in run.call_args_list]
+        popen_cmds = [c[0][0] for c in popen.call_args_list if c[0]]
+        assert ["ibus", "engine", "voiceio"] not in run_cmds + popen_cmds
+        assert not any("gsettings" in cmd[0] for cmd in run_cmds + popen_cmds)
+
     def test_successful_ping_resets_counter(self):
         vio, proc = self._vio_ibus(proc_poll=None)
         vio._engine_ping_fails = 1

python_voiceio-0.8.1/tests/test_ibus_ping.py

@@ -0,0 +1,50 @@
+"""Tests for the shared engine ping used by the daemon health watchdog and
+the engine's own refuse-to-double-run guard (a duplicate engine binding the
+socket path silently starves the healthy instance)."""
+from __future__ import annotations
+
+import socket
+import threading
+
+import voiceio.ibus as ibus_mod
+
+
+def test_no_socket_returns_false(tmp_path, monkeypatch):
+    monkeypatch.setattr(ibus_mod, "SOCKET_PATH", tmp_path / "nope.sock")
+    assert ibus_mod.ping_engine(timeout=0.2) is False
+
+
+def test_healthy_peer_answers_pong(tmp_path, monkeypatch):
+    sock_path = tmp_path / "engine.sock"
+    server = socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM)
+    server.bind(str(sock_path))
+    server.settimeout(2.0)
+
+    def _serve():
+        try:
+            data, addr = server.recvfrom(64)
+            if data == b"ping" and addr:
+                server.sendto(b"pong", addr)
+        except OSError:
+            pass
+
+    t = threading.Thread(target=_serve, daemon=True)
+    t.start()
+    monkeypatch.setattr(ibus_mod, "SOCKET_PATH", sock_path)
+    try:
+        assert ibus_mod.ping_engine(timeout=1.0) is True
+    finally:
+        t.join(timeout=2.0)
+        server.close()
+
+
+def test_unresponsive_socket_returns_false(tmp_path, monkeypatch):
+    """A bound-but-silent socket (starved listener) must read as dead."""
+    sock_path = tmp_path / "engine.sock"
+    server = socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM)
+    server.bind(str(sock_path))
+    monkeypatch.setattr(ibus_mod, "SOCKET_PATH", sock_path)
+    try:
+        assert ibus_mod.ping_engine(timeout=0.2) is False
+    finally:
+        server.close()

{python_voiceio-0.8.0 → python_voiceio-0.8.1}/tests/test_robustness.py

@@ -578,6 +578,7 @@ class TestBootRaceAndReProbe:
 
         with patch.dict("os.environ", {
             "DISPLAY": ":0",
+            "XAUTHORITY": "/run/user/1000/.mutter-Xwaylandauth.TEST",
             "WAYLAND_DISPLAY": "wayland-0",
             "XDG_SESSION_TYPE": "wayland",
             "XDG_CURRENT_DESKTOP": "GNOME",
@@ -592,6 +593,34 @@ class TestBootRaceAndReProbe:
 
         app_mod._graphical_env_complete = False
 
+    def test_import_graphical_env_pulls_xauthority(self):
+        """Without the X auth cookie, xclip fails silently inside the daemon
+        and clipboard copies fall back to focus-stealing wl-copy — whose
+        focus-out discards any visible IBus preedit (the flashing preview)."""
+        import os
+
+        from voiceio import app as app_mod
+        from voiceio.app import _import_graphical_env
+
+        app_mod._graphical_env_complete = False
+        env = {
+            "DISPLAY": ":0",
+            "WAYLAND_DISPLAY": "wayland-0",
+            "XDG_SESSION_TYPE": "wayland",
+            "XDG_CURRENT_DESKTOP": "GNOME",
+            "XDG_SESSION_DESKTOP": "gnome",
+        }
+        with patch.dict("os.environ", env, clear=True):
+            with patch(
+                "voiceio.app.subprocess.check_output",
+                return_value="XAUTHORITY=/run/user/1000/.mutter-Xwaylandauth.TEST\n",
+            ):
+                _import_graphical_env()
+            assert os.environ["XAUTHORITY"] == "/run/user/1000/.mutter-Xwaylandauth.TEST"
+            assert app_mod._graphical_env_complete is True
+
+        app_mod._graphical_env_complete = False
+
     def test_try_upgrade_typer_upgrades_from_clipboard_to_ibus(self):
         """When chain has ibus first and current is clipboard, upgrade."""
         vio, _, _ = _make_vio()

python_voiceio-0.8.1/voiceio/__init__.py

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

{python_voiceio-0.8.0 → python_voiceio-0.8.1}/voiceio/app.py

@@ -34,6 +34,10 @@ _DEBOUNCE_SECS = 0.8
 # IBus input source configuration.
 _GRAPHICAL_ENV_VARS = (
     "DISPLAY",
+    # Without the X auth cookie, X11 tools (xclip via the XWayland bridge)
+    # fail silently inside the daemon and clipboard copies fall back to
+    # wl-copy — whose focus steal discards any visible IBus preedit.
+    "XAUTHORITY",
     "WAYLAND_DISPLAY",
     "XDG_SESSION_TYPE",
     "XDG_CURRENT_DESKTOP",
@@ -893,7 +897,8 @@ class VoiceIO:
                 return False
             if new_typer.name == "ibus" and self._engine_proc is None:
                 try:
-                    self._ensure_ibus_engine()  # subprocess ops, outside the lock
+                    # subprocess ops, outside the lock; IDLE → never activate
+                    self._ensure_ibus_engine(activate=False)
                 except Exception:
                     log.exception("Upgrade (%s): failed to start IBus engine", reason)
             return True
@@ -919,8 +924,12 @@ class VoiceIO:
         except Exception:
             log.exception("IBus engine respawn at record start failed")
 
-    def _ensure_ibus_engine(self) -> None:
-        """Start the VoiceIO IBus engine and activate it.
+    def _ensure_ibus_engine(self, activate: bool = True) -> None:
+        """Start the VoiceIO IBus engine, optionally pre-creating its instance.
+
+        ``activate=False`` spawns and registers the engine process without
+        ever touching the input source — the only safe mode while IDLE.
+        Claiming the source (``activate=True``) is reserved for record start.
 
         Single-flight: a concurrent spawn (health loop vs record start)
         is skipped rather than queued — two dances would fight over the
@@ -930,11 +939,11 @@ class VoiceIO:
             log.debug("IBus engine spawn already in progress, skipping")
             return
         try:
-            self._spawn_ibus_engine()
+            self._spawn_ibus_engine(activate)
         finally:
             self._engine_spawn_lock.release()
 
-    def _spawn_ibus_engine(self) -> None:
+    def _spawn_ibus_engine(self, activate: bool = True) -> None:
         from voiceio.ibus import READY_PATH, SOCKET_PATH
         from voiceio.typers.ibus import LAUNCHER_PATH, _ibus_env
 
@@ -984,6 +993,16 @@ class VoiceIO:
                 log.warning("IBus engine started but socket not found, commands may fail")
             return
 
+        if not activate:
+            # Registered-but-dormant mode (health loop, daemon start): the
+            # factory now owns the component name, so ibus-daemon won't
+            # exec-spawn a duplicate engine, and an accidental switch onto
+            # the voiceio source lands on a live pass-through engine. The
+            # engine INSTANCE is created on first activation (record start,
+            # or GNOME switching sources) — no input-source claim needed.
+            log.info("VoiceIO IBus engine ready (registered, dormant)")
+            return
+
         # Remember the source the user is on now so we can return the engine
         # to dormancy without hardcoding index 0 (which may not be the user's
         # keyboard). Phase 2 briefly activates voiceio to spawn the instance.
@@ -1025,22 +1044,12 @@ class VoiceIO:
     def _ping_ibus_engine(self) -> bool:
         """Check if the IBus engine's socket listener is alive.
 
-        Returns True if the engine responds to a ping within 1 second.
         A False result means the engine process is alive but its socket
-        listener / GLib loop is dead (zombie engine).
+        listener is dead or starved (zombie engine) — e.g. a duplicate
+        engine process stole the socket path.
         """
-        import socket as _socket
-        from voiceio.ibus import SOCKET_PATH
-        try:
-            sock = _socket.socket(_socket.AF_UNIX, _socket.SOCK_DGRAM)
-            sock.settimeout(2.0)
-            sock.bind("")
-            sock.sendto(b"ping", str(SOCKET_PATH))
-            data, _ = sock.recvfrom(64)
-            sock.close()
-            return data == b"pong"
-        except (OSError, _socket.timeout):
-            return False
+        from voiceio.ibus import ping_engine
+        return ping_engine(timeout=2.0)
 
     def _detect_input_source_hijack(self) -> None:
         """If the user switched input source away from voiceio mid-recording,
@@ -1084,7 +1093,7 @@ class VoiceIO:
                 try:
                     typer = typer_chain.select(self.platform, self.cfg.output.method)
                     if typer.name == "ibus":
-                        self._ensure_ibus_engine()
+                        self._ensure_ibus_engine(activate=False)
                         return typer
                 except RuntimeError:
                     pass
@@ -1388,20 +1397,30 @@ class VoiceIO:
 
         # Check IBus engine liveness. A dormant engine dying is NORMAL:
         # ibus-daemon reaps deactivated engine processes (SIGTERM ~10s after
-        # the input source switches away). Eagerly respawning here created a
-        # spawn→activate→dormant→reap loop that grabbed the user's input
-        # source every cycle — the focus churn wiped any visible preedit
-        # (flickering underline). Respawn lazily at the next record start.
+        # the input source switches away). Respawn it REGISTERED BUT NEVER
+        # ACTIVATED (activate=False): while our factory owns the component
+        # name, ibus-daemon won't exec-spawn a duplicate engine (a duplicate
+        # rebinds the command socket and silently starves the healthy one),
+        # and an accidental switch onto the voiceio source (Super+Space,
+        # GNOME's per-window source memory) lands on a live pass-through
+        # engine instead of a seconds-long cold spawn that eats keystrokes.
+        # Activation — claiming the input source — happens ONLY at record
+        # start: idle activation was the focus churn that wiped visible
+        # preedits and stole the source mid-typing.
         if self._typer.name == "ibus" and self._engine_proc is not None:
             if self._engine_proc.poll() is not None:
                 rc = self._engine_proc.returncode
                 self._engine_proc = None
                 self._engine_ping_fails = 0
                 if self._state == _State.IDLE:
-                    log.debug(
-                        "IBus engine exited while dormant (rc=%s) — normal "
-                        "reaping, will respawn at next recording", rc,
+                    log.info(
+                        "IBus engine exited while dormant (rc=%s) — "
+                        "respawning registered, without activation", rc,
                     )
+                    try:
+                        self._ensure_ibus_engine(activate=False)
+                    except Exception:
+                        log.exception("IBus engine respawn failed")
                 else:
                     log.warning("IBus engine died mid-recording (rc=%s), restarting", rc)
                     try:
@@ -1412,9 +1431,9 @@ class VoiceIO:
             elif self._state == _State.IDLE:
                 # Engine process alive — check if its socket listener is
                 # actually responding. A zombie engine (process alive but
-                # GLib loop stuck / socket thread dead) silently drops all
-                # preedit and commit messages. One missed ping on a loaded
-                # system is not a zombie — require two consecutive misses.
+                # socket stolen by a duplicate / listener dead) silently
+                # drops all preedit and commit messages. One missed ping on
+                # a loaded system is not a zombie — require two consecutive.
                 if not self._ping_ibus_engine():
                     self._engine_ping_fails += 1
                     if self._engine_ping_fails < 2:
@@ -1432,7 +1451,7 @@ class VoiceIO:
                         pass
                     self._engine_proc = None
                     try:
-                        self._ensure_ibus_engine()
+                        self._ensure_ibus_engine(activate=False)
                         log.info("IBus engine recovered (was zombie)")
                     except Exception:
                         log.exception("IBus engine recovery failed")
@@ -1510,7 +1529,9 @@ class VoiceIO:
                     self._typer.ensure_installed()
             except Exception:
                 log.exception("IBus ensure_installed failed (continuing)")
-            self._ensure_ibus_engine()
+            # Register the engine but never claim the input source at boot —
+            # the instance is created on first activation (record start).
+            self._ensure_ibus_engine(activate=False)
         else:
             # IBus daemon may not be ready at startup (race with graphical
             # session). If IBus is in the preferred chain but wasn't selected,

python_voiceio-0.8.1/voiceio/ibus/__init__.py

@@ -0,0 +1,33 @@
+"""IBus input method engine for VoiceIO."""
+from __future__ import annotations
+
+import os
+from pathlib import Path
+
+SOCKET_PATH = Path(os.environ.get("XDG_RUNTIME_DIR", "/tmp")) / "voiceio-ibus.sock"
+READY_PATH = Path(os.environ.get("XDG_RUNTIME_DIR", "/tmp")) / "voiceio-ibus.ready"
+
+
+def ping_engine(timeout: float = 2.0) -> bool:
+    """True if a live engine answers a ping on SOCKET_PATH.
+
+    Used by the daemon's health watchdog, and by the engine itself at
+    startup to refuse to double-run: a second engine binding the socket
+    path would silently starve the healthy instance (its listener stays
+    blocked on a socket inode that no longer receives anything).
+    """
+    import socket
+
+    if not SOCKET_PATH.exists():
+        return False
+    sock = socket.socket(socket.AF_UNIX, socket.SOCK_DGRAM)
+    try:
+        sock.settimeout(timeout)
+        sock.bind("")  # Linux autobind: gives us an address for the reply
+        sock.sendto(b"ping", str(SOCKET_PATH))
+        data, _ = sock.recvfrom(64)
+        return data == b"pong"
+    except OSError:
+        return False
+    finally:
+        sock.close()

{python_voiceio-0.8.0 → python_voiceio-0.8.1}/voiceio/ibus/engine.py

@@ -24,7 +24,7 @@ import gi
 gi.require_version("IBus", "1.0")
 from gi.repository import GLib, GObject, IBus
 
-from voiceio.ibus import READY_PATH, SOCKET_PATH
+from voiceio.ibus import READY_PATH, SOCKET_PATH, ping_engine
 from voiceio.ibus.pending import PendingBuffer
 
 log = logging.getLogger(__name__)
@@ -146,6 +146,7 @@ def _socket_listener(mainloop: GLib.MainLoop) -> None:
         except socket.timeout:
             continue
         except OSError:
+            log.exception("Socket listener error — listener exiting")
             break
 
         msg = data.decode("utf-8", errors="replace")
@@ -229,6 +230,15 @@ def main() -> None:
         ],
     )
 
+    # Refuse to double-run. ibus-daemon can exec-spawn its own copy of this
+    # engine (component XML) when something activates the voiceio source —
+    # e.g. GNOME's per-window source memory. Binding SOCKET_PATH here would
+    # steal it from the healthy daemon-spawned engine and silently starve it
+    # (alive, but never sees another command or ping → zombie recovery).
+    if ping_engine(timeout=0.5):
+        log.info("Healthy VoiceIO engine already serving %s — exiting duplicate", SOCKET_PATH)
+        return
+
     IBus.init()
     bus = IBus.Bus()
 

{python_voiceio-0.8.0 → python_voiceio-0.8.1}/voiceio/tray/_indicator.py

@@ -49,15 +49,7 @@ def main() -> None:
         gi.require_version("AppIndicator3", "0.1")
         from gi.repository import AppIndicator3
 
-    from gi.repository import GLib, Gtk
-
-    indicator = AppIndicator3.Indicator.new_with_path(
-        "voiceio",
-        idle_icon_names[0],
-        AppIndicator3.IndicatorCategory.APPLICATION_STATUS,
-        args.theme_dir,
-    )
-    indicator.set_status(AppIndicator3.IndicatorStatus.ACTIVE)
+    from gi.repository import Gio, GLib, Gtk
 
     recording = [False]
 
@@ -105,8 +97,6 @@ def main() -> None:
     menu.append(quit_item)
 
     menu.show_all()
-    indicator.set_menu(menu)
-    indicator.set_secondary_activate_target(toggle_item)
 
     # Animation state
     anim_frame = [0]
@@ -114,10 +104,36 @@ def main() -> None:
     anim_icons = [rec_icon_names]  # current icon set for animation
     anim_interval = [args.interval]
 
+    indicator = [None]
+    ind_serial = [0]
+
+    def _make_indicator() -> None:
+        """(Re)create the AppIndicator and register it with the watcher.
+
+        A fresh id per rebuild gives a fresh D-Bus object path, so a
+        rebuilt indicator never collides with the half-dead export of
+        the previous one.
+        """
+        old = indicator[0]
+        if old is not None:
+            old.set_status(AppIndicator3.IndicatorStatus.PASSIVE)
+        ind_serial[0] += 1
+        ind_id = "voiceio" if ind_serial[0] == 1 else f"voiceio-{ind_serial[0]}"
+        ind = AppIndicator3.Indicator.new_with_path(
+            ind_id,
+            anim_icons[0][anim_frame[0] % len(anim_icons[0])],
+            AppIndicator3.IndicatorCategory.APPLICATION_STATUS,
+            args.theme_dir,
+        )
+        ind.set_status(AppIndicator3.IndicatorStatus.ACTIVE)
+        ind.set_menu(menu)
+        ind.set_secondary_activate_target(toggle_item)
+        indicator[0] = ind
+
     def _animate() -> bool:
         icons = anim_icons[0]
         frame = anim_frame[0] % len(icons)
-        indicator.set_icon_full(icons[frame], "animating")
+        indicator[0].set_icon_full(icons[frame], "animating")
         anim_frame[0] = frame + 1
         return True
 
@@ -168,9 +184,44 @@ def main() -> None:
 
     signal.signal(signal.SIGTERM, lambda *_: GLib.idle_add(Gtk.main_quit))
 
+    _make_indicator()
+
     # Start with idle animation
     _start_animation(idle_icon_names, idle_interval, "Start recording")
 
+    # Registration watchdog: GNOME Shell's appindicator extension can drop
+    # items when it restarts (lock screen, extension reload) — its watcher
+    # re-seeks existing items and one D-Bus hiccup during that scan loses
+    # the icon for good while this process keeps running. Poll the watcher
+    # and rebuild the indicator if our item is gone.
+    session_bus = Gio.bus_get_sync(Gio.BusType.SESSION, None)
+
+    def _registration_ok() -> bool:
+        try:
+            reply = session_bus.call_sync(
+                "org.kde.StatusNotifierWatcher",
+                "/StatusNotifierWatcher",
+                "org.freedesktop.DBus.Properties",
+                "Get",
+                GLib.Variant("(ss)", ("org.kde.StatusNotifierWatcher",
+                                      "RegisteredStatusNotifierItems")),
+                GLib.VariantType.new("(v)"),
+                Gio.DBusCallFlags.NONE,
+                2000,
+                None,
+            )
+        except GLib.Error:
+            return True  # no watcher (extension off / shell starting) — nothing to fix
+        items = reply.unpack()[0]
+        return any("voiceio" in item for item in items)
+
+    def _check_registration() -> bool:
+        if not _registration_ok():
+            _make_indicator()
+        return True
+
+    GLib.timeout_add_seconds(60, _check_registration)
+
     reader = threading.Thread(target=_stdin_reader, daemon=True)
     reader.start()
 

python_voiceio-0.8.0/voiceio/__init__.py

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

python_voiceio-0.8.0/voiceio/ibus/__init__.py

@@ -1,8 +0,0 @@
-"""IBus input method engine for VoiceIO."""
-from __future__ import annotations
-
-import os
-from pathlib import Path
-
-SOCKET_PATH = Path(os.environ.get("XDG_RUNTIME_DIR", "/tmp")) / "voiceio-ibus.sock"
-READY_PATH = Path(os.environ.get("XDG_RUNTIME_DIR", "/tmp")) / "voiceio-ibus.ready"