Skip to content

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.py
index 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 os
import subprocess
import sys
import time
+from contextlib import contextmanager
+from typing import Iterator
import click
from rich.console import Console
from openjarvis.core.config import DEFAULT_CONFIG_DIR, load_config
from 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 serve
cmd = [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 exc
console.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 info
uptime_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.py
index 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 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
# Set up engine
register_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.py
new file mode 100644
index 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.py
new file mode 100644
index 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.py
index 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=False
diff --git a/tests/cli/test_serve_single_build.py b/tests/cli/test_serve_single_build.py
index 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 JarvisConfig
from 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.py
new file mode 100644
index 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"