Add SystemTest Agent and Controller

SystemTest-Agent/app/model_config.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+import json
+import subprocess
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Any
+
+
+def utc_now() -> str:
+    return datetime.now(timezone.utc).isoformat(timespec="seconds")
+
+
+def _load_json(path: Path, default: dict[str, Any]) -> dict[str, Any]:
+    if not path.exists():
+        return default
+    try:
+        data = json.loads(path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError:
+        return default
+    return data if isinstance(data, dict) else default
+
+
+def _save_json(path: Path, payload: dict[str, Any]) -> None:
+    path.parent.mkdir(parents=True, exist_ok=True)
+    path.write_text(json.dumps(payload, ensure_ascii=False, indent=2, sort_keys=True), encoding="utf-8")
+
+
+def load_applied_model_config(path: Path) -> dict[str, Any]:
+    return _load_json(path, {"version": 0, "value": {}, "updated_at": None, "applied_at": None})
+
+
+def save_applied_model_config(path: Path, payload: dict[str, Any]) -> None:
+    _save_json(path, payload)
+
+
+def public_model_config_summary(config: dict[str, Any]) -> dict[str, Any]:
+    value = dict(config.get("value") or {})
+    value["api_key"] = ""
+    value["api_key_set"] = bool(value.get("api_key_set") or (config.get("value") or {}).get("api_key"))
+    return {
+        "version": int(config.get("version") or 0),
+        "updated_at": config.get("updated_at"),
+        "applied_at": config.get("applied_at"),
+        "value": value,
+    }
+
+
+class RuntimeRestartManager:
+    def __init__(self, path: Path, command: str = ""):
+        self.path = path
+        self.command = command.strip()
+        self.process: subprocess.Popen | None = None
+        self.state = _load_json(
+            path,
+            {
+                "generation": 0,
+                "last_restart_at": None,
+                "reason": "",
+                "model_config_version": 0,
+                "mode": "placeholder",
+            },
+        )
+
+    @property
+    def generation(self) -> int:
+        try:
+            return int(self.state.get("generation") or 0)
+        except (TypeError, ValueError):
+            return 0
+
+    def _start_process(self) -> int | None:
+        if not self.command:
+            return None
+        if self.process and self.process.poll() is None:
+            return self.process.pid
+        self.process = subprocess.Popen(
+            self.command,
+            cwd=str(self.path.parent.parent),
+            shell=True,
+            stdout=subprocess.DEVNULL,
+            stderr=subprocess.DEVNULL,
+        )
+        return self.process.pid
+
+    def stop(self) -> None:
+        if not self.process or self.process.poll() is not None:
+            return
+        self.process.terminate()
+        try:
+            self.process.wait(timeout=5)
+        except subprocess.TimeoutExpired:
+            self.process.kill()
+            self.process.wait(timeout=5)
+
+    def ensure_started(self, version: int) -> dict[str, Any] | None:
+        if not self.command:
+            return None
+        pid = self._start_process()
+        now = utc_now()
+        self.state = {
+            "generation": self.generation,
+            "last_restart_at": self.state.get("last_restart_at"),
+            "reason": self.state.get("reason") or "startup",
+            "model_config_version": version,
+            "mode": "subprocess",
+            "pid": pid,
+            "command_configured": True,
+            "checked_at": now,
+        }
+        _save_json(self.path, self.state)
+        return self.state
+
+    def restart_for_model_config(self, version: int) -> dict[str, Any]:
+        now = utc_now()
+        self.stop()
+        pid = self._start_process()
+        self.state = {
+            "generation": self.generation + 1,
+            "last_restart_at": now,
+            "reason": f"model_config_v{version}",
+            "model_config_version": version,
+            "mode": "subprocess" if self.command else "placeholder",
+            "pid": pid,
+            "command_configured": bool(self.command),
+        }
+        _save_json(self.path, self.state)
+        return self.state