python-voiceio 0.3.4__tar.gz → 0.3.6__tar.gz

{python_voiceio-0.3.4/python_voiceio.egg-info → python_voiceio-0.3.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-voiceio
-Version: 0.3.4
+Version: 0.3.6
 Summary: Speak → text, locally, instantly.
 Author: Hugo Montenegro
 License-Expression: MIT

{python_voiceio-0.3.4 → python_voiceio-0.3.6}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-voiceio"
-version = "0.3.4"
+version = "0.3.6"
 description = "Speak → text, locally, instantly."
 readme = "README.md"
 license = "MIT"

{python_voiceio-0.3.4 → python_voiceio-0.3.6/python_voiceio.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-voiceio
-Version: 0.3.4
+Version: 0.3.6
 Summary: Speak → text, locally, instantly.
 Author: Hugo Montenegro
 License-Expression: MIT

{python_voiceio-0.3.4 → python_voiceio-0.3.6}/tests/test_robustness.py

@@ -524,3 +524,191 @@ class TestTrayWatchdog:
         with patch("voiceio.app.tray") as mock_tray:
             vio._check_health()
             mock_tray.is_alive.assert_not_called()
+
+
+# ===========================================================================
+# 9. Boot-race and typer re-probe (regression tests for 0.3.6 fix)
+# ===========================================================================
+
+class TestBootRaceAndReProbe:
+    """Tests for the fix where platform.detect's lru_cache froze a stale
+    display=unknown result at boot, defeating all re-probe logic."""
+
+    def test_redetect_clears_lru_cache(self):
+        """_redetect_platform must call cache_clear so env changes take effect."""
+        from voiceio.app import _redetect_platform
+        from voiceio import platform as plat
+
+        # Warm the cache with display=unknown (simulating boot before env ready)
+        with patch.dict("os.environ", {}, clear=True):
+            plat.detect.cache_clear()
+            p1 = plat.detect()
+            assert p1.display_server == "unknown"
+
+        # Env vars appear. Plain detect() would return cached unknown;
+        # _redetect_platform must clear cache and return the fresh values.
+        with patch.dict("os.environ", {
+            "XDG_SESSION_TYPE": "wayland",
+            "WAYLAND_DISPLAY": "wayland-0",
+            "XDG_CURRENT_DESKTOP": "GNOME",
+        }):
+            p2 = _redetect_platform()
+            assert p2.display_server == "wayland"
+            assert p2.desktop == "gnome"
+
+        plat.detect.cache_clear()
+
+    def test_import_graphical_env_is_one_shot(self):
+        """After all vars are present, _import_graphical_env becomes a no-op
+        (no subprocess every health-check cycle)."""
+        from voiceio import app as app_mod
+        from voiceio.app import _import_graphical_env
+
+        app_mod._graphical_env_complete = False
+
+        with patch.dict("os.environ", {
+            "DISPLAY": ":0",
+            "WAYLAND_DISPLAY": "wayland-0",
+            "XDG_SESSION_TYPE": "wayland",
+            "XDG_CURRENT_DESKTOP": "GNOME",
+            "XDG_SESSION_DESKTOP": "gnome",
+        }):
+            with patch("voiceio.app.subprocess.check_output") as mock_sub:
+                _import_graphical_env()
+                assert app_mod._graphical_env_complete is True
+                mock_sub.assert_not_called()  # all vars present → no subprocess
+                _import_graphical_env()
+                mock_sub.assert_not_called()  # still no subprocess
+
+        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()
+        vio.platform = MagicMock(display_server="wayland", desktop="gnome")
+        vio._typer = MagicMock()
+        vio._typer.name = "clipboard"
+
+        # Make the ClipboardTyper isinstance check false (we're using MagicMock)
+        better = MagicMock()
+        better.name = "ibus"
+
+        with patch("voiceio.app.typer_chain.resolve", return_value=[
+            ("ibus", better, MagicMock(ok=True)),
+            ("clipboard", vio._typer, MagicMock(ok=True)),
+        ]), patch("voiceio.app.typer_chain.select", return_value=better), \
+             patch("voiceio.app.typer_chain._get_chain",
+                   return_value=["ibus", "clipboard"]), \
+             patch.object(vio, "_ensure_ibus_engine") as mock_ensure:
+            result = vio._try_upgrade_typer(reason="test")
+            assert result is True
+            assert vio._typer is better
+            mock_ensure.assert_called_once()
+
+    def test_try_upgrade_typer_no_upgrade_when_already_best(self):
+        """If already on the first entry in the chain, no upgrade."""
+        vio, _, _ = _make_vio()
+        vio.platform = MagicMock(display_server="wayland", desktop="gnome")
+        vio._typer = MagicMock()
+        vio._typer.name = "ibus"
+
+        with patch("voiceio.app.typer_chain._get_chain",
+                   return_value=["ibus", "clipboard"]):
+            result = vio._try_upgrade_typer(reason="test")
+            assert result is False
+
+    def test_try_upgrade_typer_no_upgrade_when_unknown_platform(self):
+        """Regression: with display=unknown the chain is ['clipboard'], and
+        upgrade should early-return False (this was silent and defeated the
+        health loop before the lru_cache fix)."""
+        vio, _, _ = _make_vio()
+        vio.platform = MagicMock(display_server="unknown", desktop="unknown")
+        vio._typer = MagicMock()
+        vio._typer.name = "clipboard"
+
+        with patch("voiceio.app.typer_chain._get_chain",
+                   return_value=["clipboard"]):
+            result = vio._try_upgrade_typer(reason="test")
+            assert result is False
+
+    def test_boot_race_healed_by_health_check(self):
+        """Simulate: __init__ ran with display=unknown and picked clipboard.
+        Later, env vars become available and health check should upgrade."""
+        from voiceio import app as app_mod
+        from voiceio import platform as plat
+
+        vio, _, _ = _make_vio()
+        # Simulate the stale state as if we started at boot
+        vio.platform = MagicMock(display_server="unknown", desktop="unknown")
+        vio._typer = MagicMock()
+        vio._typer.name = "clipboard"
+        vio.recorder.stream_health = MagicMock(return_value=(True, ""))
+        vio.transcriber.is_worker_alive = MagicMock(return_value=True)
+        vio.cfg.tray.enabled = False
+
+        # Env arrives; health check should re-import, re-detect, and upgrade.
+        better = MagicMock()
+        better.name = "ibus"
+        better.probe.return_value = MagicMock(ok=True)
+
+        # Force env import to go through; reset one-shot flag
+        app_mod._graphical_env_complete = False
+
+        fresh_platform = MagicMock(display_server="wayland", desktop="gnome")
+
+        with patch.dict("os.environ", {
+            "DISPLAY": ":0",
+            "WAYLAND_DISPLAY": "wayland-0",
+            "XDG_SESSION_TYPE": "wayland",
+            "XDG_CURRENT_DESKTOP": "GNOME",
+            "XDG_SESSION_DESKTOP": "gnome",
+        }), patch("voiceio.app._redetect_platform", return_value=fresh_platform), \
+             patch("voiceio.app.typer_chain._get_chain",
+                   return_value=["ibus", "clipboard"]), \
+             patch("voiceio.app.typer_chain.resolve", return_value=[
+                 ("ibus", better, MagicMock(ok=True)),
+             ]), patch("voiceio.app.typer_chain.select", return_value=better), \
+             patch.object(vio, "_ensure_ibus_engine"):
+            vio._check_health()
+
+        assert vio._typer is better
+        assert vio.platform is fresh_platform
+        plat.detect.cache_clear()
+        app_mod._graphical_env_complete = False
+
+    def test_on_typer_broken_defers_until_idle(self):
+        """Mid-recording, _on_typer_broken must NOT hot-swap the typer."""
+        from voiceio.app import _State
+
+        vio, _, _ = _make_vio()
+        vio._state = _State.RECORDING
+        original_typer = vio._typer
+
+        # Call the handler directly (no thread) to check it respects state.
+        # The real handler kicks off a thread; we test the internal method.
+        with patch.object(vio, "_try_upgrade_typer") as mock_upgrade:
+            # Simulate the thread having already waited: state is still RECORDING
+            # Force deadline-past by calling with state still RECORDING
+            # We invoke _deferred_typer_upgrade with a very short timeout
+            # by mocking time.monotonic and time.sleep.
+            with patch("voiceio.app.time.monotonic",
+                       side_effect=[0, 100, 100, 100]), \
+                 patch("voiceio.app.time.sleep"):
+                vio._deferred_typer_upgrade()
+            mock_upgrade.assert_not_called()
+        assert vio._typer is original_typer
+
+    def test_on_typer_broken_runs_when_idle(self):
+        """Once IDLE is reached, the deferred upgrade runs."""
+        from voiceio.app import _State
+
+        vio, _, _ = _make_vio()
+        vio._state = _State.IDLE
+
+        with patch.object(vio, "_try_upgrade_typer") as mock_upgrade, \
+             patch("voiceio.app._import_graphical_env"), \
+             patch("voiceio.app._redetect_platform",
+                   return_value=vio.platform), \
+             patch("voiceio.app.time.sleep"):
+            vio._deferred_typer_upgrade()
+            mock_upgrade.assert_called_once_with(reason="streaming-failure")

python_voiceio-0.3.6/voiceio/__init__.py

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

{python_voiceio-0.3.4 → python_voiceio-0.3.6}/voiceio/app.py

@@ -29,6 +29,66 @@ if TYPE_CHECKING:
 log = logging.getLogger("voiceio")
 _DEBOUNCE_SECS = 0.3
 
+# Env vars needed for clipboard/tray/typing on graphical sessions.
+# XDG_CURRENT_DESKTOP is required for is_gnome() detection, which gates
+# IBus input source configuration.
+_GRAPHICAL_ENV_VARS = (
+    "DISPLAY",
+    "WAYLAND_DISPLAY",
+    "XDG_SESSION_TYPE",
+    "XDG_CURRENT_DESKTOP",
+    "XDG_SESSION_DESKTOP",
+)
+
+
+def _redetect_platform():
+    """Clear the cached Platform and re-run detection.
+
+    plat.detect() is @lru_cache'd, so the first call freezes the result.
+    When voiceio starts before the desktop session has exported its env
+    vars, that first call returns display='unknown' and we'd be stuck
+    with that forever. Always clear the cache before re-detecting.
+    """
+    plat.detect.cache_clear()
+    return plat.detect()
+
+
+_graphical_env_complete = False
+
+
+def _import_graphical_env() -> None:
+    """Pull graphical session env vars from the systemd user manager.
+
+    When started as a systemd user service, the process may launch before
+    the desktop session imports DISPLAY/WAYLAND_DISPLAY. This queries
+    ``systemctl --user show-environment`` to pick them up after the fact.
+
+    Once all expected vars are present, sets ``_graphical_env_complete``
+    and becomes a free no-op so callers in the health loop don't spawn
+    a subprocess every 10s.
+    """
+    global _graphical_env_complete
+    if _graphical_env_complete:
+        return
+    missing = [v for v in _GRAPHICAL_ENV_VARS if v not in os.environ]
+    if not missing:
+        _graphical_env_complete = True
+        return
+    try:
+        out = subprocess.check_output(
+            ["systemctl", "--user", "show-environment"],
+            text=True, timeout=3,
+        )
+    except (FileNotFoundError, subprocess.SubprocessError):
+        return
+    for line in out.splitlines():
+        key, _, val = line.partition("=")
+        if key in missing and val:
+            os.environ[key] = val
+            log.info("Imported %s=%s from systemd user env", key, val)
+    if not [v for v in _GRAPHICAL_ENV_VARS if v not in os.environ]:
+        _graphical_env_complete = True
+
 
 _HEALTH_CHECK_INTERVAL = 10  # seconds between health checks
 
@@ -43,7 +103,19 @@ class _State(enum.Enum):
 class VoiceIO:
     def __init__(self, cfg: config.Config):
         self.cfg = cfg
-        self.platform = plat.detect()
+
+        # Import graphical env vars early so typer/platform detection
+        # sees DISPLAY, WAYLAND_DISPLAY, XDG_SESSION_TYPE, XDG_CURRENT_DESKTOP
+        # even when started as a systemd user service before the desktop
+        # session has exported them.
+        _import_graphical_env()
+
+        # Fresh detection (clears lru_cache in case anything warmed it)
+        self.platform = _redetect_platform()
+        log.info(
+            "Platform: display=%s desktop=%s",
+            self.platform.display_server, self.platform.desktop,
+        )
 
         # Select backends
         self._hotkey = hotkey_chain.select(self.platform, cfg.hotkey.backend)
@@ -208,6 +280,7 @@ class VoiceIO:
                 commands=self._command_processor,
                 corrections=self._corrections,
                 llm=self._llm,
+                on_typer_broken=self._on_typer_broken,
             )
             self._session.start()
         log.info("Recording... press [%s] again to stop", self.cfg.hotkey.key)
@@ -395,6 +468,108 @@ class VoiceIO:
             except RuntimeError:
                 log.error("No working typer backend available")
 
+    def _on_typer_broken(self) -> None:
+        """Called by streaming session when typer fails repeatedly.
+
+        Defers the re-probe+upgrade to a background thread that waits
+        for the state to reach IDLE. We cannot hot-swap mid-recording:
+        the streaming session tracks ``_typed_text`` in terms of the old
+        typer's behavior (char-level for clipboard vs preedit for ibus),
+        and mid-stream swapping would leave stale or duplicated chars.
+        The current recording is already broken — accept that, fix it
+        before the next one.
+        """
+        threading.Thread(
+            target=self._deferred_typer_upgrade,
+            daemon=True, name="typer-upgrade",
+        ).start()
+
+    def _deferred_typer_upgrade(self) -> None:
+        """Wait for IDLE state, then re-detect platform and upgrade typer."""
+        # Wait up to 30s for recording/finalizing to complete
+        deadline = time.monotonic() + 30
+        while time.monotonic() < deadline:
+            if self._state == _State.IDLE or self._shutdown.is_set():
+                break
+            time.sleep(0.5)
+        if self._shutdown.is_set():
+            return
+        with self._hotkey_lock:
+            if self._state != _State.IDLE:
+                log.debug("Typer upgrade abandoned: state=%s after 30s", self._state)
+                return
+            _import_graphical_env()
+            self.platform = _redetect_platform()
+            log.info(
+                "Typer broken: re-detected platform: display=%s desktop=%s",
+                self.platform.display_server, self.platform.desktop,
+            )
+            self._try_upgrade_typer(reason="streaming-failure")
+
+    def _try_upgrade_typer(self, reason: str = "") -> bool:
+        """Try to switch to a better typer backend.
+
+        Called on resume, after env import, or after repeated typer failures.
+        If the current typer is a fallback (e.g. clipboard) and a preferred
+        backend (e.g. ibus) is now available, switch to it.
+
+        Returns True if typer was upgraded.
+        """
+        chain = typer_chain._get_chain(self.platform)
+        current_idx = chain.index(self._typer.name) if self._typer.name in chain else len(chain)
+        log.debug(
+            "Upgrade attempt (%s): current=%s (idx %d) chain=%s",
+            reason, self._typer.name, current_idx, chain,
+        )
+        if current_idx == 0:
+            log.debug("Upgrade (%s) skipped: already on best backend in chain", reason)
+            return False  # already on the best backend
+
+        # Reset clipboard tool cache so re-probe sees updated env
+        from voiceio.typers.clipboard import ClipboardTyper
+        if isinstance(self._typer, ClipboardTyper):
+            self._typer.reset_tools()
+
+        # Log all probe results so we can diagnose why upgrade failed
+        try:
+            results = typer_chain.resolve(self.platform, self.cfg.output.method)
+        except Exception:
+            log.exception("Upgrade (%s): typer resolve failed", reason)
+            return False
+        for name, _backend, probe in results:
+            status = "OK" if probe.ok else f"FAIL: {probe.reason}"
+            log.info("Upgrade (%s): probe %s -> %s", reason, name, status)
+
+        try:
+            new_typer = typer_chain.select(self.platform, self.cfg.output.method)
+        except RuntimeError as e:
+            log.warning("Upgrade (%s) select failed: %s", reason, e)
+            return False
+
+        new_idx = chain.index(new_typer.name) if new_typer.name in chain else len(chain)
+        if new_idx < current_idx:
+            old_name = self._typer.name
+            self._typer = new_typer
+            log.info("Typer upgraded: %s -> %s (%s)", old_name, new_typer.name, reason)
+            if new_typer.name == "ibus" and self._engine_proc is None:
+                try:
+                    self._ensure_ibus_engine()
+                except Exception:
+                    log.exception("Upgrade (%s): failed to start IBus engine", reason)
+            return True
+
+        log.info(
+            "Upgrade (%s): no better backend available (stayed on %s)",
+            reason, new_typer.name,
+        )
+        # Even if same backend, re-resolve tools (e.g. clipboard switching
+        # from xclip to wl-copy after env vars change)
+        if isinstance(self._typer, ClipboardTyper):
+            self._typer._resolve_tools()
+            log.debug("Clipboard typer tools re-resolved (%s)", reason)
+
+        return False
+
     # ── IBus engine lifecycle ───────────────────────────────────────────
 
     def _ensure_ibus_engine(self) -> None:
@@ -473,6 +648,34 @@ class VoiceIO:
         self._set_gnome_input_source_index(0)
         log.info("VoiceIO IBus engine ready (dormant until recording)")
 
+    def _reactivate_ibus_if_stale(self) -> None:
+        """Re-activate IBus engine if it lost registration (e.g. after hibernate).
+
+        After suspend/hibernate, the IBus daemon may forget about our engine.
+        Check by querying the current active engine; if it's not 'voiceio',
+        re-run ``ibus engine voiceio`` to re-register.
+        """
+        from voiceio.typers.ibus import _ibus_env
+        try:
+            result = subprocess.run(
+                ["ibus", "engine"], capture_output=True, text=True,
+                timeout=3, env=_ibus_env(),
+            )
+            current = result.stdout.strip() if result.returncode == 0 else ""
+        except (FileNotFoundError, subprocess.TimeoutExpired):
+            return
+        if current == "voiceio":
+            return  # still registered, nothing to do
+        log.warning("IBus engine stale (current=%r), re-activating", current)
+        try:
+            subprocess.run(
+                ["ibus", "engine", "voiceio"],
+                capture_output=True, timeout=5, env=_ibus_env(),
+            )
+            log.info("IBus engine re-activated")
+        except (FileNotFoundError, subprocess.TimeoutExpired) as e:
+            log.warning("IBus re-activation failed: %s", e)
+
     def _wait_for_ibus(self, chain: list[str]) -> TyperBackend | None:
         """Wait for IBus daemon to become available and switch to IBus typer.
 
@@ -584,17 +787,79 @@ class VoiceIO:
 
     # ── Health watchdog ─────────────────────────────────────────────
 
+    # If the gap between health checks exceeds this, we probably resumed
+    # from suspend/hibernate and should re-probe everything.
+    _RESUME_THRESHOLD = 30  # seconds
+
     def _health_loop(self) -> None:
         """Periodic health check: transcriber worker, IBus engine, audio stream."""
+        last_check = time.monotonic()
         while not self._shutdown.is_set():
             self._shutdown.wait(_HEALTH_CHECK_INTERVAL)
             if self._shutdown.is_set():
                 break
+
+            now = time.monotonic()
+            gap = now - last_check
+            last_check = now
+
             try:
+                if gap > self._RESUME_THRESHOLD:
+                    log.info("System resume detected (%.0fs gap), re-probing all backends", gap)
+                    self._on_resume()
                 self._check_health()
             except Exception:
                 log.debug("Health check error", exc_info=True)
 
+    def _on_resume(self) -> None:
+        """Re-probe all backends after system suspend/hibernate.
+
+        Sleep/hibernate breaks connections to system services (IBus, audio,
+        tray D-Bus, ydotoold) across all platforms. Instead of catching each
+        failure individually, do a single sweep to restore everything.
+        """
+        _import_graphical_env()
+
+        # Re-detect platform now that env vars may have been refreshed
+        self.platform = _redetect_platform()
+
+        # Audio: reopen stream (device may have changed or died)
+        try:
+            self.recorder.reopen_stream()
+            log.info("Resume: audio stream reopened")
+        except Exception:
+            log.warning("Resume: audio stream reopen failed", exc_info=True)
+
+        # Typer: re-probe if on a fallback backend (e.g. clipboard instead
+        # of ibus) — the preferred backend may be available now.
+        self._try_upgrade_typer(reason="resume")
+
+        # IBus: re-activate engine registration
+        if self._typer.name == "ibus" and self._engine_proc is not None:
+            if self._engine_proc.poll() is not None:
+                # Engine process died during sleep
+                self._engine_proc = None
+                try:
+                    self._ensure_ibus_engine()
+                    log.info("Resume: IBus engine restarted")
+                except Exception:
+                    log.exception("Resume: IBus engine restart failed")
+            else:
+                self._reactivate_ibus_if_stale()
+
+        # Tray: restart if subprocess died
+        if self.cfg.tray.enabled and not tray.is_alive():
+            log.info("Resume: restarting tray")
+            tray.restart(self.on_hotkey)
+
+        # Transcriber: ensure worker is alive
+        if not self.transcriber.is_worker_alive():
+            try:
+                self.transcriber._ensure_worker()
+                log.info("Resume: transcriber worker restarted")
+            except RuntimeError:
+                log.error("Resume: transcriber worker failed")
+
     def _check_health(self) -> None:
         """Run one health check cycle."""
         # Check transcriber worker
@@ -644,7 +909,31 @@ class VoiceIO:
             log.warning("Tray subprocess died, restarting")
             tray.restart(self.on_hotkey)
 
-        # Check IBus engine (restart if died)
+        # Check typer: if on a fallback, try to upgrade to preferred backend.
+        # Refresh env + platform first in case we started before the desktop
+        # session had exported DISPLAY/WAYLAND_DISPLAY/XDG_CURRENT_DESKTOP.
+        _import_graphical_env()
+        old_desktop = self.platform.desktop
+        self.platform = _redetect_platform()
+        if self.platform.desktop != old_desktop:
+            log.info(
+                "Platform refreshed: display=%s desktop=%s (was desktop=%s)",
+                self.platform.display_server, self.platform.desktop, old_desktop,
+            )
+        chain = typer_chain._get_chain(self.platform)
+        current_idx = chain.index(self._typer.name) if self._typer.name in chain else len(chain)
+        if current_idx > 0:
+            self._try_upgrade_typer(reason="health-check")
+
+        # Check typer: re-probe if current backend is broken
+        probe = self._typer.probe()
+        if not probe.ok:
+            log.warning("Typer '%s' probe failed: %s — re-selecting", self._typer.name, probe.reason)
+            _import_graphical_env()
+            self.platform = _redetect_platform()
+            self._try_upgrade_typer(reason="probe-failed")
+
+        # Check IBus engine (restart if died, re-activate if stale after resume)
         if self._typer.name == "ibus" and self._engine_proc is not None:
             if self._engine_proc.poll() is not None:
                 log.warning("IBus engine process died (rc=%d), restarting",
@@ -655,12 +944,30 @@ class VoiceIO:
                     log.info("IBus engine recovered")
                 except Exception:
                     log.exception("IBus engine recovery failed")
+            elif self._state == _State.IDLE:
+                # Engine alive but may have lost IBus registration after
+                # hibernate/suspend. Re-activate so preedit works next time.
+                self._reactivate_ibus_if_stale()
 
     # ── Main loop ───────────────────────────────────────────────────────
 
     def run(self) -> None:
         from voiceio.config import PID_PATH, LOG_DIR
 
+        # Refresh env and platform in case the desktop session exported
+        # vars between __init__ and run() (e.g. boot race with user@.service).
+        _import_graphical_env()
+        old_platform = self.platform
+        self.platform = _redetect_platform()
+        if (self.platform.display_server != old_platform.display_server
+                or self.platform.desktop != old_platform.desktop):
+            log.info(
+                "Platform changed since init: display=%s desktop=%s (was %s/%s), re-selecting typer",
+                self.platform.display_server, self.platform.desktop,
+                old_platform.display_server, old_platform.desktop,
+            )
+            self._try_upgrade_typer(reason="run-init")
+
         LOG_DIR.mkdir(parents=True, exist_ok=True)
         self._pid_fd = open(PID_PATH, "w")
         try:
@@ -679,7 +986,9 @@ class VoiceIO:
         else:
             # IBus daemon may not be ready at startup (race with graphical
             # session). If IBus is in the preferred chain but wasn't selected,
-            # wait briefly and re-probe.
+            # wait briefly and re-probe. Re-fetch the chain after env refresh
+            # above so we don't use a stale "clipboard-only" chain from when
+            # platform=unknown.
             chain = typer_chain._get_chain(self.platform)
             if "ibus" in chain and self._typer.name != "ibus":
                 self._typer = self._wait_for_ibus(chain) or self._typer

{python_voiceio-0.3.4 → python_voiceio-0.3.6}/voiceio/service.py

@@ -264,25 +264,38 @@ def install_symlinks() -> list[str]:
 
 
 def _add_local_bin_to_path() -> None:
-    """Add ~/.local/bin to PATH via shell profile (for macOS etc.)."""
+    """Add ~/.local/bin to PATH in the user's active shell rc file."""
     global _PATH_HINT_ADDED
     line = '\nexport PATH="$HOME/.local/bin:$PATH"\n'
-    # Try .zshrc first (macOS default), then .bashrc
-    for rc_name in (".zshrc", ".bashrc", ".profile"):
+
+    # Detect the user's actual shell and target its rc file.
+    # .profile is sourced by login shells only — interactive terminals
+    # (especially zsh on Ubuntu) may never read it.
+    shell = os.environ.get("SHELL", "")
+    if "zsh" in shell:
+        targets = [".zshrc", ".profile"]
+    elif "bash" in shell:
+        targets = [".bashrc", ".profile"]
+    else:
+        targets = [".zshrc", ".bashrc", ".profile"]
+
+    for rc_name in targets:
         rc = Path.home() / rc_name
         if rc.exists():
             content = rc.read_text()
             if ".local/bin" in content:
-                return  # already there
+                continue  # already in this file, check next
             rc.write_text(content + line)
             log.info("Added ~/.local/bin to PATH in %s", rc)
             _PATH_HINT_ADDED = True
             return
-    # No shell rc found, create .profile
-    rc = Path.home() / ".profile"
+
+    # No existing rc found — create the shell-appropriate one
+    rc = Path.home() / (targets[0] if targets else ".profile")
     rc.write_text(line)
     log.info("Created %s with PATH entry", rc)
     _PATH_HINT_ADDED = True
+    _PATH_HINT_ADDED = True
 
 
 def symlinks_installed() -> bool:

{python_voiceio-0.3.4 → python_voiceio-0.3.6}/voiceio/streaming.py

@@ -3,9 +3,10 @@ from __future__ import annotations
 
 import logging
 import re
+import subprocess
 import threading
 import time
-from typing import TYPE_CHECKING
+from typing import TYPE_CHECKING, Callable
 
 from voiceio.transcriber import TRANSCRIBE_TIMEOUT
 from voiceio.typers.base import StreamingTyper
@@ -48,6 +49,9 @@ def _word_match_len(old_words: list[str], new_words: list[str]) -> int:
     return count
 
 
+_TYPER_FAIL_THRESHOLD = 3  # consecutive failures before signalling re-probe
+
+
 class StreamingSession:
     """Manages one streaming transcription cycle.
 
@@ -75,6 +79,7 @@ class StreamingSession:
         commands: CommandProcessor | None = None,
         corrections: CorrectionDict | None = None,
         llm: LLMProcessor | None = None,
+        on_typer_broken: Callable[[], None] | None = None,
     ):
         self._transcriber = transcriber
         self._typer = typer
@@ -87,6 +92,9 @@ class StreamingSession:
         self._commands = commands
         self._corrections = corrections
         self._llm = llm
+        self._on_typer_broken = on_typer_broken
+        self._typer_fail_count = 0
+        self._typer_broken_signalled = False
         self._typed_text = ""
         self._pending = threading.Event()
         self._stop_event = threading.Event()
@@ -137,6 +145,20 @@ class StreamingSession:
                 break
             try:
                 self._transcribe_and_apply()
+            except subprocess.CalledProcessError:
+                self._typer_fail_count += 1
+                if (self._typer_fail_count >= _TYPER_FAIL_THRESHOLD
+                        and not self._typer_broken_signalled):
+                    self._typer_broken_signalled = True
+                    log.warning(
+                        "Typer '%s' failed %d times in streaming, requesting re-probe",
+                        self._typer.name, self._typer_fail_count,
+                    )
+                    if self._on_typer_broken:
+                        self._on_typer_broken()
+                elif self._typer_fail_count < _TYPER_FAIL_THRESHOLD:
+                    log.exception("Streaming typer error (%d/%d)",
+                                  self._typer_fail_count, _TYPER_FAIL_THRESHOLD)
             except Exception:
                 log.exception("Streaming transcribe/apply error (non-fatal)")
 

{python_voiceio-0.3.4 → python_voiceio-0.3.6}/voiceio/typers/clipboard.py

@@ -65,6 +65,13 @@ class ClipboardTyper:
             self._pynput_kb = Controller()
         return self._pynput_kb
 
+    def reset_tools(self) -> None:
+        """Clear cached tool resolution so next probe re-detects."""
+        self._copy_cmd = None
+        self._paste_tool = None
+        self._delete_tool = None
+        self._tools_resolved = False
+
     def probe(self) -> ProbeResult:
         self._resolve_tools()
         if self._copy_cmd is None or (

{python_voiceio-0.3.4 → python_voiceio-0.3.6}/voiceio/typers/ibus.py

@@ -384,10 +384,22 @@ class IBusTyper:
         except (OSError, socket.timeout):
             return True  # assume focused on error (safe default: no extra paste)
 
+    @staticmethod
+    def _ydotoold_running() -> bool:
+        """Check if ydotoold daemon is running (required for reliable ydotool)."""
+        try:
+            result = subprocess.run(
+                ["pgrep", "-x", "ydotoold"],
+                capture_output=True, timeout=2,
+            )
+            return result.returncode == 0
+        except (FileNotFoundError, subprocess.TimeoutExpired):
+            return False
+
     def _simulate_paste(self) -> None:
         """Simulate Ctrl+V to paste clipboard into non-IBus apps (terminals)."""
         try:
-            if self._ydotool:
+            if self._ydotool and self._ydotoold_running():
                 # ydotool key scancodes: 29=LCtrl, 47=V
                 subprocess.run(
                     [self._ydotool, "key", "29:1", "47:1", "47:0", "29:0"],
@@ -399,7 +411,7 @@ class IBusTyper:
                     capture_output=True, timeout=3,
                 )
             else:
-                log.debug("No paste tool available (ydotool/wtype)")
+                log.debug("No paste tool available (ydotoold not running, wtype not found)")
         except (subprocess.TimeoutExpired, OSError) as e:
             log.debug("Paste simulation failed: %s", e)
 

python_voiceio-0.3.4/voiceio/__init__.py

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