python-voiceio 1.16.1__tar.gz → 1.17.1__tar.gz

{python_voiceio-1.16.1/python_voiceio.egg-info → python_voiceio-1.17.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-voiceio
-Version: 1.16.1
+Version: 1.17.1
 Summary: Voice dictation for Linux. Speak → text, locally, instantly.
 Author: Hugo Montenegro
 License-Expression: MIT
@@ -96,7 +96,7 @@ sudo apt install ./voiceio_*.deb
 voiceio setup
 ```
 
-Then press your hotkey, speak, and press it again (or hold it while you speak). `voiceio doctor` shows what works, `voiceio doctor --fix` repairs what it can, and `voiceio doctor --report` shares an anonymous install report on the [feedback board](https://voiceio.dev/#feedback) (it shows you the text and asks first). NixOS, other extras and installing from source: [docs/linux.md](docs/linux.md). Agent runbook: [INSTALL.md](INSTALL.md).
+Then press your hotkey, speak, and press it again (or hold it while you speak). `voiceio doctor` shows what works, `voiceio doctor --fix` repairs what it can, and `voiceio doctor --report` shares an anonymous install report on the [feedback board](https://voiceio.dev/#feedback) (it shows you the text and asks first). Doctor offers one when a check fails, and so does the tray's "Report a problem...". A report names the last error only by its type and `file:line`, never its message. NixOS, other extras and installing from source: [docs/linux.md](docs/linux.md). Agent runbook: [INSTALL.md](INSTALL.md).
 
 ## Make it yours
 

{python_voiceio-1.16.1 → python_voiceio-1.17.1}/README.md

@@ -43,7 +43,7 @@ sudo apt install ./voiceio_*.deb
 voiceio setup
 ```
 
-Then press your hotkey, speak, and press it again (or hold it while you speak). `voiceio doctor` shows what works, `voiceio doctor --fix` repairs what it can, and `voiceio doctor --report` shares an anonymous install report on the [feedback board](https://voiceio.dev/#feedback) (it shows you the text and asks first). NixOS, other extras and installing from source: [docs/linux.md](docs/linux.md). Agent runbook: [INSTALL.md](INSTALL.md).
+Then press your hotkey, speak, and press it again (or hold it while you speak). `voiceio doctor` shows what works, `voiceio doctor --fix` repairs what it can, and `voiceio doctor --report` shares an anonymous install report on the [feedback board](https://voiceio.dev/#feedback) (it shows you the text and asks first). Doctor offers one when a check fails, and so does the tray's "Report a problem...". A report names the last error only by its type and `file:line`, never its message. NixOS, other extras and installing from source: [docs/linux.md](docs/linux.md). Agent runbook: [INSTALL.md](INSTALL.md).
 
 ## Make it yours
 

{python_voiceio-1.16.1 → python_voiceio-1.17.1}/pyproject.toml

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

{python_voiceio-1.16.1 → python_voiceio-1.17.1/python_voiceio.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: python-voiceio
-Version: 1.16.1
+Version: 1.17.1
 Summary: Voice dictation for Linux. Speak → text, locally, instantly.
 Author: Hugo Montenegro
 License-Expression: MIT
@@ -96,7 +96,7 @@ sudo apt install ./voiceio_*.deb
 voiceio setup
 ```
 
-Then press your hotkey, speak, and press it again (or hold it while you speak). `voiceio doctor` shows what works, `voiceio doctor --fix` repairs what it can, and `voiceio doctor --report` shares an anonymous install report on the [feedback board](https://voiceio.dev/#feedback) (it shows you the text and asks first). NixOS, other extras and installing from source: [docs/linux.md](docs/linux.md). Agent runbook: [INSTALL.md](INSTALL.md).
+Then press your hotkey, speak, and press it again (or hold it while you speak). `voiceio doctor` shows what works, `voiceio doctor --fix` repairs what it can, and `voiceio doctor --report` shares an anonymous install report on the [feedback board](https://voiceio.dev/#feedback) (it shows you the text and asks first). Doctor offers one when a check fails, and so does the tray's "Report a problem...". A report names the last error only by its type and `file:line`, never its message. NixOS, other extras and installing from source: [docs/linux.md](docs/linux.md). Agent runbook: [INSTALL.md](INSTALL.md).
 
 ## Make it yours
 

{python_voiceio-1.16.1 → python_voiceio-1.17.1}/python_voiceio.egg-info/SOURCES.txt

@@ -24,6 +24,7 @@ tests/test_corrections.py
 tests/test_dead_mic.py
 tests/test_decoders.py
 tests/test_engine.py
+tests/test_errorlog.py
 tests/test_evdev_uaccess.py
 tests/test_fallback.py
 tests/test_fcitx_bridge.py
@@ -101,6 +102,7 @@ voiceio/context_terms.py
 voiceio/corrections.py
 voiceio/demo.py
 voiceio/display.py
+voiceio/errorlog.py
 voiceio/feedback.py
 voiceio/focus.py
 voiceio/health.py

python_voiceio-1.17.1/tests/test_errorlog.py

@@ -0,0 +1,136 @@
+"""The last error in a report, and the service's repeated-error nudge."""
+from __future__ import annotations
+
+import datetime as dt
+import logging
+
+from voiceio import errorlog
+
+NOW = dt.datetime(2026, 11, 5, 15, 0, 0)
+SECRET = "please wire the money to my sister on Friday"
+PKG = errorlog._PKG
+
+
+def _log(tmp_path, text):
+    path = tmp_path / "voiceio.log"
+    path.write_text(text)
+    return path
+
+
+SERVICE_LOG = f"""\
+2026-11-05 12:58:10,961 voiceio INFO Recording started
+2026-11-05 12:58:11,000 voiceio.streaming ERROR Streaming failed on: {SECRET}
+Traceback (most recent call last):
+  File "{PKG}/core/decoders/sherpa.py", line 280, in decode
+    stream = self._rec.create_stream(hotwords)
+AttributeError: 'NoneType' object has no attribute 'create_stream'
+
+The above exception was the direct cause of the following exception:
+
+Traceback (most recent call last):
+  File "{PKG}/streaming.py", line 488, in _transcribe_and_apply
+    result = self._decoder.decode(tail)
+  File "/usr/lib/python3/dist-packages/numpy/core.py", line 9, in f
+    pass
+voiceio.core.decoders.base.DecodeError: decode failed: {SECRET}
+Word
+{SECRET}
+2026-11-05 12:58:12,000 voiceio INFO voiceio stopped
+"""
+
+
+def test_last_error_names_only_type_frame_and_age(tmp_path):
+    got = errorlog.last_error(_log(tmp_path, SERVICE_LOG), tmp_path / "none", now=NOW)
+    assert got == "DecodeError at voiceio/streaming.py:488 (2 h ago)"
+
+
+def test_dictated_text_in_a_log_never_reaches_the_report(tmp_path):
+    from voiceio.health import BackendStatus, HealthReport
+    from voiceio.platform import Platform
+    from voiceio.report import build_report
+    from voiceio.config import Config
+
+    err = errorlog.last_error(_log(tmp_path, SERVICE_LOG), tmp_path / "none", now=NOW)
+    health = HealthReport(
+        platform=Platform(os="linux", display_server="wayland", desktop="gnome"),
+        hotkey_backends=[BackendStatus("evdev", True)],
+        typer_backends=[BackendStatus("ibus", True)], audio_ok=True)
+    text = build_report(health, last_error=err, cfg=Config())
+    assert "last error: DecodeError at voiceio/streaming.py:488" in text
+    for word in ("money", "sister", "Friday", "Word", "NoneType", "create_stream"):
+        assert word not in text
+
+
+def test_an_error_without_traceback_names_its_logger(tmp_path):
+    log = f"2026-11-05 14:30:00,000 voiceio.recorder ERROR mic gone: {SECRET}\n"
+    got = errorlog.last_error(_log(tmp_path, log), tmp_path / "none", now=NOW)
+    assert got == "logged by voiceio.recorder (30 min ago)"
+
+
+def test_errors_older_than_a_week_are_left_out(tmp_path):
+    old = SERVICE_LOG.replace("2026-11-05 12:58:11", "2026-10-20 12:58:11")
+    assert errorlog.last_error(_log(tmp_path, old), tmp_path / "none", now=NOW) == ""
+
+
+def test_crash_log_keeps_the_frame_not_the_argv(tmp_path):
+    crash = tmp_path / "crash.log"
+    crash.write_text(f"""
+===== 2026-11-04T14:00:00.123456 =====
+argv: ['voiceio', 'say', '{SECRET}']
+Traceback (most recent call last):
+  File "/home/someone/src/voiceio/voiceio/cli/__init__.py", line 205, in _entry_point
+    main()
+  File "/home/someone/.venv/lib/python3.13/site-packages/numpy/__init__.py", line 1, in <module>
+    x
+ImportError: cannot import {SECRET}
+""")
+    got = errorlog.last_error(tmp_path / "none", crash, now=NOW)
+    assert got == "ImportError at voiceio/cli/__init__.py:205 (1 d ago)"
+
+
+def test_the_newest_of_service_and_crash_errors_wins(tmp_path):
+    crash = tmp_path / "crash.log"
+    crash.write_text("===== 2026-11-05T14:59:00 =====\nargv: []\n"
+                     "Traceback (most recent call last):\n"
+                     f'  File "{PKG}/app.py", line 7, in run\n    x\nKeyError: 1\n')
+    got = errorlog.last_error(_log(tmp_path, SERVICE_LOG), crash, now=NOW)
+    assert got == "KeyError at voiceio/app.py:7 (1 min ago)"
+
+
+def _record(msg, *args):
+    return logging.LogRecord("voiceio.streaming", logging.ERROR, __file__, 1, msg, args, None)
+
+
+def test_the_same_error_three_times_notifies_once_a_day(tmp_path):
+    sent = []
+    h = errorlog.RepeatedErrorNotifier(tmp_path / "state.json",
+                                       notify=lambda title, body: sent.append(body))
+    for n in range(2):
+        h.emit(_record("decode failed: %s", f"words {n}"))
+    h.emit(_record("something else"))
+    assert sent == []
+    h.emit(_record("decode failed: %s", "more words"))
+    assert sent == ["Run 'voiceio doctor --report' to tell us."]
+    # A restarted daemon reads the same state: no second nudge today.
+    h2 = errorlog.RepeatedErrorNotifier(tmp_path / "state.json",
+                                        notify=lambda title, body: sent.append(body))
+    for _ in range(3):
+        h2.emit(_record("decode failed: %s", "x"))
+    assert len(sent) == 1
+
+
+def test_doctor_offers_a_report_only_after_a_failure_in_a_terminal(monkeypatch):
+    import argparse
+
+    from voiceio import report
+    from voiceio.cli.doctor import _offer_report
+
+    asked = []
+    monkeypatch.setattr(report, "_ask", lambda prompt: asked.append(prompt) or "y")
+    monkeypatch.setattr(report, "_interactive", lambda: True)
+    args = argparse.Namespace(yes=False)
+    assert not _offer_report(args, healthy=True)
+    assert not _offer_report(argparse.Namespace(yes=True), healthy=False)
+    assert _offer_report(args, healthy=False) and "Something isn't working" in asked[0]
+    monkeypatch.setattr(report, "_interactive", lambda: False)
+    assert not _offer_report(args, healthy=False)

{python_voiceio-1.16.1 → python_voiceio-1.17.1}/tests/test_security_hardening.py

@@ -85,6 +85,94 @@ def test_check_permissions_flags_loose_and_clears_after_harden(tmp_path, monkeyp
     assert config.check_permissions() == []
 
 
+@pytest.fixture
+def umask_002():
+    """The user-private-group umask of Debian/Fedora desktops: plain mkdir
+    gives 0775, which is how the reported ~/.local/state/voiceio got there."""
+    import os
+    old = os.umask(0o002)
+    try:
+        yield
+    finally:
+        os.umask(old)
+
+
+@posix_only
+def test_private_dir_creates_0700_with_missing_parents(tmp_path, umask_002):
+    (tmp_path / "home").mkdir(mode=0o755)
+    target = tmp_path / "home" / ".local" / "state" / "voiceio"
+    assert config.private_dir(target) == target
+    assert _mode(target) == 0o700
+    assert _mode(target.parent) == 0o700          # XDG: created dirs are 0700
+    assert _mode(tmp_path / "home") == 0o755      # existing parents untouched
+
+
+@posix_only
+def test_private_dir_tightens_existing_lax_dir(tmp_path):
+    d = tmp_path / "voiceio"
+    d.mkdir()
+    d.chmod(0o775)
+    config.private_dir(d)
+    assert _mode(d) == 0o700
+
+
+@posix_only
+def test_crash_log_dir_is_private(tmp_path, monkeypatch, umask_002, capsys):
+    from voiceio import cli
+    log_dir = tmp_path / "state" / "voiceio"
+    monkeypatch.setattr(config, "LOG_DIR", log_dir)
+
+    def boom():
+        raise RuntimeError("crash before logging")
+
+    monkeypatch.setattr(cli, "main", boom)
+    with pytest.raises(SystemExit):
+        cli._entry_point()
+    assert (log_dir / "crash.log").exists()
+    assert _mode(log_dir) == 0o700
+    assert _mode(log_dir.parent) == 0o700
+
+
+@posix_only
+def test_error_notifier_state_dir_is_private(tmp_path, umask_002):
+    import logging
+    from voiceio.errorlog import RepeatedErrorNotifier
+    state = tmp_path / "state" / "voiceio" / "error-notify.json"
+    handler = RepeatedErrorNotifier(state_path=state, notify=lambda *a, **k: None)
+    handler.emit(logging.LogRecord("voiceio.x", logging.ERROR, __file__, 1, "boom", (), None))
+    assert state.exists()
+    assert _mode(state.parent) == 0o700
+
+
+@posix_only
+def test_secure_write_missing_parents_are_private(tmp_path, umask_002):
+    target = tmp_path / "config" / "voiceio" / "config.toml"
+    config.secure_write(target, "x = 1\n")
+    assert _mode(target.parent) == 0o700
+    assert _mode(target.parent.parent) == 0o700
+
+
+@posix_only
+def test_label_store_dirs_are_private(tmp_path, monkeypatch, umask_002):
+    from voiceio.learn import store
+    monkeypatch.setenv("XDG_DATA_HOME", str(tmp_path / "share"))
+    store.add_label("a.wav", [], source="test")
+    assert _mode(store.learn_dir()) == 0o700
+    assert _mode(config.data_dir()) == 0o700
+
+
+@posix_only
+def test_check_permissions_flags_lax_learn_dir(tmp_path, monkeypatch):
+    monkeypatch.setenv("XDG_DATA_HOME", str(tmp_path / "share"))
+    learn = config.data_dir() / "learn"
+    learn.mkdir(parents=True)
+    learn.chmod(0o775)
+    assert learn in {p for p, _, _ in config.check_permissions()}
+    config.harden_permissions()
+    assert _mode(learn) == 0o700
+    assert learn not in {p for p, _, _ in config.check_permissions()}
+
+
 # ── udev rule (replaces sudo chmod 0666 /dev/uinput) ─────────────────────
 
 def test_uinput_udev_rule_content():

{python_voiceio-1.16.1 → python_voiceio-1.17.1}/tests/test_setup.py

@@ -280,3 +280,108 @@ def test_setup_offers_nightly_learning_once(monkeypatch):
     steps._offer_nightly_learning(state)
     steps._offer_nightly_learning(state)      # already on: not asked again
     assert installed == [1] and len(asked) == 1
+
+
+# ── root commands with no terminal (agent, launcher, GUI) ────────────
+
+def _no_terminal(monkeypatch, *, sudo_cached=False, pkexec=True, display=True):
+    monkeypatch.setattr(plat, "_has_tty", lambda: False)
+    monkeypatch.setattr(plat, "_sudo_without_password", lambda: sudo_cached)
+    monkeypatch.setattr(plat.shutil, "which",
+                        lambda name: "/usr/bin/pkexec" if pkexec and name == "pkexec" else None)
+    monkeypatch.delenv("DISPLAY", raising=False)
+    if display:
+        monkeypatch.setenv("WAYLAND_DISPLAY", "wayland-0")
+    else:
+        monkeypatch.delenv("WAYLAND_DISPLAY", raising=False)
+
+
+def test_privileged_argv_unchanged_with_a_terminal(monkeypatch):
+    monkeypatch.setattr(plat, "_has_tty", lambda: True)
+    argv = ["sudo", "apt", "install", "ibus"]
+    assert plat.privileged_argv(argv) == argv
+
+
+def test_privileged_argv_leaves_unprivileged_commands_alone(monkeypatch):
+    _no_terminal(monkeypatch, pkexec=False)
+    assert plat.privileged_argv(["brew", "install", "x"]) == ["brew", "install", "x"]
+
+
+def test_privileged_argv_uses_pkexec_without_a_terminal(monkeypatch):
+    _no_terminal(monkeypatch)
+    assert plat.privileged_argv(["sudo", "apt", "install", "ibus", "gcc"]) == [
+        "pkexec", "apt", "install", "-y", "ibus", "gcc"]
+    assert plat.privileged_argv(["sudo", "pacman", "-S", "ibus"]) == [
+        "pkexec", "pacman", "-S", "--noconfirm", "ibus"]
+
+
+def test_privileged_argv_runs_shell_scripts_with_inner_sudo_under_pkexec(monkeypatch):
+    _no_terminal(monkeypatch)
+    script = ["sh", "-c", "printf x | sudo tee /etc/udev/rules.d/r > /dev/null"]
+    assert plat.privileged_argv(script) == ["pkexec", *script]
+
+
+def test_privileged_argv_prefers_cached_sudo(monkeypatch):
+    _no_terminal(monkeypatch, sudo_cached=True)
+    assert plat.privileged_argv(["sudo", "apt", "install", "x"]) == [
+        "sudo", "-n", "apt", "install", "-y", "x"]
+
+
+@pytest.mark.parametrize("pkexec,display", [(False, True), (True, False)])
+def test_privileged_argv_gives_up_without_pkexec_or_desktop(monkeypatch, pkexec, display):
+    _no_terminal(monkeypatch, pkexec=pkexec, display=display)
+    assert plat.privileged_argv(["sudo", "apt", "install", "x"]) is None
+
+
+def test_noninteractive_install_deps_without_terminal_prints_command(cfg_paths, monkeypatch, capsys):
+    _patch_noninteractive(monkeypatch)
+    monkeypatch.setattr("voiceio.platform.check_system_deps", lambda: ["portaudio"])
+    monkeypatch.setattr(plat, "system_deps_install_cmd", lambda keys: "sudo apt install libportaudio2")
+    monkeypatch.setattr(plat, "privileged_argv", lambda argv: None)
+    ran = []
+    monkeypatch.setattr(noninteractive.subprocess, "run", lambda *a, **k: ran.append(a))
+    code = noninteractive.run_setup_noninteractive({}, install_deps=True)
+    assert code == 4
+    assert ran == []
+    assert "sudo apt install libportaudio2" in capsys.readouterr().out
+
+
+def test_noninteractive_install_deps_runs_pkexec_argv(cfg_paths, monkeypatch):
+    _patch_noninteractive(monkeypatch)
+    state = {"missing": ["portaudio"]}
+    monkeypatch.setattr("voiceio.platform.check_system_deps", lambda: state["missing"])
+    monkeypatch.setattr(plat, "system_deps_install_cmd", lambda keys: "sudo apt install libportaudio2")
+    _no_terminal(monkeypatch)
+    ran = []
+
+    class _Done:
+        returncode = 0
+
+    def fake_run(argv, **kw):
+        ran.append(argv)
+        state["missing"] = []
+        return _Done()
+
+    monkeypatch.setattr(noninteractive.subprocess, "run", fake_run)
+    assert noninteractive.run_setup_noninteractive({}, install_deps=True) == 0
+    assert ran == [["pkexec", "apt", "install", "-y", "libportaudio2"]]
+
+
+def test_doctor_privileged_fix_asks_first_and_never_runs_when_declined(monkeypatch):
+    from voiceio.cli import doctor
+    ran = []
+    monkeypatch.setattr("subprocess.run", lambda *a, **k: ran.append(a))
+    monkeypatch.setattr(doctor, "_confirm_privileged", lambda d, c: False)
+    assert doctor._run_privileged("Fix x", ["sudo", "true"], 5) is None
+    assert ran == []
+
+
+def test_doctor_privileged_fix_without_terminal_prints_command(monkeypatch, capsys):
+    from voiceio.cli import doctor
+    ran = []
+    monkeypatch.setattr("subprocess.run", lambda *a, **k: ran.append(a))
+    monkeypatch.setattr(doctor, "_confirm_privileged", lambda d, c: True)
+    monkeypatch.setattr(plat, "privileged_argv", lambda argv: None)
+    assert doctor._run_privileged("Fix x", ["sudo", "udevadm", "trigger"], 5) is False
+    assert ran == []
+    assert "sudo udevadm trigger" in capsys.readouterr().out

{python_voiceio-1.16.1 → python_voiceio-1.17.1}/tests/test_tts.py

@@ -499,3 +499,54 @@ def test_chain_passes_language_to_supertonic():
     from voiceio.tts import chain
     engine = chain._create("supertonic", TTSConfig(engine="supertonic", language="de"))
     assert engine.name == "supertonic" and engine._language == "de"
+
+
+# ── no engine installed: the default config stays quiet ─────────────
+
+def _no_engines(cfg):
+    names = ["piper", "supertonic", "edge-tts", "espeak"] if cfg.engine == "auto" else [cfg.engine]
+    return [(n, ProbeResult(ok=False, reason=f"{n} not installed")) for n in names]
+
+
+def test_doctor_tts_auto_without_engine_is_quiet_off():
+    from voiceio import health
+    with patch("voiceio.tts.probe_all", side_effect=_no_engines):
+        status = health._tts_status(TTSConfig())
+    assert status.startswith("off")
+    assert "enabled but" not in status
+    assert "⚠" not in health._feature_line("Text-to-speech", status)
+
+
+def test_doctor_tts_named_engine_missing_still_warns():
+    from voiceio import health
+    with patch("voiceio.tts.probe_all", side_effect=_no_engines):
+        status = health._tts_status(TTSConfig(engine="piper"))
+    assert status.startswith("enabled but piper unavailable")
+
+
+def test_doctor_tts_on_when_engine_present():
+    from voiceio import health
+    with patch("voiceio.tts.probe_all",
+               return_value=[("piper", ProbeResult(ok=False, reason="x")),
+                             ("espeak", ProbeResult(ok=True))]):
+        assert health._tts_status(TTSConfig()) == "on (espeak)"
+
+
+def test_doctor_tts_disabled_is_off():
+    from voiceio import health
+    assert health._tts_status(TTSConfig(enabled=False)) == "off"
+
+
+def test_auto_select_without_engine_logs_no_warning(caplog):
+    import logging
+    from voiceio.tts.chain import select, _create
+
+    def none_ok(name, cfg):
+        engine = _create(name, cfg)
+        engine.probe = lambda: ProbeResult(ok=False, reason="not installed")
+        return engine
+
+    with patch("voiceio.tts.chain._create", side_effect=none_ok), \
+            caplog.at_level(logging.DEBUG, logger="voiceio.tts.chain"):
+        assert select(TTSConfig()) is None
+    assert not [r for r in caplog.records if r.levelno >= logging.WARNING]

python_voiceio-1.17.1/voiceio/__init__.py

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

{python_voiceio-1.16.1 → python_voiceio-1.17.1}/voiceio/app.py

@@ -202,8 +202,11 @@ class VoiceIO:
                 # Create a second hotkey backend for TTS
                 self._tts_hotkey = hotkey_chain.select(platform, cfg.hotkey.backend)
                 log.info("TTS: engine=%s, hotkey=%s", self._tts_engine.name, cfg.tts.hotkey)
+            elif cfg.tts.engine == "auto":
+                # The default config: read aloud once an engine is installed.
+                log.info("TTS: no engine installed, read-aloud hotkey off")
             else:
-                log.warning("TTS enabled but no engine available")
+                log.warning("TTS: engine '%s' is configured but unavailable", cfg.tts.engine)
 
         # Optional key that cancels a dictation (read only, never grabbed: the
         # key also reaches the focused app). Needs a backend that sees keys.
@@ -1007,11 +1010,11 @@ class VoiceIO:
             self._cancel_hotkey.start(self.cfg.hotkey.cancel_key, self.cancel)
 
     def run(self) -> None:
-        from voiceio.config import PID_PATH, LOG_DIR
+        from voiceio.config import PID_PATH, LOG_DIR, private_dir
 
         self._typers.redetect_at_start()
 
-        LOG_DIR.mkdir(parents=True, exist_ok=True)
+        private_dir(LOG_DIR)
         self._pid_fd = open(PID_PATH, "a")   # not "w": the running daemon's PID stays
         try:
             from voiceio.pidlock import lock_pid_file

{python_voiceio-1.16.1 → python_voiceio-1.17.1}/voiceio/cli/__init__.py

@@ -112,9 +112,9 @@ def _cmd_run(args: argparse.Namespace) -> None:
     console.setLevel(getattr(logging, cfg.daemon.log_level))
 
     # File: always log DEBUG to rotating file
-    from voiceio.config import LOG_DIR, LOG_PATH
+    from voiceio.config import LOG_DIR, LOG_PATH, private_dir
     from logging.handlers import RotatingFileHandler
-    LOG_DIR.mkdir(parents=True, exist_ok=True)
+    private_dir(LOG_DIR)
     file_handler = RotatingFileHandler(
         str(LOG_PATH), maxBytes=2_000_000, backupCount=2,
     )
@@ -125,6 +125,8 @@ def _cmd_run(args: argparse.Namespace) -> None:
 
     logging.basicConfig(level=logging.DEBUG, handlers=[console, file_handler])
     logging.getLogger("voiceio").setLevel(getattr(logging, cfg.daemon.log_level))
+    from voiceio.errorlog import RepeatedErrorNotifier
+    logging.getLogger("voiceio").addHandler(RepeatedErrorNotifier())
 
     log = logging.getLogger("voiceio")
     from voiceio import __version__, platform as plat
@@ -210,12 +212,13 @@ def _entry_point() -> None:
         import traceback
         tb = traceback.format_exc()
         try:
-            from voiceio.config import LOG_DIR
-            LOG_DIR.mkdir(parents=True, exist_ok=True)
+            from voiceio.config import LOG_DIR, private_dir
+            private_dir(LOG_DIR)
             with open(LOG_DIR / "crash.log", "a", encoding="utf-8") as f:
                 f.write(f"\n===== {datetime.datetime.now().isoformat()} =====\n"
                         f"argv: {sys.argv}\n{tb}")
-            print(f"\n[voiceio crashed — traceback in {LOG_DIR / 'crash.log'}]", file=sys.stderr)
+            print(f"\n[voiceio crashed — traceback in {LOG_DIR / 'crash.log'}]\n"
+                  "Report it: voiceio doctor --report", file=sys.stderr)
         except Exception:  # noqa: BLE001 — last resort
             pass
         print(tb, file=sys.stderr)