Dodaios is an open-source agent OS for your desktop: it runs your coding agents, browser and apps by voice or chat, on your own machine. Formerly Personal Jarvis.
Python agent-orchestrationai-agentai-coding-assistantclaude-codecoding-agentcomputer-usedesktop-applocal-firstmcppersonal-jarvisvoice-assistantvoice-coding
fix(dictation): reap abandoned native model workers
rubenluetke10-beep084607383dcb
diff --git a/jarvis/dictation/local_preview.py b/jarvis/dictation/local_preview.pyindex 25de9922d7..8d6c314a58 100644--- a/jarvis/dictation/local_preview.py+++ b/jarvis/dictation/local_preview.py@@ -48,6 +48,7 @@ import subprocessimport sysimport threadingimport time+import weakreffrom pathlib import Pathfrom types import SimpleNamespacefrom typing import Any@@ -116,6 +117,40 @@ def _child_python() -> str:raise RuntimeError(f"no python interpreter beside {exe}")+def _close_worker_process(proc: subprocess.Popen[bytes]) -> None:+ """Kill, reap and close pipes. Runs only on a cleanup/caller worker thread."""+ try:+ proc.kill()+ except Exception as exc: # noqa: BLE001 — an already-dead worker is the goal state+ log.debug("Preview worker kill skipped: %s", exc)+ try:+ wait = getattr(proc, "wait", None)+ if callable(wait):+ wait(timeout=3.0)+ except Exception as exc: # noqa: BLE001 — never wait forever on teardown+ log.warning("Preview worker did not exit after kill: %s", exc)+ return+ for stream in (proc.stdin, proc.stdout):+ if stream is not None:+ try:+ stream.close()+ except Exception as exc: # noqa: BLE001 — already-closed pipe is harmless+ log.debug("Preview worker pipe close skipped: %s", exc)+++def _release_abandoned_worker(proc: subprocess.Popen[bytes]) -> None:+ """Do not let garbage collection block the voice/UI loop on pipe teardown."""+ try:+ threading.Thread(+ target=_close_worker_process,+ args=(proc,),+ name="dictation-worker-reap",+ daemon=True,+ ).start()+ except RuntimeError:+ log.exception("Could not schedule abandoned dictation worker cleanup")++class _WorkerModel:"""faster-whisper-shaped proxy whose decodes run in the preview worker.@@ -130,6 +165,15 @@ class _WorkerModel:self._proc = procself.device = deviceself.compute = compute+ # Provider switches discard the owner without necessarily calling close.+ # Popen can retain a live child in its global _active list, including+ # its open stdin pipe: neither GC nor the child's EOF loop then frees+ # the native model. Retain only the process here, never a bound method+ # of self. Active transcribe calls keep self alive until they finish.+ self._cleanup = weakref.finalize(self, _release_abandoned_worker, proc)+ # No new threads during interpreter shutdown. Parent pipe closure is+ # the worker's existing EOF/exit path at process shutdown.+ self._cleanup.atexit = False # type: ignore[misc] # Writable property despite finalize's slots.def transcribe(self,@@ -175,23 +219,8 @@ class _WorkerModel:def close(self) -> None:"""Kill and reap the worker. Blocking: callers must keep this off-loop."""- try:- self._proc.kill()- except Exception as exc: # noqa: BLE001 — an already-dead worker is the goal state- log.debug("Preview worker kill skipped: %s", exc)- try:- wait = getattr(self._proc, "wait", None)- if callable(wait):- wait(timeout=3.0)- except Exception as exc: # noqa: BLE001 — never wait forever on teardown- log.warning("Preview worker did not exit after kill: %s", exc)- return- for stream in (self._proc.stdin, self._proc.stdout):- if stream is not None:- try:- stream.close()- except Exception as exc: # noqa: BLE001 — already-closed pipe is harmless- log.debug("Preview worker pipe close skipped: %s", exc)+ if self._cleanup.detach() is not None:+ _close_worker_process(self._proc)def _spawn_worker_model(model_name: str, *, compute: str | None = None) -> _WorkerModel | None:diff --git a/tests/unit/dictation/test_worker_ownership.py b/tests/unit/dictation/test_worker_ownership.pynew file mode 100644index 0000000000..8dba1ab5e1--- /dev/null+++ b/tests/unit/dictation/test_worker_ownership.py@@ -0,0 +1,123 @@+"""An abandoned native worker must not outlive its last usable owner."""++from __future__ import annotations++import gc+import io+import subprocess+import sys+import threading+import weakref++import pytest++from jarvis.core.process_utils import NO_WINDOW_CREATIONFLAGS+from jarvis.dictation.local_final import LocalFinalSTT+from jarvis.dictation.local_preview import LocalPreviewTranscriber, _WorkerModel+++class Process:+ def __init__(self) -> None:+ self.stdin = io.BytesIO()+ self.stdout = io.BytesIO()+ self.kills = 0+ self.reaped = threading.Event()++ def kill(self) -> None:+ self.kills += 1++ def wait(self, timeout: float) -> int:+ self.reaped.set()+ return 0++[email protected]("kind", ["preview", "final"])+def test_replacing_an_owner_reaps_its_abandoned_worker(kind: str) -> None:+ proc = Process()+ worker = _WorkerModel(proc, "cpu", "int8")+ if kind == "preview":+ owner = LocalPreviewTranscriber(prefer_worker=True)+ owner._model = worker+ else:+ owner = LocalFinalSTT()+ owner._worker = worker+ reference = weakref.ref(worker)+ del worker, owner+ gc.collect()+ assert reference() is None+ assert proc.reaped.wait(2), "the owner disappeared but its worker was never reaped"+ assert proc.kills == 1+++def test_a_retained_worker_is_not_reaped_until_the_last_caller_releases_it() -> None:+ proc = Process()+ owner = LocalFinalSTT()+ owner._worker = _WorkerModel(proc, "cpu", "int8")+ active_call = owner._worker+ del owner+ gc.collect()+ assert proc.kills == 0+ del active_call+ gc.collect()+ assert proc.reaped.wait(2)+++def test_explicit_close_and_later_collection_reap_only_once() -> None:+ proc = Process()+ worker = _WorkerModel(proc, "cpu", "int8")+ worker.close()+ worker.close()+ del worker+ gc.collect()+ assert proc.kills == 1+ assert proc.stdin.closed and proc.stdout.closed+++def test_collection_never_waits_for_a_slow_worker_on_the_collecting_thread() -> None:+ release = threading.Event()+ started = threading.Event()++ class SlowProcess(Process):+ def wait(self, timeout: float) -> int:+ started.set()+ assert release.wait(timeout)+ return super().wait(timeout)++ proc = SlowProcess()+ worker = _WorkerModel(proc, "cpu", "int8")+ try:+ del worker+ gc.collect()+ assert started.wait(1)+ assert not proc.reaped.is_set()+ finally:+ release.set()+ assert proc.reaped.wait(2)+++def test_twenty_real_worker_replacements_leave_no_child_processes() -> None:+ """Exercise real process ownership without importing any inference engine."""+ processes: list[subprocess.Popen[bytes]] = []+ try:+ for _ in range(20):+ proc = subprocess.Popen(+ [sys.executable, "-X", "utf8", "-c", "import sys; sys.stdin.buffer.read()"],+ stdin=subprocess.PIPE,+ stdout=subprocess.PIPE,+ stderr=subprocess.DEVNULL,+ creationflags=NO_WINDOW_CREATIONFLAGS,+ )+ processes.append(proc)+ worker = _WorkerModel(proc, "cpu", "int8")+ del worker+ gc.collect()+ proc.wait(timeout=5)+ assert all(proc.poll() is not None for proc in processes)+ finally:+ for proc in processes:+ if proc.poll() is None:+ proc.kill()+ proc.wait(timeout=5)+ for stream in (proc.stdin, proc.stdout):+ if stream is not None:+ stream.close()