Merge pull request #837 from gabsprogrammer/codex/settings-reliability-polish

fix(settings): harden loading and polish status view

Author: Lightheartdevs

dream-server/extensions/services/dashboard-api/main.py

@@ -15,8 +15,10 @@
 """
 
 import asyncio
+import json
 import logging
 import os
+import re
 import socket
 import shutil
 import time
@@ -28,7 +30,7 @@
 from fastapi.middleware.cors import CORSMiddleware
 
 # --- Local modules ---
-from config import SERVICES, DATA_DIR, SIDEBAR_ICONS, MANIFEST_ERRORS
+from config import SERVICES, DATA_DIR, INSTALL_DIR, SIDEBAR_ICONS, MANIFEST_ERRORS
 from models import (
     GPUInfo, ServiceStatus, DiskUsage, ModelInfo, BootstrapStatus,
     FullStatus, PortCheckRequest,
@@ -75,13 +77,181 @@ def set(self, key: str, value: object, ttl: float):
 _GPU_CACHE_TTL = 3.0
 _STATUS_CACHE_TTL = 2.0
 _STORAGE_CACHE_TTL = 30.0
+_SETTINGS_SUMMARY_CACHE_TTL = 5.0
 _SERVICE_POLL_INTERVAL = 10.0  # background health check interval
 
 # --- Router imports ---
 from routers import workflows, features, setup, updates, agents, privacy, extensions, gpu as gpu_router, resources
 
 logger = logging.getLogger(__name__)
 
+
+def _resolve_install_root() -> Path:
+    host_root = Path("/dream-server")
+    if host_root.exists():
+        return host_root
+    return Path(INSTALL_DIR)
+
+
+def _read_installed_version() -> str:
+    install_root = _resolve_install_root()
+    env_file = install_root / ".env"
+    if env_file.exists():
+        try:
+            for line in env_file.read_text().splitlines():
+                if line.startswith("DREAM_VERSION="):
+                    return line.split("=", 1)[1].strip().strip("\"'")
+        except OSError:
+            pass
+
+    version_file = install_root / ".version"
+    if version_file.exists():
+        try:
+            raw = version_file.read_text().strip()
+            if raw:
+                return raw
+        except OSError:
+            pass
+
+    manifest_file = install_root / "manifest.json"
+    if manifest_file.exists():
+        try:
+            data = json.loads(manifest_file.read_text())
+            version = (
+                data.get("release", {}).get("version")
+                or data.get("dream_version")
+                or data.get("manifestVersion")
+            )
+            if version:
+                return str(version)
+        except (OSError, json.JSONDecodeError, ValueError, AttributeError):
+            pass
+
+    return app.version
+
+
+def _normalize_timestamp_precision(timestamp: str) -> str:
+    match = re.match(r"^(.*?\.\d{6})\d+(.*)$", timestamp)
+    if match:
+        return f"{match.group(1)}{match.group(2)}"
+    return timestamp
+
+
+def _read_install_date() -> Optional[str]:
+    install_root = _resolve_install_root()
+    env_file = install_root / ".env"
+    if env_file.exists():
+        try:
+            for line in env_file.read_text(encoding="utf-8").splitlines()[:8]:
+                if line.startswith("# Generated by ") and " on " in line:
+                    raw_timestamp = line.split(" on ", 1)[1].strip()
+                    normalized = _normalize_timestamp_precision(raw_timestamp)
+                    try:
+                        return datetime.fromisoformat(normalized).isoformat()
+                    except ValueError:
+                        return raw_timestamp
+        except OSError:
+            pass
+
+    for candidate in (
+        env_file,
+        install_root / ".version",
+        install_root / "manifest.json",
+    ):
+        if candidate.exists():
+            try:
+                return datetime.fromtimestamp(candidate.stat().st_mtime, tz=timezone.utc).isoformat()
+            except OSError:
+                continue
+
+    return None
+
+
+def _infer_tier(gpu_info) -> str:
+    if not gpu_info:
+        return "Unknown"
+
+    vram_gb = gpu_info.memory_total_mb / 1024
+    if gpu_info.memory_type == "unified" and gpu_info.gpu_backend == "amd":
+        return "Strix Halo 90+" if vram_gb >= 90 else "Strix Halo Compact"
+    if vram_gb >= 80:
+        return "Professional"
+    if vram_gb >= 24:
+        return "Prosumer"
+    if vram_gb >= 16:
+        return "Standard"
+    if vram_gb >= 8:
+        return "Entry"
+    return "Minimal"
+
+
+def _serialize_gpu(gpu_info) -> Optional[dict]:
+    if not gpu_info:
+        return None
+
+    gpu_count = 1
+    gpu_count_env = os.environ.get("GPU_COUNT", "")
+    if gpu_count_env.isdigit():
+        gpu_count = int(gpu_count_env)
+    elif " × " in gpu_info.name:
+        try:
+            gpu_count = int(gpu_info.name.rsplit(" × ", 1)[-1])
+        except ValueError:
+            pass
+    elif " + " in gpu_info.name:
+        gpu_count = gpu_info.name.count(" + ") + 1
+
+    gpu_data = {
+        "name": gpu_info.name,
+        "vramUsed": round(gpu_info.memory_used_mb / 1024, 1),
+        "vramTotal": round(gpu_info.memory_total_mb / 1024, 1),
+        "utilization": gpu_info.utilization_percent,
+        "temperature": gpu_info.temperature_c,
+        "memoryType": gpu_info.memory_type,
+        "backend": gpu_info.gpu_backend,
+        "gpu_count": gpu_count,
+        "memoryLabel": "VRAM Partition" if gpu_info.memory_type == "unified" else "VRAM",
+    }
+    if gpu_info.power_w is not None:
+        gpu_data["powerDraw"] = gpu_info.power_w
+    return gpu_data
+
+
+def _serialize_model(model_info) -> Optional[dict]:
+    if not model_info:
+        return None
+    return {
+        "name": model_info.name,
+        "contextLength": model_info.context_length,
+    }
+
+
+def _serialize_services(service_statuses: list[ServiceStatus], uptime: int) -> list[dict]:
+    return [
+        {
+            "name": service.name,
+            "status": service.status,
+            "port": service.external_port,
+            "uptime": uptime if service.status == "healthy" else None,
+        }
+        for service in service_statuses
+    ]
+
+
+def _fallback_services() -> list[dict]:
+    links = []
+    for service_id, config in SERVICES.items():
+        external_port = config.get("external_port", config.get("port", 0))
+        if not external_port:
+            continue
+        links.append({
+            "name": config.get("name", service_id),
+            "status": "unknown",
+            "port": external_port,
+            "uptime": None,
+        })
+    return links
+
 # --- App ---
 
 app = FastAPI(
@@ -501,6 +671,48 @@ def _compute_storage():
     return result
 
 
+@app.get("/api/settings/summary")
+async def api_settings_summary(api_key: str = Depends(verify_api_key)):
+    """Fast settings payload that avoids slow live service probes on first load."""
+    cached = _cache.get("settings_summary")
+    if cached is not None:
+        return cached
+
+    gpu_info, model_info, uptime, cpu_metrics, ram_metrics = await asyncio.gather(
+        asyncio.to_thread(get_gpu_info),
+        asyncio.to_thread(get_model_info),
+        asyncio.to_thread(get_uptime),
+        asyncio.to_thread(get_cpu_metrics),
+        asyncio.to_thread(get_ram_metrics),
+    )
+
+    cached_services = get_cached_services()
+    services_data = (
+        _serialize_services(cached_services, uptime)
+        if cached_services is not None
+        else _fallback_services()
+    )
+
+    result = {
+        "version": _read_installed_version(),
+        "install_date": _read_install_date(),
+        "tier": _infer_tier(gpu_info),
+        "uptime": uptime,
+        "cpu": cpu_metrics,
+        "ram": ram_metrics,
+        "gpu": _serialize_gpu(gpu_info),
+        "model": _serialize_model(model_info),
+        "services": services_data,
+        "system": {
+            "uptime": uptime,
+            "hostname": os.environ.get("HOSTNAME", "dream-server"),
+        },
+        "manifest_errors": MANIFEST_ERRORS,
+    }
+    _cache.set("settings_summary", result, _SETTINGS_SUMMARY_CACHE_TTL)
+    return result
+
+
 # --- Service Health Polling ---
 
 async def _get_services() -> list[ServiceStatus]: