codna 0.2.32__tar.gz → 0.2.34__tar.gz

{codna-0.2.32 → codna-0.2.34}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codna
-Version: 0.2.32
+Version: 0.2.34
 Summary: Local-first repo intelligence and agent fixing for Codna.
 Author: Thyn
 Maintainer: Thyn

{codna-0.2.32 → codna-0.2.34}/codna/__init__.py

@@ -5,4 +5,4 @@ This package is the `codna` CLI. Users never touch "algenta" directly — the en
 is an internal dependency reached over HTTP.
 """
 
-__version__ = "0.2.32"
+__version__ = "0.2.34"

{codna-0.2.32 → codna-0.2.34}/codna/local_mojo_daemon.py

@@ -9,7 +9,7 @@ import sys
 import threading
 import time
 from pathlib import Path
-from typing import Any
+from typing import Any, Callable
 
 from . import local_mojo_pool as local_mojo_pool_module
 from .local_mojo_pool import (
@@ -56,6 +56,56 @@ class LocalMojoDaemonError(RuntimeError):
         self.details = details or {}
 
 
+_IDLE_EXIT_ENV = "CODNA_LOCAL_MOJO_DAEMON_IDLE_S"
+_DEFAULT_IDLE_EXIT_S = 1800.0
+
+
+def local_mojo_daemon_idle_exit_seconds() -> float:
+    """Seconds without a request after which the daemon exits on its own; ``0`` disables.
+
+    The daemon is started on demand (:func:`ensure_local_mojo_daemon`) and, until 2026-09-18, never
+    stopped on its own: every test run and every CLI run with a fresh ``CODNA_RUNTIME_ROOT`` left a
+    daemon plus its ``simulate`` worker behind for good -- 70 such pairs (634 MB) were found on one
+    laptop after a day. The next request simply starts a fresh daemon, so idling out costs one pool
+    start. Configurable via ``CODNA_LOCAL_MOJO_DAEMON_IDLE_S``; a request that is still running
+    always holds the daemon open (see :class:`_Activity`).
+    """
+    raw = os.environ.get(_IDLE_EXIT_ENV)
+    if raw is None or not raw.strip():
+        return _DEFAULT_IDLE_EXIT_S
+    try:
+        return max(0.0, float(raw))
+    except ValueError:
+        return _DEFAULT_IDLE_EXIT_S
+
+
+class _Activity:
+    """Request bookkeeping for the idle timer: time of the last request and requests in flight."""
+
+    def __init__(self, clock: Callable[[], float] = time.monotonic) -> None:
+        self._clock = clock
+        self._lock = threading.Lock()
+        self._last = clock()
+        self._in_flight = 0
+
+    def begin(self) -> None:
+        with self._lock:
+            self._in_flight += 1
+            self._last = self._clock()
+
+    def end(self) -> None:
+        with self._lock:
+            self._in_flight = max(0, self._in_flight - 1)
+            self._last = self._clock()
+
+    def idle_for(self) -> float:
+        """Seconds since the last request ended; ``0.0`` while any request is still running."""
+        with self._lock:
+            if self._in_flight > 0:
+                return 0.0
+            return self._clock() - self._last
+
+
 def local_mojo_daemon_enabled() -> bool:
     if os.environ.get("CODNA_LOCAL_MOJO_DAEMON") == "1":
         return False
@@ -530,24 +580,77 @@ def _invoke_owned_pool_direct(payload: dict[str, Any], *, timeout: float | None
     return result
 
 
-def _serve_client(handle: socket.socket, config: RuntimeConfig, stop_event: threading.Event) -> None:
-    with handle:
-        try:
-            request = _read_frame(handle)
-            response = _handle_request(config, request, stop_event)
-        except Exception as exc:  # noqa: BLE001
-            response = {
-                "ok": False,
-                "error": {
-                    "code": getattr(exc, "code", "local_mojo_daemon_request_failed"),
-                    "message": str(exc),
-                    "details": getattr(exc, "details", {}),
-                },
-            }
+def _serve_client(
+    handle: socket.socket,
+    config: RuntimeConfig,
+    stop_event: threading.Event,
+    activity: _Activity | None = None,
+) -> None:
+    try:
+        if activity is not None:
+            activity.begin()  # inside the try: end() must run even if begin() itself failed
+        with handle:
+            try:
+                request = _read_frame(handle)
+                response = _handle_request(config, request, stop_event)
+            except Exception as exc:  # noqa: BLE001
+                response = {
+                    "ok": False,
+                    "error": {
+                        "code": getattr(exc, "code", "local_mojo_daemon_request_failed"),
+                        "message": str(exc),
+                        "details": getattr(exc, "details", {}),
+                    },
+                }
+            try:
+                _write_frame(handle, response)
+            except OSError:
+                return
+    finally:
+        if activity is not None:
+            activity.end()
+
+
+def _accept_loop(
+    server: Any,
+    config: RuntimeConfig,
+    stop_event: threading.Event,
+    *,
+    idle_exit_s: float,
+    activity: _Activity,
+) -> str:
+    """Accept clients until asked to stop, or until idle for ``idle_exit_s`` (``0`` = never).
+
+    Returns ``"stopped"``, ``"idle"`` or ``"error"`` -- the reason the loop ended."""
+    while not stop_event.is_set():
         try:
-            _write_frame(handle, response)
-        except OSError:
-            return
+            client, _addr = server.accept()
+        except TimeoutError:
+            if idle_exit_s > 0 and activity.idle_for() >= idle_exit_s:
+                print(
+                    json.dumps({"event": "local_mojo_daemon_idle_exit", "idle_s": idle_exit_s, "pid": os.getpid()}),
+                    file=sys.stderr,
+                )
+                stop_event.set()
+                return "idle"
+            continue
+        except OSError as exc:
+            # EMFILE / EBADF / ECONNABORTED on the listening socket: the daemon cannot serve any
+            # more, so end cleanly (the caller's finally shuts the pool) instead of dying mid-loop
+            # with the stop event never set. The next ensure_local_mojo_daemon starts a fresh one.
+            print(
+                json.dumps({"event": "local_mojo_daemon_accept_error", "error": f"{type(exc).__name__}: {exc}", "pid": os.getpid()}),
+                file=sys.stderr,
+            )
+            stop_event.set()
+            return "error"
+        thread = threading.Thread(
+            target=_serve_client,
+            args=(client, config, stop_event, activity),
+            daemon=True,
+        )
+        thread.start()
+    return "stopped"
 
 
 def serve_local_mojo_daemon() -> int:
@@ -563,17 +666,13 @@ def serve_local_mojo_daemon() -> int:
             server.bind(str(socket_path))
             server.listen()
             server.settimeout(0.5)
-            while not stop_event.is_set():
-                try:
-                    client, _addr = server.accept()
-                except TimeoutError:
-                    continue
-                thread = threading.Thread(
-                    target=_serve_client,
-                    args=(client, config, stop_event),
-                    daemon=True,
-                )
-                thread.start()
+            _accept_loop(
+                server,
+                config,
+                stop_event,
+                idle_exit_s=local_mojo_daemon_idle_exit_seconds(),
+                activity=_Activity(),
+            )
         return 0
     finally:
         shutdown_local_mojo_pool()

{codna-0.2.32 → codna-0.2.34}/codna.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: codna
-Version: 0.2.32
+Version: 0.2.34
 Summary: Local-first repo intelligence and agent fixing for Codna.
 Author: Thyn
 Maintainer: Thyn

{codna-0.2.32 → codna-0.2.34}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "codna"
-version = "0.2.32"
+version = "0.2.34"
 description = "Local-first repo intelligence and agent fixing for Codna."
 readme = "README.md"
 requires-python = ">=3.10"

codna-0.2.34/tests/test_local_mojo_daemon.py

@@ -0,0 +1,179 @@
+from __future__ import annotations
+
+import json
+
+import pytest
+
+from codna.local_mojo_daemon import (
+    LocalMojoDaemonError,
+    local_mojo_daemon_state_path,
+    stop_local_mojo_daemon,
+)
+from codna.runtime.config import resolve_runtime_config
+import codna.local_mojo_daemon as local_mojo_daemon_module
+
+
+def test_stop_local_mojo_daemon_reports_permission_denied(tmp_path, monkeypatch) -> None:
+    monkeypatch.setenv("CODNA_RUNTIME_ROOT", str(tmp_path / ".codna"))
+    config = resolve_runtime_config()
+    state_path = local_mojo_daemon_state_path(config)
+    state_path.parent.mkdir(parents=True)
+    state_path.write_text(json.dumps({"pid": 123}), encoding="utf-8")
+
+    monkeypatch.setattr(local_mojo_daemon_module, "_daemon_state_matches", lambda _config, _state: True)
+    monkeypatch.setattr(local_mojo_daemon_module, "_request_daemon", lambda *_args, **_kwargs: None)
+    monkeypatch.setattr(local_mojo_daemon_module, "pid_is_alive", lambda _pid: True)
+
+    def deny_stop(*_args, **_kwargs):
+        raise PermissionError("denied")
+
+    monkeypatch.setattr(local_mojo_daemon_module, "terminate_pid", deny_stop)
+
+    with pytest.raises(LocalMojoDaemonError) as excinfo:
+        stop_local_mojo_daemon(config)
+
+    assert excinfo.value.code == "local_mojo_daemon_stop_permission_denied"
+    assert excinfo.value.details["pid"] == 123
+    assert excinfo.value.details["manual_stop_command"] == "kill 123"
+
+
+# ---- idle auto-exit (the daemon used to live forever; 70 leaked daemon+worker pairs on one laptop) ----
+
+class _Clock:
+    def __init__(self) -> None:
+        self.t = 0.0
+
+    def __call__(self) -> float:
+        return self.t
+
+
+class _TimingOutServer:
+    """accept() never yields a client; each call advances the clock, then raises TimeoutError."""
+
+    def __init__(self, clock: _Clock, step: float, stop_after: int | None = None, stop_event=None) -> None:
+        self.clock, self.step, self.stop_after, self.stop_event, self.calls = clock, step, stop_after, stop_event, 0
+
+    def accept(self):
+        self.calls += 1
+        self.clock.t += self.step
+        if self.stop_after is not None and self.calls >= self.stop_after and self.stop_event is not None:
+            self.stop_event.set()
+        raise TimeoutError
+
+
+def test_idle_exit_seconds_defaults_and_parsing(monkeypatch) -> None:
+    monkeypatch.delenv("CODNA_LOCAL_MOJO_DAEMON_IDLE_S", raising=False)
+    assert local_mojo_daemon_module.local_mojo_daemon_idle_exit_seconds() == 1800.0
+    monkeypatch.setenv("CODNA_LOCAL_MOJO_DAEMON_IDLE_S", "90")
+    assert local_mojo_daemon_module.local_mojo_daemon_idle_exit_seconds() == 90.0
+    monkeypatch.setenv("CODNA_LOCAL_MOJO_DAEMON_IDLE_S", "0")
+    assert local_mojo_daemon_module.local_mojo_daemon_idle_exit_seconds() == 0.0
+    monkeypatch.setenv("CODNA_LOCAL_MOJO_DAEMON_IDLE_S", "not-a-number")
+    assert local_mojo_daemon_module.local_mojo_daemon_idle_exit_seconds() == 1800.0
+    monkeypatch.setenv("CODNA_LOCAL_MOJO_DAEMON_IDLE_S", "-5")
+    assert local_mojo_daemon_module.local_mojo_daemon_idle_exit_seconds() == 0.0
+
+
+def test_accept_loop_exits_once_idle_for_the_configured_time(capsys) -> None:
+    """REGRESSION: the loop only ever ended on an explicit shutdown request, so a daemon whose
+    client (a test run) simply exited kept itself and its simulate worker alive forever."""
+    import threading
+
+    clock = _Clock()
+    stop = threading.Event()
+    server = _TimingOutServer(clock, step=4.0)
+    activity = local_mojo_daemon_module._Activity(clock)
+    why = local_mojo_daemon_module._accept_loop(server, object(), stop, idle_exit_s=10.0, activity=activity)
+    assert why == "idle"
+    assert stop.is_set()
+    assert server.calls == 3                      # 4 s, 8 s, 12 s -> idle >= 10 s on the third timeout
+    assert "local_mojo_daemon_idle_exit" in capsys.readouterr().err
+
+
+def test_accept_loop_with_idle_exit_disabled_only_stops_on_request() -> None:
+    import threading
+
+    clock = _Clock()
+    stop = threading.Event()
+    server = _TimingOutServer(clock, step=1000.0, stop_after=3, stop_event=stop)
+    activity = local_mojo_daemon_module._Activity(clock)
+    why = local_mojo_daemon_module._accept_loop(server, object(), stop, idle_exit_s=0.0, activity=activity)
+    assert why == "stopped" and server.calls == 3
+
+
+def test_accept_loop_never_idles_out_while_a_request_is_running() -> None:
+    """A long invoke must not be cut off by the idle timer: in-flight requests pin the daemon."""
+    import threading
+
+    clock = _Clock()
+    stop = threading.Event()
+    server = _TimingOutServer(clock, step=1000.0, stop_after=3, stop_event=stop)
+    activity = local_mojo_daemon_module._Activity(clock)
+    activity.begin()                              # a request is in flight the whole time
+    why = local_mojo_daemon_module._accept_loop(server, object(), stop, idle_exit_s=10.0, activity=activity)
+    assert why == "stopped" and server.calls == 3  # 3000 s "idle" on the clock, yet no idle exit
+
+
+def test_serve_client_brackets_the_request_in_activity(monkeypatch) -> None:
+    import threading
+    from unittest.mock import MagicMock
+
+    clock = _Clock()
+    activity = local_mojo_daemon_module._Activity(clock)
+    clock.t = 50.0
+    seen = []
+    monkeypatch.setattr(local_mojo_daemon_module, "_read_frame", lambda _h: {"type": "ping"})
+    monkeypatch.setattr(local_mojo_daemon_module, "_handle_request", lambda _c, _req, _stop: {"ok": True})
+    monkeypatch.setattr(local_mojo_daemon_module, "_write_frame", lambda _h, resp: seen.append(resp))
+    handle = MagicMock()
+    handle.__enter__ = lambda self: self
+    handle.__exit__ = lambda self, *a: None
+    local_mojo_daemon_module._serve_client(handle, object(), threading.Event(), activity)
+    assert seen and seen[0]["ok"] is True
+    assert activity._in_flight == 0
+    assert activity.idle_for() == 0.0             # the request just ended at t=50 -> idle resets
+    clock.t = 61.0
+    assert activity.idle_for() == 11.0
+
+
+class _BrokenServer:
+    def __init__(self, exc: BaseException) -> None:
+        self.exc = exc
+
+    def accept(self):
+        raise self.exc
+
+
+def test_accept_loop_ends_cleanly_when_the_listening_socket_breaks(capsys) -> None:
+    """EMFILE / EBADF on accept() used to escape the loop as an exception with the stop event never
+    set; now the loop ends with reason "error" and the caller's finally still shuts the pool."""
+    import threading
+
+    stop = threading.Event()
+    activity = local_mojo_daemon_module._Activity(_Clock())
+    why = local_mojo_daemon_module._accept_loop(
+        _BrokenServer(OSError(24, "Too many open files")), object(), stop, idle_exit_s=10.0, activity=activity,
+    )
+    assert why == "error" and stop.is_set()
+    assert "local_mojo_daemon_accept_error" in capsys.readouterr().err
+
+
+def test_serve_client_ends_activity_even_if_begin_fails(monkeypatch) -> None:
+    import threading
+    from unittest.mock import MagicMock
+
+    activity = local_mojo_daemon_module._Activity(_Clock())
+    calls = {"begin": 0}
+
+    def failing_begin():
+        calls["begin"] += 1
+        raise RuntimeError("boom")
+
+    monkeypatch.setattr(activity, "begin", failing_begin)
+    handle = MagicMock()
+    handle.__enter__ = lambda self: self
+    handle.__exit__ = lambda self, *a: None
+    with pytest.raises(RuntimeError):
+        local_mojo_daemon_module._serve_client(handle, object(), threading.Event(), activity)
+    assert calls["begin"] == 1
+    assert activity._in_flight == 0  # end() ran and clamped at zero: the idle timer is not wedged

codna-0.2.32/tests/test_local_mojo_daemon.py

@@ -1,37 +0,0 @@
-from __future__ import annotations
-
-import json
-
-import pytest
-
-from codna.local_mojo_daemon import (
-    LocalMojoDaemonError,
-    local_mojo_daemon_state_path,
-    stop_local_mojo_daemon,
-)
-from codna.runtime.config import resolve_runtime_config
-import codna.local_mojo_daemon as local_mojo_daemon_module
-
-
-def test_stop_local_mojo_daemon_reports_permission_denied(tmp_path, monkeypatch) -> None:
-    monkeypatch.setenv("CODNA_RUNTIME_ROOT", str(tmp_path / ".codna"))
-    config = resolve_runtime_config()
-    state_path = local_mojo_daemon_state_path(config)
-    state_path.parent.mkdir(parents=True)
-    state_path.write_text(json.dumps({"pid": 123}), encoding="utf-8")
-
-    monkeypatch.setattr(local_mojo_daemon_module, "_daemon_state_matches", lambda _config, _state: True)
-    monkeypatch.setattr(local_mojo_daemon_module, "_request_daemon", lambda *_args, **_kwargs: None)
-    monkeypatch.setattr(local_mojo_daemon_module, "pid_is_alive", lambda _pid: True)
-
-    def deny_stop(*_args, **_kwargs):
-        raise PermissionError("denied")
-
-    monkeypatch.setattr(local_mojo_daemon_module, "terminate_pid", deny_stop)
-
-    with pytest.raises(LocalMojoDaemonError) as excinfo:
-        stop_local_mojo_daemon(config)
-
-    assert excinfo.value.code == "local_mojo_daemon_stop_permission_denied"
-    assert excinfo.value.details["pid"] == 123
-    assert excinfo.value.details["manual_stop_command"] == "kill 123"