Personal AI, On Personal Devices
Python
fix(daemon): report the address the server actually bound to (#924)
ceyre-boop6ceded992484
diff --git a/src/openjarvis/cli/daemon_cmd.py b/src/openjarvis/cli/daemon_cmd.pyindex c2511681..a5c347b9 100644--- a/src/openjarvis/cli/daemon_cmd.py+++ b/src/openjarvis/cli/daemon_cmd.py@@ -2,18 +2,27 @@from __future__ import annotations+import json+import osimport subprocessimport sysimport time+from contextlib import contextmanager+from typing import Iteratorimport clickfrom rich.console import Consolefrom openjarvis.core.config import DEFAULT_CONFIG_DIR, load_configfrom openjarvis.core.utils import process_alive, terminate_process+from openjarvis.security.file_utils import secure_write_json, secure_write_text_PID_FILE = DEFAULT_CONFIG_DIR / "server.pid"_LOG_FILE = DEFAULT_CONFIG_DIR / "server.log"+# Records the address the daemon was actually started on. Without it `status`+# and `restart` fall back to the config defaults and misreport (or silently+# move) the port whenever `start` was given an explicit --host/--port.+_STATE_FILE = DEFAULT_CONFIG_DIR / "server.json"def _pid_alive(pid: int) -> bool:@@ -21,26 +30,137 @@ def _pid_alive(pid: int) -> bool:return process_alive(pid)-def _read_pid() -> int | None:- """Read PID from pid file, return None if not found or stale."""- if not _PID_FILE.exists():- return None+@contextmanager+def _state_lock() -> Iterator[None]:+ """Serialize daemon bookkeeping across launching and supervised processes."""+ _PID_FILE.parent.mkdir(parents=True, exist_ok=True)+ with _PID_FILE.with_suffix(".lock").open("a+b") as lock:+ if os.name == "nt":+ import msvcrt++ if lock.tell() == 0:+ lock.write(b"\0")+ lock.flush()+ lock.seek(0)+ msvcrt.locking(lock.fileno(), msvcrt.LK_LOCK, 1)+ else:+ import fcntl++ fcntl.flock(lock.fileno(), fcntl.LOCK_EX)+ try:+ yield+ finally:+ if os.name == "nt":+ lock.seek(0)+ msvcrt.locking(lock.fileno(), msvcrt.LK_UNLCK, 1)+ else:+ fcntl.flock(lock.fileno(), fcntl.LOCK_UN)+++def _read_pid_file() -> int | None:try:pid = int(_PID_FILE.read_text().strip())except (OSError, ValueError):- _PID_FILE.unlink(missing_ok=True)return None- # Check if process is still running (non-destructive, cross-platform).- if not _pid_alive(pid):+ return pid if pid > 0 else None+++def _clear_state_unlocked(pid: int) -> None:+ # The files can disagree after an interrupted older writer. Check each+ # owner separately; one matching file never authorizes deleting the other.+ if _read_pid_file() == pid:_PID_FILE.unlink(missing_ok=True)- return None- return pid+ if _read_state().get("pid") == pid:+ _STATE_FILE.unlink(missing_ok=True)-def _write_pid(pid: int) -> None:- """Write PID to pid file."""- DEFAULT_CONFIG_DIR.mkdir(parents=True, exist_ok=True)- _PID_FILE.write_text(str(pid))+def _read_pid() -> int | None:+ """Read PID from pid file, return None if not found or stale."""+ with _state_lock():+ pid = _read_pid_file()+ if pid is None:+ _PID_FILE.unlink(missing_ok=True)+ return None+ if not _pid_alive(pid):+ _clear_state_unlocked(pid)+ return None+ return pid+++def _write_pid(+ pid: int, host: str = "", port: int | None = None, *, ready: bool = True+) -> None:+ """Write PID, plus the address the daemon actually bound to."""+ with _state_lock():+ existing = _read_pid_file()+ if existing is not None and existing != pid and _pid_alive(existing):+ raise RuntimeError(f"Another server is already registered (PID {existing})")+ current = _read_state()+ if not ready and current.get("pid") == pid and current.get("ready", True):+ # The child may have finished binding before its parent records+ # the spawn. Never replace that actual address with a request.+ return+ secure_write_text(_PID_FILE, str(pid))+ if host or port is not None:+ state = {"pid": pid, "host": host, "port": port}+ if not ready:+ state["ready"] = False+ secure_write_json(_STATE_FILE, state)+ else:+ _STATE_FILE.unlink(missing_ok=True)+++def _read_state() -> dict:+ """Return the recorded daemon address, or {} when it is unavailable."""+ try:+ state = json.loads(_STATE_FILE.read_text())+ except (OSError, ValueError):+ return {}+ if not isinstance(state, dict):+ return {}+ if (+ type(state.get("pid")) is not int+ or state["pid"] <= 0+ or not isinstance(state.get("host"), str)+ or not state["host"].strip()+ or type(state.get("port")) is not int+ or not 0 <= state["port"] <= 65535+ or type(state.get("ready", True)) is not bool+ ):+ return {}+ return state+++def _bound_address(pid: int | None = None) -> tuple[str, int]:+ """Resolve the daemon's address, preferring what `start` recorded."""+ state = _read_state()+ if (+ state.get("pid") == (pid if pid is not None else _read_pid_file())+ and state.get("ready", True)+ and state+ ):+ return state["host"], state["port"]+ config = load_config()+ return config.server.host, int(config.server.port)+++def _server_url(host: str, port: int) -> str:+ return f"http://[{host}]:{port}" if ":" in host else f"http://{host}:{port}"+++def record_server_state(pid: int, host: str, port: int) -> None:+ """Register a running server so `jarvis status` can find it.++ Called by `jarvis serve` itself, so a server supervised by launchd/systemd+ (which never goes through `jarvis start`) is still reported as running.+ """+ _write_pid(pid, host, port)+++def clear_server_state(pid: int) -> None:+ """Deregister a server on shutdown, but only if it still owns the files."""+ with _state_lock():+ _clear_state_unlocked(pid)@click.group()@@ -72,13 +192,13 @@ def start(config = load_config()bind_host = host or config.server.host- bind_port = port or config.server.port+ bind_port = port if port is not None else config.server.port# Build command to run jarvis servecmd = [sys.executable, "-m", "openjarvis.cli", "serve"]if host:cmd.extend(["--host", host])- if port:+ if port is not None:cmd.extend(["--port", str(port)])if engine_key:cmd.extend(["--engine", engine_key])@@ -110,11 +230,15 @@ def start(stderr=log_fh,**spawn_kwargs,)- _write_pid(proc.pid)+ try:+ _write_pid(proc.pid, bind_host, bind_port, ready=False)+ except RuntimeError as exc:+ terminate_process(proc.pid, grace_seconds=10.0)+ raise click.ClickException(str(exc)) from excconsole.print(- f"[green]OpenJarvis server started[/green] (PID {proc.pid})\n"- f" URL: http://{bind_host}:{bind_port}\n"+ f"[green]OpenJarvis server starting[/green] (PID {proc.pid})\n"+ f" Requested URL: {_server_url(bind_host, bind_port)}\n"f" Log: {_LOG_FILE}")@@ -132,7 +256,7 @@ def stop() -> None:# 10s if still running. Cross-platform — no POSIX-only os.kill/SIGKILL.terminate_process(pid, grace_seconds=10.0)- _PID_FILE.unlink(missing_ok=True)+ clear_server_state(pid)console.print(f"[green]Server stopped[/green] (PID {pid}).")@@ -142,10 +266,19 @@ def restart(ctx: click.Context) -> None:"""Restart the OpenJarvis server daemon."""console = Console(stderr=True)pid = _read_pid()+ previous = _read_state() if pid is not None else {}+ if previous.get("pid") != pid:+ previous = {}if pid is not None:console.print(f"Stopping server (PID {pid})...")ctx.invoke(stop)- ctx.invoke(start)+ # Carry the previous bind address across the restart; otherwise an explicit+ # `start --port N` silently reverts to the config default on restart.+ ctx.invoke(+ start,+ host=previous.get("host") or None,+ port=previous.get("port"),+ )@daemon.command()@@ -157,6 +290,12 @@ def status() -> None:console.print("[yellow]Server is not running.[/yellow]")return+ state = _read_state()+ if state.get("pid") == pid and state.get("ready") is False:+ console.print(f"[yellow]Server is starting[/yellow] (PID {pid}).")+ console.print(f" Log: {_LOG_FILE}")+ return+# Get process infouptime_info = ""try:@@ -170,10 +309,10 @@ def status() -> None:except (ImportError, Exception):pass- config = load_config()+ host, port = _bound_address(pid)console.print(f"[green]Server is running[/green] (PID {pid}){uptime_info}\n"- f" URL: http://{config.server.host}:{config.server.port}\n"+ f" URL: {_server_url(host, port)}\n"f" Log: {_LOG_FILE}")diff --git a/src/openjarvis/cli/serve.py b/src/openjarvis/cli/serve.pyindex 650f7e42..0ea1dc19 100644--- a/src/openjarvis/cli/serve.py+++ b/src/openjarvis/cli/serve.py@@ -156,7 +156,7 @@ def serve(# Resolve host/port from CLI args or configbind_host = host or config.server.host- bind_port = port or config.server.port+ bind_port = port if port is not None else config.server.port# Set up engineregister_builtin_models()@@ -741,4 +741,6 @@ def serve("authenticated requests to your instance.")- uvicorn.run(app, host=bind_host, port=bind_port, log_level="info")+ from openjarvis.server.daemon import run_server++ run_server(app, host=bind_host, port=bind_port, log_level="info")diff --git a/src/openjarvis/server/daemon.py b/src/openjarvis/server/daemon.pynew file mode 100644index 00000000..99b4a424--- /dev/null+++ b/src/openjarvis/server/daemon.py@@ -0,0 +1,41 @@+"""Register daemon state only after Uvicorn has opened its listening socket."""++from __future__ import annotations++import os+import socket+from typing import Any++import uvicorn++from openjarvis.cli.daemon_cmd import clear_server_state, record_server_state+++class DaemonServer(uvicorn.Server):+ async def startup(self, sockets: list[socket.socket] | None = None) -> None:+ await super().startup(sockets=sockets)+ if not self.started:+ return+ listener = next(+ sock for server in self.servers for sock in (server.sockets or [])+ )+ host, port = listener.getsockname()[:2]+ try:+ record_server_state(os.getpid(), host, port)+ except Exception:+ # A second supervised server must not take over an existing live+ # daemon's entry. Close this listener and its application cleanly.+ await self.shutdown(sockets=sockets)+ raise+++def run_server(app: Any, *, host: str, port: int, log_level: str = "info") -> None:+ server = DaemonServer(+ uvicorn.Config(app, host=host, port=port, log_level=log_level)+ )+ try:+ server.run()+ finally:+ # Includes startup failure: remove a parent-created pending entry, but+ # never an entry belonging to a different server process.+ clear_server_state(os.getpid())diff --git a/tests/cli/test_daemon_state.py b/tests/cli/test_daemon_state.pynew file mode 100644index 00000000..9fdb0a83--- /dev/null+++ b/tests/cli/test_daemon_state.py@@ -0,0 +1,188 @@+"""Daemon address bookkeeping.++`status` and `restart` used to read `config.server.{host,port}` rather than the+address the daemon actually bound to, so `jarvis start --port N` was reported+(and restarted) on the config default instead of N.+"""++from __future__ import annotations++import json+import threading++import pytest+from click.testing import CliRunner++from openjarvis.cli import daemon_cmd+++def state_dir(tmp_path, monkeypatch):+ monkeypatch.setattr(daemon_cmd, "_PID_FILE", tmp_path / "server.pid")+ monkeypatch.setattr(daemon_cmd, "_STATE_FILE", tmp_path / "server.json")+ monkeypatch.setattr(daemon_cmd, "DEFAULT_CONFIG_DIR", tmp_path)+ return tmp_path+++def test_write_pid_records_bound_address(state_dir):+ daemon_cmd._write_pid(4321, "127.0.0.1", 8899)+ assert daemon_cmd._read_state() == {+ "pid": 4321,+ "host": "127.0.0.1",+ "port": 8899,+ }+++def test_bound_address_prefers_recorded_over_config(state_dir):+ daemon_cmd._write_pid(4321, "127.0.0.1", 8899)+ host, port = daemon_cmd._bound_address()+ assert (host, port) == ("127.0.0.1", 8899)+++def test_bound_address_falls_back_to_config(state_dir):+ from openjarvis.core.config import load_config++ config = load_config()+ host, port = daemon_cmd._bound_address()+ assert (host, port) == (config.server.host, int(config.server.port))+++def test_read_state_tolerates_corrupt_file(state_dir):+ (state_dir / "server.json").write_text("{not json")+ assert daemon_cmd._read_state() == {}+++def test_read_state_rejects_non_mapping(state_dir):+ (state_dir / "server.json").write_text(json.dumps([1, 2, 3]))+ assert daemon_cmd._read_state() == {}+++def test_record_server_state_makes_status_findable(state_dir):+ """A launchd-supervised `serve` never calls `start`; it must still register."""+ daemon_cmd.record_server_state(999, "127.0.0.1", 8899)+ assert daemon_cmd._read_state()["port"] == 8899+++def test_clear_server_state_only_removes_own_entry(state_dir):+ daemon_cmd.record_server_state(999, "127.0.0.1", 8899)+ daemon_cmd.clear_server_state(1234) # a different process+ assert daemon_cmd._read_state()["pid"] == 999+ daemon_cmd.clear_server_state(999)+ assert daemon_cmd._read_state() == {}+++def test_old_cleanup_preserves_new_pid_when_legacy_files_disagree(state_dir):+ daemon_cmd.record_server_state(999, "127.0.0.1", 8899)+ (state_dir / "server.pid").write_text("1234")++ daemon_cmd.clear_server_state(999)++ assert (state_dir / "server.pid").read_text() == "1234"+ assert not (state_dir / "server.json").exists()+++def test_old_cleanup_preserves_new_address_when_legacy_files_disagree(state_dir):+ daemon_cmd.record_server_state(1234, "127.0.0.1", 8899)+ (state_dir / "server.pid").write_text("999")++ daemon_cmd.clear_server_state(999)++ assert daemon_cmd._read_state()["pid"] == 1234+ assert not (state_dir / "server.pid").exists()+++def test_stale_address_is_not_used_for_another_pid(state_dir, monkeypatch):+ daemon_cmd.record_server_state(999, "127.0.0.1", 8899)+ (state_dir / "server.pid").write_text("1234")+ config = daemon_cmd.load_config()+ monkeypatch.setattr(daemon_cmd, "load_config", lambda: config)++ assert daemon_cmd._bound_address(1234) == (+ config.server.host,+ int(config.server.port),+ )++[email protected]("port", ["broken", True, -1, 65536, None])+def test_invalid_address_fields_are_ignored(state_dir, port):+ (state_dir / "server.json").write_text(+ json.dumps({"pid": 999, "host": "127.0.0.1", "port": port})+ )+ assert daemon_cmd._read_state() == {}+++def test_parent_cannot_replace_child_bound_port_with_requested_zero(state_dir):+ daemon_cmd.record_server_state(999, "127.0.0.1", 8899)++ daemon_cmd._write_pid(999, "127.0.0.1", 0, ready=False)++ assert daemon_cmd._read_state()["port"] == 8899+ assert daemon_cmd._read_state().get("ready", True)+++def test_pending_start_does_not_claim_an_address_is_listening(state_dir, monkeypatch):+ daemon_cmd._write_pid(999, "127.0.0.1", 0, ready=False)+ monkeypatch.setattr(daemon_cmd, "_pid_alive", lambda pid: True)++ result = CliRunner().invoke(daemon_cmd.status)++ assert result.exit_code == 0+ assert "Server is starting" in result.output+ assert "URL:" not in result.output+++def test_restart_passes_the_recorded_address_to_start(state_dir, monkeypatch):+ daemon_cmd.record_server_state(999, "127.0.0.1", 8899)+ monkeypatch.setattr(daemon_cmd, "_pid_alive", lambda pid: True)+ started = []+ monkeypatch.setattr(daemon_cmd.stop, "callback", lambda: None)+ monkeypatch.setattr(+ daemon_cmd.start, "callback", lambda **params: started.append(params)+ )++ result = CliRunner().invoke(daemon_cmd.restart)++ assert result.exit_code == 0+ assert started[0]["host"] == "127.0.0.1"+ assert started[0]["port"] == 8899+++def test_cleanup_waits_for_in_progress_registration(state_dir, monkeypatch):+ daemon_cmd.record_server_state(999, "127.0.0.1", 8899)+ monkeypatch.setattr(daemon_cmd, "_pid_alive", lambda pid: False)+ write_started, release_write, cleared = (+ threading.Event(),+ threading.Event(),+ threading.Event(),+ )+ write_json = daemon_cmd.secure_write_json++ def blocked_write(path, value):+ write_started.set()+ assert release_write.wait(5)+ write_json(path, value)++ def clear_old():+ daemon_cmd.clear_server_state(999)+ cleared.set()++ monkeypatch.setattr(daemon_cmd, "secure_write_json", blocked_write)+ writer = threading.Thread(+ target=daemon_cmd.record_server_state, args=(1234, "127.0.0.1", 8900)+ )+ cleanup = threading.Thread(target=clear_old)+ writer.start()+ try:+ assert write_started.wait(5)+ cleanup.start()+ assert not cleared.wait(0.05)+ finally:+ release_write.set()+ writer.join(5)+ if cleanup.ident is not None:+ cleanup.join(5)++ assert not writer.is_alive()+ assert not cleanup.is_alive()+ assert daemon_cmd._read_state()["pid"] == 1234+ assert (state_dir / "server.pid").read_text() == "1234"diff --git a/tests/cli/test_serve_persona.py b/tests/cli/test_serve_persona.pyindex e64e2c62..a4eee0d8 100644--- a/tests/cli/test_serve_persona.py+++ b/tests/cli/test_serve_persona.py@@ -106,7 +106,7 @@ def test_serve_wires_persona_builder_into_served_agent(with (patch("openjarvis.server.app.create_app", side_effect=_capture_create_app),- patch("uvicorn.run", lambda *a, **k: None),+ patch("openjarvis.server.daemon.run_server", lambda *a, **k: None),):result = CliRunner().invoke(cli, ["serve", "--agent", agent_name], catch_exceptions=Falsediff --git a/tests/cli/test_serve_single_build.py b/tests/cli/test_serve_single_build.pyindex 0453d49c..aadf3af9 100644--- a/tests/cli/test_serve_single_build.py+++ b/tests/cli/test_serve_single_build.py@@ -98,7 +98,7 @@ def _run_serve(tmp_path, monkeypatch, *, build_spy, set_system_spy):"""Invoke ``jarvis serve`` with all heavy/blocking pieces stubbed out.Returns the CliRunner result. The server is never actually started- (``uvicorn.run`` is a no-op) and no real engine is contacted.+ (``run_server`` is a no-op) and no real engine is contacted."""from openjarvis.core.config import JarvisConfigfrom openjarvis.core.registry import MemoryRegistry@@ -159,7 +159,7 @@ def _run_serve(tmp_path, monkeypatch, *, build_spy, set_system_spy):"openjarvis.agents.executor.AgentExecutor.set_system",set_system_spy,),- patch("uvicorn.run", lambda *a, **k: None),+ patch("openjarvis.server.daemon.run_server", lambda *a, **k: None),):return CliRunner().invoke(cli, ["serve"], catch_exceptions=False)diff --git a/tests/server/test_daemon_lifecycle.py b/tests/server/test_daemon_lifecycle.pynew file mode 100644index 00000000..99ecd026--- /dev/null+++ b/tests/server/test_daemon_lifecycle.py@@ -0,0 +1,81 @@+"""Exercise daemon state against real Uvicorn bind and shutdown behavior."""++from __future__ import annotations++import socket+from contextlib import asynccontextmanager++import httpx+import pytest+from fastapi import FastAPI++from openjarvis.cli import daemon_cmd+from openjarvis.server.daemon import DaemonServer, run_server+++def state_dir(tmp_path, monkeypatch):+ monkeypatch.setattr(daemon_cmd, "_PID_FILE", tmp_path / "server.pid")+ monkeypatch.setattr(daemon_cmd, "_STATE_FILE", tmp_path / "server.json")+ monkeypatch.setattr(daemon_cmd, "DEFAULT_CONFIG_DIR", tmp_path)+ return tmp_path+++def test_ephemeral_port_is_registered_after_startup_and_cleared(state_dir, monkeypatch):+ @asynccontextmanager+ async def lifespan(app):+ assert daemon_cmd._read_state() == {}+ yield++ app = FastAPI(lifespan=lifespan)++ @app.get("/health")+ def health():+ return {"status": "ok"}++ observed = []++ async def verify_running(self):+ state = daemon_cmd._read_state()+ assert state["host"] == "127.0.0.1"+ assert state["port"] > 0+ observed.append(state)+ async with httpx.AsyncClient(trust_env=False) as client:+ response = await client.get(f"http://127.0.0.1:{state['port']}/health")+ assert response.json() == {"status": "ok"}++ monkeypatch.setattr(DaemonServer, "main_loop", verify_running)+ run_server(app, host="127.0.0.1", port=0, log_level="error")++ assert len(observed) == 1+ assert daemon_cmd._read_state() == {}+ assert not (state_dir / "server.pid").exists()+++def test_failed_bind_does_not_overwrite_an_existing_server(state_dir):+ daemon_cmd.record_server_state(999999, "127.0.0.1", 8899)+ before = (state_dir / "server.json").read_bytes()+ with socket.socket() as occupied:+ occupied.bind(("127.0.0.1", 0))+ occupied.listen()+ with pytest.raises(SystemExit):+ run_server(+ FastAPI(),+ host="127.0.0.1",+ port=occupied.getsockname()[1],+ log_level="error",+ )++ assert (state_dir / "server.json").read_bytes() == before+ assert (state_dir / "server.pid").read_text() == "999999"+++def test_second_live_server_cannot_replace_registered_owner(state_dir, monkeypatch):+ daemon_cmd.record_server_state(999999, "127.0.0.1", 8899)+ monkeypatch.setattr(daemon_cmd, "_pid_alive", lambda pid: True)++ with pytest.raises(RuntimeError, match="already registered"):+ run_server(FastAPI(), host="127.0.0.1", port=0, log_level="error")++ assert daemon_cmd._read_state()["pid"] == 999999+ assert (state_dir / "server.pid").read_text() == "999999"