Your lightweight open-source personal agent.
Python agent-frameworkai-agentai-agentschatbotchatopsdiscord-botllm-agentsllmslocal-llmmcpmodel-context-protocolmulti-agentopenai-compatibleopenclawpersonal-ai-assistantpythonself-hostedtelegram-bot-ai-assistantwebuiworkflow-automation
fix(gateway): preserve runtime identity compatibility
Xubin Ren99d5fa2908a1
diff --git a/nanobot/gateway/runtime.py b/nanobot/gateway/runtime.pyindex aaafca62f..828c2f604 100644--- a/nanobot/gateway/runtime.py+++ b/nanobot/gateway/runtime.py@@ -28,6 +28,7 @@ from nanobot.process_runtime import (ProcessRuntimePaths,ProcessStartOptions,ProcessStatus,+ process_identity_record,process_is_running,)@@ -300,7 +301,6 @@ class GatewayRuntime(ManagedProcessRuntime[ProcessStartOptions]):state.update({"pid": pid,- "identity": self._process_identity(pid),"started_at": datetime.now(UTC).isoformat(),"platform": self.platform_name,"port": options.port,@@ -311,6 +311,8 @@ class GatewayRuntime(ManagedProcessRuntime[ProcessStartOptions]):"launch_mode": launch_mode,})+ state.pop("stable_identity", None)+ state.update(self.process_identity_record(pid))self._write_state(state)if launch_mode == "foreground":lease._try_mark_persistent_locked()@@ -513,11 +515,12 @@ class GatewayClientLease:def _register(self, state: dict[str, object]) -> None:clients = self._clients(state)- clients[self.token] = {+ record: dict[str, object] = {"pid": self.pid,"kind": self.kind,- "identity": self._process_identity(self.pid),}+ record.update(process_identity_record(self._process_identity(self.pid), lease=True))+ clients[self.token] = recordself._write_state(state)self._acquired = True@@ -531,7 +534,9 @@ class GatewayClientLease:continuerecord = cast(dict[str, object], value)pid = record.get("pid")- identity = record.get("identity")+ identity = record.get("stable_identity")+ if identity is None:+ identity = record.get("identity")if not isinstance(pid, int) or not self._process_is_running(pid):stale.append(token)continuediff --git a/nanobot/process_runtime.py b/nanobot/process_runtime.pyindex 5b7233434..359fed8a6 100644--- a/nanobot/process_runtime.py+++ b/nanobot/process_runtime.py@@ -107,7 +107,8 @@ class ManagedProcessRuntime(Generic[_StartOptionsT]):returnstate["pid"] = os.getpid()runtime = cls(paths=paths)- state["identity"] = runtime._process_identity(os.getpid())+ state.pop("stable_identity", None)+ state.update(runtime.process_identity_record(os.getpid()))state["started_at"] = _utc_now()runtime._write_state(state)@@ -140,19 +141,18 @@ class ManagedProcessRuntime(Generic[_StartOptionsT]):if not self._is_pid_running(pid):return ProcessResult(False, self._message("exited_during_startup"), self.status())- self._write_state(- {- "pid": pid,- "identity": self._process_identity(pid),- "started_at": _utc_now(),- "platform": self.platform_name,- "port": options.port,- "workspace": options.workspace,- "config_path": options.config_path,- "command": command,- "log_path": str(self.paths.log_path),- }- )+ state: dict[str, object] = {+ "pid": pid,+ "started_at": _utc_now(),+ "platform": self.platform_name,+ "port": options.port,+ "workspace": options.workspace,+ "config_path": options.config_path,+ "command": command,+ "log_path": str(self.paths.log_path),+ }+ state.update(self.process_identity_record(pid))+ self._write_state(state)return ProcessResult(True, self._message("started_background"), self.status())def stop(self, *, timeout_s: int = 20) -> ProcessResult:@@ -273,6 +273,15 @@ class ManagedProcessRuntime(Generic[_StartOptionsT]):"""Return an identity that changes when an operating-system PID is reused."""return self._process_identity(pid)+ def process_identity_record(+ self,+ pid: int,+ *,+ lease: bool = False,+ ) -> dict[str, str | int | None]:+ """Serialize an identity without breaking pre-upgrade macOS readers."""+ return process_identity_record(self._process_identity(pid), lease=lease)+def process_identity_match(self,recorded: object,@@ -436,7 +445,9 @@ class ManagedProcessRuntime(Generic[_StartOptionsT]):) -> Literal["match", "mismatch", "unknown"]:if not state:return "mismatch"- recorded = state.get("identity")+ recorded = state.get("stable_identity")+ if recorded is None:+ recorded = state.get("identity")return self.process_identity_match(recorded, pid)def _read_state(self) -> dict[str, Any] | None:@@ -549,13 +560,14 @@ def _darwin_identity_match("""Compare the new numeric identity with a pre-upgrade ``ps`` identity."""if not isinstance(recorded, str) or not isinstance(current, str):return "mismatch"- current_match = re.fullmatch(r"darwin:(\d+):(\d+):(\d+)", current)- if current_match is None:+ current_identity = _parse_darwin_identity(current)+ if current_identity is None:return "mismatch"+ current_group, current_seconds, _ = current_identityrecorded_group, separator, recorded_started_at = recorded.partition(":")if not separator or not recorded_group.isdigit():return "mismatch"- if int(recorded_group) != int(current_match.group(1)):+ if int(recorded_group) != current_group:return "mismatch"legacy_epoch = _legacy_darwin_started_at(recorded_started_at)if legacy_epoch is None:@@ -563,7 +575,35 @@ def _darwin_identity_match(# locale produced a date we cannot safely parse. Keep the record until# the owning client exits instead of killing a live gateway.return "unknown"- return "match" if legacy_epoch == int(current_match.group(2)) else "mismatch"+ return "match" if legacy_epoch == current_seconds else "mismatch"+++def _parse_darwin_identity(value: object) -> tuple[int, int, int] | None:+ if not isinstance(value, str):+ return None+ match = re.fullmatch(r"darwin:(\d+):(\d+):(\d+)", value)+ if match is None:+ return None+ return int(match.group(1)), int(match.group(2)), int(match.group(3))+++def process_identity_record(+ identity: str | int | None,+ *,+ lease: bool = False,+) -> dict[str, str | int | None]:+ """Serialize an identity without breaking pre-upgrade macOS readers."""+ darwin = _parse_darwin_identity(identity)+ if darwin is None:+ return {"identity": identity}+ process_group, _, _ = darwin+ # Old process-state readers understand a PGID-only integer. Old lease+ # readers raw-compare identities, so ``None`` asks them to rely on the+ # still-live PID while upgraded readers use the stable native value.+ return {+ "identity": None if lease else process_group,+ "stable_identity": identity,+ }def _legacy_darwin_started_at(value: str) -> int | None:@@ -603,7 +643,7 @@ def _legacy_darwin_started_at(value: str) -> int | None:month, day, hour, minute, second, year = map(int, numeric.groups())try:return int(time.mktime((year, month, day, hour, minute, second, -1, -1, -1)))- except (OverflowError, ValueError):+ except (OSError, OverflowError, ValueError):return Nonediff --git a/tests/gateway/test_runtime.py b/tests/gateway/test_runtime.pyindex 484ceb8e3..01059154b 100644--- a/tests/gateway/test_runtime.py+++ b/tests/gateway/test_runtime.py@@ -660,6 +660,28 @@ def test_lease_snapshot_keeps_a_legacy_localized_darwin_client(tmp_path, monkeypassert snapshot.clients == 1+def test_darwin_lease_keeps_old_readers_compatible_and_detects_pid_reuse(+ tmp_path,+ monkeypatch,+):+ runtime = GatewayRuntime(paths=_paths(tmp_path), platform_name="Darwin")+ identity = "darwin:42:1786992348:123456"+ monkeypatch.setattr(runtime, "_is_pid_running", lambda _pid: True)+ monkeypatch.setattr(runtime, "_process_identity", lambda _pid: identity)+ client = GatewayClientLease(runtime, kind="tui", pid=12345, token="client")++ client.acquire()+ client.mark_ephemeral()+ state = json.loads(client.state_path.read_text(encoding="utf-8"))+ record = state["clients"]["client"]++ assert record["identity"] is None # Pre-upgrade lease readers keep the live PID.+ assert record["stable_identity"] == identity++ identity = "darwin:42:1786992348:654321"+ assert client.snapshot().clients == 0++def test_lease_snapshot_keeps_a_client_when_identity_probe_is_unavailable(tmp_path,monkeypatch,@@ -925,16 +947,74 @@ def test_darwin_process_identity_is_locale_independent(tmp_path, monkeypatch):)monkeypatch.setenv("LANG", "zh_CN.UTF-8")monkeypatch.setenv("LC_ALL", "zh_CN.UTF-8")+ monkeypatch.setattr("nanobot.process_runtime._platform_name", lambda: "Darwin")started_at = int(time.mktime((2026, 8, 18, 2, 17, 54, -1, -1, -1)))monkeypatch.setattr("nanobot.process_runtime._darwin_process_birth",lambda _pid: (42, started_at, 123456),)- assert runtime.process_identity(12345) == f"darwin:42:{started_at}:123456"+ identity = f"darwin:42:{started_at}:123456"+ assert runtime.process_identity(12345) == identity+ assert runtime.process_identity_record(12345) == {+ "identity": 42,+ "stable_identity": identity,+ }assert runtime._record_matches_process({"identity": 42}, 12345) is True+def test_darwin_status_discovers_a_legacy_localized_state(tmp_path, monkeypatch):+ runtime = GatewayRuntime(paths=_paths(tmp_path), platform_name="Darwin")+ started_at = int(time.mktime((2026, 8, 18, 2, 17, 54, -1, -1, -1)))+ runtime.paths.run_dir.mkdir(parents=True)+ runtime.paths.state_path.write_text(+ '{"pid": 12345, "identity": "42:二 8/18 02:17:54 2026"}',+ encoding="utf-8",+ )+ monkeypatch.setattr(runtime, "_is_pid_running", lambda _pid: True)+ monkeypatch.setattr(+ runtime,+ "_process_identity",+ lambda _pid: f"darwin:42:{started_at}:123456",+ )++ status = runtime.status()++ assert status.running is True+ assert status.reason == "running"+ assert runtime.paths.state_path.exists()+++def test_darwin_status_prefers_stable_identity_over_compatibility_pgid(+ tmp_path,+ monkeypatch,+):+ runtime = GatewayRuntime(paths=_paths(tmp_path), platform_name="Darwin")+ runtime.paths.run_dir.mkdir(parents=True)+ runtime.paths.state_path.write_text(+ json.dumps(+ {+ "pid": 12345,+ "identity": 42,+ "stable_identity": "darwin:42:1786992348:123456",+ }+ ),+ encoding="utf-8",+ )+ monkeypatch.setattr(runtime, "_is_pid_running", lambda _pid: True)+ monkeypatch.setattr(+ runtime,+ "_process_identity",+ lambda _pid: "darwin:42:1786992348:654321",+ )++ status = runtime.status()++ assert status.running is False+ assert status.reason == "stale_state"+ assert not runtime.paths.state_path.exists()++@pytest.mark.skipif(sys.platform != "darwin", reason="requires macOS proc_pidinfo")def test_darwin_live_process_identity_is_stable(tmp_path):runtime = GatewayRuntime(paths=_paths(tmp_path), platform_name="Darwin")