Fix runtime logging and frontend app regressions

backend/api/runtime.py

@@ -38,12 +38,13 @@ class RuntimeState:
     """
 
     _instance: Optional["RuntimeState"] = None
-    _lock: asyncio.Lock = asyncio.Lock()
+    _lock: "threading.Lock" = __import__("threading").Lock()
 
     def __new__(cls) -> "RuntimeState":
-        if cls._instance is None:
-            cls._instance = super().__new__(cls)
-            cls._instance._initialized = False
+        with cls._lock:
+            if cls._instance is None:
+                cls._instance = super().__new__(cls)
+                cls._instance._initialized = False
         return cls._instance
 
     def __init__(self) -> None:
@@ -207,6 +208,13 @@ class RuntimeConfigResponse(BaseModel):
     resolved: Dict[str, Any]
 
 
+class RuntimeLogResponse(BaseModel):
+    run_id: Optional[str] = None
+    is_running: bool
+    log_path: Optional[str] = None
+    content: str = ""
+
+
 class UpdateRuntimeConfigRequest(BaseModel):
     schedule_mode: Optional[str] = None
     interval_minutes: Optional[int] = Field(default=None, ge=1)
@@ -288,14 +296,20 @@ def _start_gateway_process(
         "--bootstrap", json.dumps(bootstrap)
     ]
 
-    # Start process
-    process = subprocess.Popen(
-        cmd,
-        env=env,
-        stdout=subprocess.PIPE,
-        stderr=subprocess.PIPE,
-        cwd=PROJECT_ROOT
-    )
+    log_path = run_dir / "logs" / "gateway.log"
+    log_path.parent.mkdir(parents=True, exist_ok=True)
+
+    log_file = log_path.open("ab")
+    try:
+        process = subprocess.Popen(
+            cmd,
+            env=env,
+            stdout=log_file,
+            stderr=subprocess.STDOUT,
+            cwd=PROJECT_ROOT
+        )
+    finally:
+        log_file.close()
 
     return process
 
@@ -390,6 +404,26 @@ async def get_gateway_port(request: Request) -> Dict[str, Any]:
     }
 
 
+@router.get("/logs", response_model=RuntimeLogResponse)
+async def get_runtime_logs() -> RuntimeLogResponse:
+    """Return current runtime log tail, or the latest run log if runtime is stopped."""
+    try:
+        context = _get_runtime_context_from_latest_snapshot()
+    except HTTPException:
+        return RuntimeLogResponse(is_running=False, content="")
+
+    run_id = str(context.get("config_name") or "").strip() or None
+    log_path = _get_gateway_log_path_for_run(run_id) if run_id else None
+    content = _read_log_tail(log_path) if log_path else ""
+
+    return RuntimeLogResponse(
+        run_id=run_id,
+        is_running=_is_gateway_running(),
+        log_path=str(log_path) if log_path else None,
+        content=content,
+    )
+
+
 def _build_gateway_ws_url(request: Request, port: int) -> str:
     """Build a proxy-safe Gateway WebSocket URL."""
     forwarded_proto = request.headers.get("x-forwarded-proto", "").split(",")[0].strip()
@@ -416,10 +450,8 @@ def _load_latest_runtime_snapshot() -> Dict[str, Any]:
     return json.loads(snapshots[0].read_text(encoding="utf-8"))
 
 
-def _get_current_runtime_context() -> Dict[str, Any]:
-    """Return the active runtime context from the latest snapshot."""
-    if not _is_gateway_running():
-        raise HTTPException(status_code=404, detail="No runtime is currently running")
+def _get_runtime_context_from_latest_snapshot() -> Dict[str, Any]:
+    """Return the latest persisted runtime context regardless of active process state."""
     latest = _load_latest_runtime_snapshot()
     context = latest.get("context") or {}
     if not context.get("config_name"):
@@ -427,6 +459,26 @@ def _get_current_runtime_context() -> Dict[str, Any]:
     return context
 
 
+def _get_gateway_log_path_for_run(run_id: str) -> Path:
+    return _get_run_dir(run_id) / "logs" / "gateway.log"
+
+
+def _read_log_tail(path: Path, max_chars: int = 120_000) -> str:
+    if not path.exists() or not path.is_file():
+        return ""
+    text = path.read_text(encoding="utf-8", errors="replace")
+    if len(text) <= max_chars:
+        return text
+    return text[-max_chars:]
+
+
+def _get_current_runtime_context() -> Dict[str, Any]:
+    """Return the active runtime context from the latest snapshot."""
+    if not _is_gateway_running():
+        raise HTTPException(status_code=404, detail="No runtime is currently running")
+    return _get_runtime_context_from_latest_snapshot()
+
+
 def _resolve_runtime_response(run_id: str) -> RuntimeConfigResponse:
     """Build a normalized runtime config response for the active run."""
     context = _get_current_runtime_context()
@@ -567,11 +619,12 @@ async def start_runtime(
         await asyncio.sleep(2)
 
         if not _is_gateway_running():
-            stdout, stderr = process.communicate(timeout=1)
             _runtime_state.gateway_process = None
+            log_path = _get_gateway_log_path_for_run(run_id)
+            log_tail = _read_log_tail(log_path, max_chars=4000)
             raise HTTPException(
                 status_code=500,
-                detail=f"Gateway failed to start: {stderr.decode() if stderr else 'Unknown error'}"
+                detail=f"Gateway failed to start: {log_tail or 'Unknown error'}"
             )
 
     except Exception as e: