python-voiceio 0.3.5__tar.gz → 0.3.7__tar.gz

{python_voiceio-0.3.5/python_voiceio.egg-info → python_voiceio-0.3.7}/PKG-INFO

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

{python_voiceio-0.3.5 → python_voiceio-0.3.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "python-voiceio"
-version = "0.3.5"
+version = "0.3.7"
 description = "Speak → text, locally, instantly."
 readme = "README.md"
 license = "MIT"
@@ -50,7 +50,7 @@ Issues = "https://github.com/Hugo0/voiceio/issues"
 Changelog = "https://github.com/Hugo0/voiceio/releases"
 
 [project.scripts]
-voiceio = "voiceio.cli:main"
+voiceio = "voiceio.cli:_entry_point"
 # Legacy aliases (prefer: voiceio toggle/doctor/setup/test)
 voiceio-toggle = "voiceio.cli:_cmd_toggle"
 voiceio-doctor = "voiceio.cli:_cmd_doctor_legacy"

{python_voiceio-0.3.5 → python_voiceio-0.3.7/python_voiceio.egg-info}/PKG-INFO

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

{python_voiceio-0.3.5 → python_voiceio-0.3.7}/python_voiceio.egg-info/entry_points.txt

@@ -1,5 +1,5 @@
 [console_scripts]
-voiceio = voiceio.cli:main
+voiceio = voiceio.cli:_entry_point
 voiceio-doctor = voiceio.cli:_cmd_doctor_legacy
 voiceio-setup = voiceio.cli:_cmd_setup
 voiceio-test = voiceio.cli:_cmd_test

{python_voiceio-0.3.5 → python_voiceio-0.3.7}/tests/test_robustness.py

@@ -1,11 +1,13 @@
 """Tests for robustness features: stream health, tray watchdog, audio backoff."""
 from __future__ import annotations
 
+import sys
 import threading
 import time
 from unittest.mock import MagicMock, patch
 
 import numpy as np
+import pytest
 from voiceio.config import Config
 
 
@@ -524,3 +526,199 @@ 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)
+# ===========================================================================
+
+_linux_only = pytest.mark.skipif(
+    not sys.platform.startswith("linux"),
+    reason="Boot-race scenario is Linux-specific "
+           "(macOS/Windows detect display server from sys.platform)",
+)
+
+
+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."""
+
+    @_linux_only
+    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.7/voiceio/__init__.py

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

python_voiceio-0.3.7/voiceio/__main__.py

@@ -0,0 +1,3 @@
+from voiceio.cli import _entry_point
+
+_entry_point()

{python_voiceio-0.3.5 → python_voiceio-0.3.7}/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:
@@ -643,6 +818,11 @@ class VoiceIO:
         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()
@@ -650,6 +830,10 @@ class VoiceIO:
         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:
@@ -725,6 +909,30 @@ class VoiceIO:
             log.warning("Tray subprocess died, restarting")
             tray.restart(self.on_hotkey)
 
+        # 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:
@@ -746,6 +954,20 @@ class VoiceIO:
     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:
@@ -764,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.5 → python_voiceio-0.3.7}/voiceio/cli.py

@@ -1092,3 +1092,62 @@ def _cmd_doctor_legacy() -> None:
     parser = argparse.ArgumentParser(prog="voiceio-doctor")
     parser.add_argument("--fix", action="store_true", help="Attempt to auto-fix issues")
     _cmd_doctor(parser.parse_args())
+
+
+def _entry_point() -> None:
+    """PyInstaller entry point.
+
+    On Linux/macOS the console_scripts wrapper that setuptools generates
+    from ``project.scripts`` calls ``main()`` directly, so module-level
+    code here never runs. On Windows we ship a PyInstaller bundle that
+    runs ``cli.py`` as ``__main__`` — without this wrapper, the exe would
+    load all definitions and exit silently (which is exactly what users
+    reported: "installed, clicked, nothing happened").
+
+    This wrapper also catches any unhandled exception and writes it to
+    ``crash.log`` before exiting, so a crash before logging is configured
+    still leaves a diagnostic trail. On Windows consoles we pause so the
+    cmd.exe window stays open long enough to read the error.
+    """
+    try:
+        main()
+    except SystemExit:
+        raise
+    except BaseException:
+        import traceback
+        tb = traceback.format_exc()
+        # Best-effort crash log: write to the standard log dir, and also
+        # stderr. Use a fresh import path in case config import itself
+        # was the thing that crashed.
+        try:
+            import os
+            from pathlib import Path
+            if sys.platform == "win32":
+                log_dir = Path(os.environ.get("LOCALAPPDATA", Path.home())) / "voiceio" / "logs"
+            else:
+                log_dir = Path.home() / ".local" / "state" / "voiceio"
+            log_dir.mkdir(parents=True, exist_ok=True)
+            crash_path = log_dir / "crash.log"
+            with open(crash_path, "a", encoding="utf-8") as f:
+                import datetime
+                f.write(f"\n===== {datetime.datetime.now().isoformat()} =====\n")
+                f.write(f"argv: {sys.argv}\n")
+                f.write(f"platform: {sys.platform}\n")
+                f.write(tb)
+            print(f"\n[voiceio crashed — wrote traceback to {crash_path}]",
+                  file=sys.stderr)
+        except Exception:
+            pass  # absolute last-resort: nothing we can do
+        print(tb, file=sys.stderr)
+        # On Windows, keep the console window open so the user can read
+        # the error instead of watching cmd.exe flash and close.
+        if sys.platform == "win32" and sys.stdin is not None and sys.stdin.isatty():
+            try:
+                input("\nPress Enter to close...")
+            except (EOFError, KeyboardInterrupt):
+                pass
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    _entry_point()

{python_voiceio-0.3.5 → python_voiceio-0.3.7}/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.5 → python_voiceio-0.3.7}/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.5 → python_voiceio-0.3.7}/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.5/voiceio/__init__.py

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

python_voiceio-0.3.5/voiceio/__main__.py

@@ -1,3 +0,0 @@
-from voiceio.cli import main
-
-main()