data.js
Rama main · réplica de lectura del repositorio original.
// AI-MONITOR · data layer
// Two interchangeable data sources behind one façade:
//
// window.AIData = { NODES, MODELS, live, totals, subscribe,
// setIntervalMs, pause, resume, mode, switchMode }
//
// mode · "mock" — local simulator (default; great for demos & dev)
// · "live" — subscribes to /api/stream (SSE) on the FastAPI backend
//
// Selection (in order):
// 1. ?mode=live or ?mode=mock in URL
// 2. localStorage("aim.mode")
// 3. auto-probe /api/health — if reachable, "live"; else "mock"
(() => {
// ── Static topology (matches the backend's NODES list) ──────────────
const NODES = [
{ id: "node-1", name: "Workstation", ip: "10.0.0.1", role: "Gateway · Edge", class: "GPU host",
os: "Ubuntu 24.04 LTS", kernel: "6.8.0-49", driver: "NVIDIA 560.35", cuda: "12.6",
gpu: { name: "GeForce RTX 4090", mem: 24, fp16: 165.2, fp4: 660.0 },
cpu: { model: "Ryzen 9 7950X", cores: 16, threads: 32 },
ram: 128, disk: 4096, net: "10 GbE",
services: ["litellm","vllm","ollama","comfyui","prometheus"] },
{ id: "node-2", name: "Inference-1", ip: "10.0.0.2", role: "Inference", class: "GPU node",
os: "Ubuntu 24.04 LTS (DGX OS)", kernel: "6.8.0-49", driver: "NVIDIA 560.40", cuda: "12.6",
gpu: { name: "GB10 Grace-Blackwell", mem: 128, fp16: 250.0, fp4: 1000.0 },
cpu: { model: "Grace 20-core ARM", cores: 20, threads: 20 },
ram: 128, disk: 4096, net: "200 GbE ConnectX-7",
services: ["vllm","node-exporter","dcgm"] },
{ id: "node-3", name: "Inference-2", ip: "10.0.0.3", role: "Inference", class: "GPU node",
os: "Ubuntu 24.04 LTS (DGX OS)", kernel: "6.8.0-49", driver: "NVIDIA 560.40", cuda: "12.6",
gpu: { name: "GB10 Grace-Blackwell", mem: 128, fp16: 250.0, fp4: 1000.0 },
cpu: { model: "Grace 20-core ARM", cores: 20, threads: 20 },
ram: 128, disk: 4096, net: "200 GbE ConnectX-7",
services: ["vllm","sglang","node-exporter","dcgm"] },
{ id: "node-4", name: "Inference-3", ip: "10.0.0.4", role: "Inference", class: "GPU node",
os: "Ubuntu 24.04 LTS (DGX OS)", kernel: "6.8.0-49", driver: "NVIDIA 560.40", cuda: "12.6",
gpu: { name: "GB10 Grace-Blackwell", mem: 128, fp16: 250.0, fp4: 1000.0 },
cpu: { model: "Grace 20-core ARM", cores: 20, threads: 20 },
ram: 128, disk: 4096, net: "200 GbE ConnectX-7",
services: ["vllm","node-exporter","dcgm"] },
{ id: "node-5", name: "Inference-4", ip: "10.0.0.5", role: "Inference", class: "GPU node",
os: "Ubuntu 24.04 LTS (DGX OS)", kernel: "6.8.0-49", driver: "NVIDIA 560.40", cuda: "12.6",
gpu: { name: "GB10 Grace-Blackwell", mem: 128, fp16: 250.0, fp4: 1000.0 },
cpu: { model: "Grace 20-core ARM", cores: 20, threads: 20 },
ram: 128, disk: 4096, net: "200 GbE ConnectX-7",
services: ["vllm","node-exporter","dcgm"] },
];
// 真实模型（镜像后端 MODEL_CATALOG / litellm /v1/models · comfyui mode）。
// metricsSource: "vllm" 有真实 vLLM 指标；"none" = llama.cpp/停用，诚实无实时指标。
const MODELS_CATALOG = [
{ id: "qwen3-coder", display: "Qwen3-Coder-Next", vendor: "Alibaba", kind: "chat",
params: "Coder-Next", quant: "FP8", ctx: 262144, framework: "vLLM", port: 8888,
route: "litellm/qwen3-coder-next", nodes: ["node-4","node-5"], vram: 0,
metricsSource: "vllm", state: "idle", tps: 0, ttft: 0, tpot: 0, rps: 0, kv: 0,
p50: 0, p95: 0, p99: 0, err: 0, tags: ["coding","2xSpark","resident"] },
{ id: "deepseek-v4-flash", display: "DeepSeek-V4-Flash", vendor: "DeepSeek", kind: "chat",
params: "—", quant: "—", ctx: 262144, framework: "vLLM", port: 8000,
route: "litellm/deepseek-v4-flash", nodes: ["node-3"], vram: 0,
metricsSource: "vllm", state: "no-metrics", tps: 0, ttft: 0, tpot: 0, rps: 0, kv: 0,
p50: 0, p95: 0, p99: 0, err: 0, tags: ["reasoning","stopped"] },
{ id: "gemma-4-31b-abliterated", display: "Gemma-4-31B-abliterated", vendor: "Google", kind: "vision",
params: "31B", quant: "Q8 GGUF", ctx: 32768, framework: "llama.cpp", port: 8001,
route: "litellm/gemma-4-31b-abliterated", nodes: ["node-3"], vram: 0,
metricsSource: "none", state: "no-metrics", tps: 0, ttft: 0, tpot: 0, rps: 0, kv: 0,
p50: 0, p95: 0, p99: 0, err: 0, tags: ["vision","abliterated"] },
{ id: "qwen3-vl-abliterated", display: "Qwen3-VL-8B-abliterated", vendor: "Alibaba", kind: "vision",
params: "8B", quant: "Q8 GGUF", ctx: 32768, framework: "llama.cpp", port: 8002,
route: "litellm/qwen3-vl-abliterated", nodes: ["node-3"], vram: 0,
metricsSource: "none", state: "no-metrics", tps: 0, ttft: 0, tpot: 0, rps: 0, kv: 0,
p50: 0, p95: 0, p99: 0, err: 0, tags: ["vision","scoring"] },
];
const HIST = 60; // history points retained on the cluster pulse cards
const SPARK = 32;
// ── Shared live state · single instance, mutated in place ───────────
// Consumers (Nav, Hero, sections) destructure `window.AIData.live` once,
// so the reference must be stable. We never reassign `live`; instead we
// wipe and re-populate its fields when switching data sources.
const live = {
nodes: {}, models: {}, nodeMeta: {},
cluster: {
tps: [], rps: [], kv: [], pow: [], temp: [],
tpsNow: 0, rpsNow: 0, kvNow: 0, powNow: 0, tempNow: 0,
reqTotal: 0, tokTotal: 0, latP50: 0, latP95: 0, uptimeSec: 0,
},
log: [], alerts: [],
// 训练可观测性(Phase 1 纯 obs 底座);trainingHist 驱动 sparkline
training: { nodes: [], summary: {} },
trainingHist: { util: [], roce: [] },
};
function makeNodeMetrics() {
const empty = () => ({ now: 0, hist: Array(HIST).fill(0) });
return {
up: true, // 真实在线状态(live 模式由后端 up 覆盖; mock 默认在线)
gpu: empty(), vram: empty(), cpu: empty(), mem: empty(),
power: empty(), tempGpu: empty(), tempCpu: empty(),
fan: empty(), disk: empty(), netIn: empty(), netOut: empty(),
smActivity: empty(), pcie: empty(),
rdmaIn: empty(), rdmaOut: empty(),
};
}
function makeModelMetrics() {
const empty = () => ({ now: 0, hist: Array(SPARK).fill(0) });
return { tps: empty(), ttft: empty(), tpot: empty(), rps: empty(), kv: empty(),
running: empty(), waiting: empty() };
}
function resetLive() {
// wipe & reinitialize all keys in place — preserves the `live` reference
for (const k of Object.keys(live.nodes)) delete live.nodes[k];
for (const k of Object.keys(live.models)) delete live.models[k];
for (const k of Object.keys(live.nodeMeta)) delete live.nodeMeta[k];
NODES.forEach((n) => { live.nodes[n.id] = makeNodeMetrics(); live.nodeMeta[n.id] = { temps: [], fans: [] }; });
MODELS.forEach((m) => { live.models[m.id] = makeModelMetrics(); });
Object.assign(live.cluster, {
tps: [], rps: [], kv: [], pow: [], temp: [],
tpsNow: 0, rpsNow: 0, kvNow: 0, powNow: 0, tempNow: 0,
reqTotal: 0, tokTotal: 0, latP50: 0, latP95: 0, uptimeSec: 0,
});
live.log.length = 0;
live.alerts.length = 0;
}
const totals = (() => {
const totalVram = NODES.reduce((a, n) => a + n.gpu.mem, 0);
const totalRam = NODES.reduce((a, n) => a + n.ram, 0);
const totalCores = NODES.reduce((a, n) => a + n.cpu.cores, 0);
const totalThreads= NODES.reduce((a, n) => a + n.cpu.threads, 0);
const totalDisk = NODES.reduce((a, n) => a + n.disk, 0);
const totalFp16 = NODES.reduce((a, n) => a + n.gpu.fp16, 0);
const totalFp4 = NODES.reduce((a, n) => a + n.gpu.fp4, 0);
return { totalVram, totalRam, totalCores, totalThreads, totalDisk,
totalFp16, totalFp4, pflopsFp4: totalFp4 / 1000,
nodes: NODES.length, gpus: NODES.length, models: MODELS_CATALOG.length,
serving: MODELS_CATALOG.filter((m) => m.state === "serving").length };
})();
// ── Subscriber bus ──────────────────────────────────────────────────
const subs = new Set();
const emit = () => subs.forEach((fn) => fn());
const subscribe = (fn) => { subs.add(fn); return () => subs.delete(fn); };
// ── State ───────────────────────────────────────────────────────────
let MODELS = [...MODELS_CATALOG];
let mode = "mock";
let intervalMs = 1200;
let mockTimer = null;
let sse = null;
let connStatus = "init"; // init|connecting|live|mock|reconnecting|error
let running = true;
// First-time structure init
NODES.forEach((n) => { live.nodes[n.id] = makeNodeMetrics(); live.nodeMeta[n.id] = { temps: [], fans: [] }; });
MODELS.forEach((m) => { live.models[m.id] = makeModelMetrics(); });
// ── Mock simulator (same logic as the original v0 prototype) ────────
const liveSeeds = {
"node-1": { gpu: 62, vram: 78, cpu: 41, mem: 58, power: 312, tempGpu: 64, tempCpu: 58, fan: 47, disk: 38, netIn: 220, netOut: 180 },
"node-2": { gpu: 78, vram: 64, cpu: 36, mem: 72, power: 168, tempGpu: 62, tempCpu: 55, fan: 38, disk: 22, netIn: 540, netOut: 510 },
"node-3": { gpu: 84, vram: 68, cpu: 44, mem: 76, power: 175, tempGpu: 66, tempCpu: 57, fan: 41, disk: 19, netIn: 480, netOut: 460 },
"node-4": { gpu: 21, vram: 14, cpu: 12, mem: 22, power: 68, tempGpu: 48, tempCpu: 46, fan: 22, disk: 12, netIn: 20, netOut: 18 },
"node-5": { gpu: 55, vram: 42, cpu: 28, mem: 48, power: 132, tempGpu: 58, tempCpu: 52, fan: 32, disk: 14, netIn: 220, netOut: 190 },
};
function seedMock() {
resetLive();
NODES.forEach((n) => {
const s = liveSeeds[n.id];
if (!s) return; // 防御: 节点无 seed 时跳过, 不崩
const ns = live.nodes[n.id];
const seed = (k, v) => { ns[k].now = v; ns[k].hist = Array.from({ length: HIST }, () => v + (Math.random() - 0.5) * 6); };
seed("gpu", s.gpu); seed("vram", s.vram); seed("cpu", s.cpu); seed("mem", s.mem);
seed("power", s.power); seed("tempGpu", s.tempGpu); seed("tempCpu", s.tempCpu);
seed("fan", s.fan); seed("disk", s.disk); seed("netIn", s.netIn); seed("netOut", s.netOut);
seed("smActivity", s.gpu * 0.92); seed("pcie", s.netIn * 0.45);
const jit = (b, spread) => Math.round(b + (Math.random() - 0.5) * spread);
live.nodeMeta[n.id].temps = [
{ module: "CPU", label: "Package", chip: "coretemp", celsius: jit(s.tempCpu, 2) },
{ module: "CPU", label: "Core 0", chip: "coretemp", celsius: jit(s.tempCpu - 1, 4) },
{ module: "CPU", label: "Core 4", chip: "coretemp", celsius: jit(s.tempCpu - 2, 4) },
{ module: "CPU", label: "Core 8", chip: "coretemp", celsius: jit(s.tempCpu - 1, 4) },
{ module: "NVMe", label: "Composite nvme0", chip: "nvme0", celsius: jit(s.tempCpu - 6, 4) },
{ module: "NVMe", label: "Composite nvme1", chip: "nvme1", celsius: jit(s.tempCpu - 5, 4) },
{ module: "网卡", label: "PHY Temperature", chip: "mlx5", celsius: jit(s.tempGpu + 12, 3) },
{ module: "网卡", label: "MAC Temperature", chip: "mlx5", celsius: jit(s.tempGpu + 12, 3) },
{ module: "水冷", label: "Coolant temp", chip: "aio", celsius: jit(s.tempCpu - 12, 3) },
{ module: "平台", label: "ACPI zone 0", chip: "acpitz", celsius: jit(s.tempCpu - 14, 3) },
].sort((a, b) => b.celsius - a.celsius);
live.nodeMeta[n.id].fans = [
{ label: "Pump speed", chip: "aio", rpm: jit(2900, 200) },
{ label: "Internal fan", chip: "aio", rpm: jit(1900, 240) },
{ label: "Chassis fan 1", chip: "aio", rpm: jit(s.fan * 28, 200) },
{ label: "Controller fan", chip: "aio", rpm: 0 },
];
});
MODELS.forEach((m) => {
const ms = live.models[m.id];
const seedM = (k, v) => { ms[k].now = v; ms[k].hist = Array.from({ length: SPARK }, () => Math.max(0, v + (Math.random() - 0.5) * v * 0.25)); };
seedM("tps", m.tps); seedM("ttft", m.ttft); seedM("tpot", m.tpot); seedM("rps", m.rps); seedM("kv", m.kv);
});
live.cluster.reqTotal = 142_840;
live.cluster.tokTotal = 18_400_000;
live.cluster.uptimeSec = 86_400 * 12 + 4 * 3600 + 1820;
live.alerts = [
{ sev: "warn", msg: "Node-2 GPU thermal margin reduced", sub: "85°C peak under load · soft thermal cap", when: "2m ago" },
{ sev: "ok", msg: "Gateway · LiteLLM rotated TLS cert", sub: "letsencrypt · expires 2026-08-12", when: "14m ago" },
{ sev: "hot", msg: "a model approaching KV-cache pressure", sub: "71% across inference nodes · consider evicting cold prefixes", when: "26m ago" },
{ sev: "warn", msg: "a node idle > 4h", sub: "candidate for power-save autopilot", when: "1h ago" },
{ sev: "ok", msg: "Cluster heartbeat green", sub: "5/5 nodes · Prometheus 15s scrape · 0 drops", when: "1h ago" },
];
seedLog();
}
function seedLog() {
const serving = MODELS.filter((m) => m.state === "serving");
let t0 = new Date();
for (let i = 0; i < 30; i++) {
const t = new Date(t0 - i * 1500 - Math.random() * 800);
live.log.unshift(genLogEntry(t, serving));
}
}
function genLogEntry(t, serving = MODELS.filter((m) => m.state === "serving")) {
// 真实目录里可能没有 state==="serving" 的模型（v4-flash 多为 idle，
// llama.cpp 为 no-metrics）→ serving 空。回退到全部 MODELS，再空则安全占位，
// 否则 m.kind 读 undefined 会在 boot 的 seedMock 直接崩，整个 data.js 不启动。
const pool = (serving && serving.length) ? serving : MODELS;
const m = pool[Math.floor(Math.random() * pool.length)];
if (!m) return { t, model: "—", meth: "POST /v1/chat/completions", lat: 0, status: "200" };
const meth = m.kind === "embed" ? "POST /v1/embeddings"
: m.kind === "speech" ? "POST /v1/audio/transcriptions"
: m.kind === "image" ? "POST /v1/images/generations"
: "POST /v1/chat/completions";
const lat = Math.round(m.p50 + (Math.random() - .3) * (m.p95 - m.p50));
const r = Math.random();
const status = r > .985 ? "5xx" : r > .97 ? "4xx" : "200";
return { t, model: m.id, meth, lat, status };
}
function mockTick() {
NODES.forEach((n) => {
const s = liveSeeds[n.id];
if (!s) return; // 防御: 节点无 seed 时跳过, 不崩
const ns = live.nodes[n.id];
const clamp = (v, lo, hi) => Math.max(lo, Math.min(hi, v));
const drift = (cur, target, amp) => clamp(cur + (target - cur) * 0.06 + (Math.random() - 0.5) * amp, 0, 100);
const driftRaw = (cur, target, amp, lo, hi) => clamp(cur + (target - cur) * 0.06 + (Math.random() - 0.5) * amp, lo, hi);
ns.gpu.now = drift(ns.gpu.now, s.gpu, 6);
ns.vram.now = drift(ns.vram.now, s.vram, 1.2);
ns.cpu.now = drift(ns.cpu.now, s.cpu, 8);
ns.mem.now = drift(ns.mem.now, s.mem, 1.0);
ns.power.now = driftRaw(ns.power.now, s.power * (0.5 + ns.gpu.now/100), 12, 50, /gateway/i.test(n.role) ? 480 : 240);
ns.tempGpu.now = driftRaw(ns.tempGpu.now, 38 + ns.gpu.now * 0.45, 1.6, 32, 89);
ns.tempCpu.now = driftRaw(ns.tempCpu.now, 36 + ns.cpu.now * 0.32, 1.4, 30, 84);
ns.fan.now = driftRaw(ns.fan.now, Math.max(ns.tempGpu.now - 35, 10), 3, 8, 98);
ns.disk.now = drift(ns.disk.now, s.disk, 1.0);
ns.netIn.now = Math.max(0, ns.netIn.now + (Math.random() - 0.45) * 80);
ns.netOut.now = Math.max(0, ns.netOut.now + (Math.random() - 0.48) * 80);
ns.smActivity.now = drift(ns.smActivity.now, ns.gpu.now * 0.95, 5);
ns.pcie.now = Math.max(0, ns.pcie.now + (Math.random() - 0.5) * 40);
Object.keys(ns).forEach((k) => { ns[k].hist.shift(); ns[k].hist.push(ns[k].now); });
});
MODELS.forEach((m) => {
if (m.state !== "serving") return;
const ms = live.models[m.id];
const drift = (cur, target, amp) => Math.max(0, cur + (target - cur) * 0.08 + (Math.random() - 0.5) * amp);
ms.tps.now = drift(ms.tps.now, m.tps, m.tps * 0.18);
ms.ttft.now = drift(ms.ttft.now, m.ttft, m.ttft * 0.14);
ms.tpot.now = drift(ms.tpot.now, m.tpot, m.tpot * 0.18);
ms.rps.now = drift(ms.rps.now, m.rps, m.rps * 0.22);
ms.kv.now = drift(ms.kv.now, m.kv, 1.8);
Object.keys(ms).forEach((k) => { ms[k].hist.shift(); ms[k].hist.push(ms[k].now); });
});
const totalTps = MODELS.reduce((a, m) => a + (m.state === "serving" ? live.models[m.id].tps.now : 0), 0);
const totalRps = MODELS.reduce((a, m) => a + (m.state === "serving" ? live.models[m.id].rps.now : 0), 0);
const serving = MODELS.filter((m) => m.state === "serving");
const totalKv = serving.length ? serving.reduce((a, m) => a + live.models[m.id].kv.now, 0) / serving.length : 0;
const totalPow = NODES.reduce((a, n) => a + live.nodes[n.id].power.now, 0);
const peakT = NODES.reduce((a, n) => Math.max(a, live.nodes[n.id].tempGpu.now), 0);
live.cluster.tpsNow = totalTps; live.cluster.rpsNow = totalRps;
live.cluster.kvNow = totalKv; live.cluster.powNow = totalPow; live.cluster.tempNow = peakT;
[["tps", totalTps],["rps", totalRps],["kv", totalKv],["pow", totalPow],["temp", peakT]].forEach(([k, v]) => {
if (live.cluster[k].length >= HIST) live.cluster[k].shift();
live.cluster[k].push(v);
});
live.cluster.reqTotal += Math.round(totalRps * (intervalMs/1000));
live.cluster.tokTotal += Math.round(totalTps * (intervalMs/1000));
live.cluster.uptimeSec += intervalMs/1000;
const n = 1 + Math.floor(Math.random() * 3);
for (let i = 0; i < n; i++) live.log.unshift(genLogEntry(new Date()));
if (live.log.length > 80) live.log.length = 80;
emit();
}
function startMock() {
stopMock(); stopSSE();
if (mode !== "mock") seedMock();
mode = "mock"; connStatus = "mock";
mockTimer = setInterval(mockTick, intervalMs);
mockTick(); // seed cluster aggregates
}
function stopMock() { if (mockTimer) { clearInterval(mockTimer); mockTimer = null; } }
// ── Live (SSE) data source ──────────────────────────────────────────
// The /api/stream endpoint pushes a full payload every ~1.2s; we use
// the values to update `live.*.now` and shift the rolling history.
function startLive() {
stopMock(); stopSSE();
mode = "live"; connStatus = "connecting";
resetLive();
const url = "/api/stream";
sse = new EventSource(url);
sse.onopen = () => { connStatus = "live"; emit(); };
sse.onerror = () => {
connStatus = "reconnecting";
// Browsers auto-reconnect EventSource — only fall back if it stays down.
setTimeout(() => {
if (connStatus === "reconnecting") { stopSSE(); startMock(); connStatus = "mock-fallback"; emit(); }
}, 8000);
emit();
};
sse.onmessage = (ev) => {
try {
const payload = JSON.parse(ev.data);
applyLivePayload(payload);
emit();
} catch (e) { /* skip */ }
};
}
function stopSSE() { if (sse) { sse.close(); sse = null; } }
function applyLivePayload(p) {
// ── cluster ──
if (p.cluster) {
Object.assign(live.cluster, {
tpsNow: p.cluster.live.tpsNow || 0,
rpsNow: p.cluster.live.rpsNow || 0,
kvNow: p.cluster.live.kvNow || 0,
powNow: p.cluster.live.powNow || 0,
tempNow: p.cluster.live.tempNow || 0,
reqTotal: p.cluster.reqTotal || live.cluster.reqTotal,
tokTotal: p.cluster.tokTotal || live.cluster.tokTotal,
latP50: p.cluster.live.latP50 || 0,
latP95: p.cluster.live.latP95 || 0,
uptimeSec: p.cluster.uptimeSec || 0,
});
// Replace history wholesale with backend's view (5min @ 15s = 20 pts;
// pad to HIST for chart consistency).
const pad = (arr, n) => {
if (!arr || !arr.length) return Array(n).fill(0);
if (arr.length >= n) return arr.slice(-n);
return [...Array(n - arr.length).fill(arr[0]), ...arr];
};
// pow/temp 有真实 Prometheus range → 整段替换；tps/kv 无 range
// (vLLM 直采，非 Prometheus)，改由下方模型聚合滚动，勿在此清空。
live.cluster.rps = pad(p.cluster.history.rps, HIST);
live.cluster.pow = pad(p.cluster.history.pow, HIST);
live.cluster.temp = pad(p.cluster.history.temp, HIST);
// Home Assistant — optional. Each field may be null (HA exporter
// absent or sensor stale); the UI treats null as "—", not 0.
live.power = p.cluster.power || null;
live.env = p.cluster.env || null;
}
// ── training(Phase 1 纯 obs 底座)──
if (p.training) {
live.training = p.training;
const s = p.training.summary || {};
const rollT = (key, v) => {
const a = live.trainingHist[key];
if (a.length < HIST) { while (a.length < HIST) a.push(v); }
else { a.push(v); a.shift(); }
};
rollT("util", s.utilAvg || 0);
rollT("roce", (s.roceRxMBps || 0) + (s.roceTxMBps || 0));
}
// ── nodes：后端是运行时权威全集。前端动态对齐——后端发什么节点就显
// 什么(id 任意, 不要求匹配前端静态目录)。静态 NODES 仅 mock 模式用;
// live 模式按 payload 重建 NODES + live.nodes, 否则后端 id(atlas/
// spark-NN)与静态 id(node-N)对不上 → 全部节点无数据。与 MODELS 同款。
if (Array.isArray(p.nodes) && p.nodes.length) {
const byId = new Map(NODES.map((x) => [x.id, x]));
const next = [];
p.nodes.forEach((n) => {
const lv = n.live || {};
const e = byId.get(n.id) || { id: n.id, os: "—", kernel: "—", driver: "NVIDIA —", cuda: "—" };
e.name = n.name || n.id;
e.ip = n.ip || "";
e.class = n.class || "GPU host";
e.role = n.role || "node";
e.kind = n.kind || "discrete";
e.gpu = n.gpu || { name: "—", mem: 0 };
e.cpu = n.cpu || { cores: 0, threads: 0 };
e.ram = n.ram || 0; e.disk = n.disk || 0; e.net = n.net || "";
e.services = n.services || [];
e.gpuPending = !!n.gpuPending;
if (e.os === undefined) { e.os = "—"; e.kernel = "—"; e.driver = "NVIDIA —"; e.cuda = "—"; }
if (!live.nodes[n.id]) live.nodes[n.id] = makeNodeMetrics();
if (!live.nodeMeta[n.id]) live.nodeMeta[n.id] = { temps: [], fans: [] };
const ns = live.nodes[n.id];
ns.up = n.up !== false; // 后端权威 up → 诚实显示在线/离线
const upd = (k, v) => { if (v === undefined || v === null) return;
ns[k].now = v; ns[k].hist.shift(); ns[k].hist.push(v); };
if (/gateway/i.test(e.role)) upd("gpu", lv.gpu); // 网关(discrete)用真实 DCGM
upd("vram", lv.vram);
upd("tempGpu", lv.tempGpu); upd("tempCpu", lv.tempCpu); upd("power", lv.power);
upd("cpu", lv.cpu); upd("mem", lv.mem); upd("disk", lv.disk);
upd("netIn", lv.netIn); upd("netOut", lv.netOut);
upd("rdmaIn", lv.rdmaIn); upd("rdmaOut", lv.rdmaOut);
live.nodeMeta[n.id].temps = Array.isArray(lv.temps) ? lv.temps : [];
live.nodeMeta[n.id].fans = Array.isArray(lv.fans) ? lv.fans : [];
next.push(e);
});
const keep = new Set(next.map((x) => x.id));
Object.keys(live.nodes).forEach((id) => {
if (!keep.has(id)) { delete live.nodes[id]; delete live.nodeMeta[id]; }
});
NODES.length = 0; Array.prototype.push.apply(NODES, next); // 原地替换保持引用
}
// ── models：后端(网关 /health 自动发现)是运行时权威全集。
// 前端动态对齐——后端返回什么就显什么(新模型自动建条目+live槽，
// 消失的删掉)，顺序随后端(运行中+vLLM 优先)。不再依赖前端静态目录，
// 部署怎么变监控自动跟，不漏显也不显错。
if (Array.isArray(p.models) && p.models.length) {
const byId = new Map(MODELS.map((x) => [x.id, x]));
const next = [];
p.models.forEach((m) => {
const lv = m.live || {};
let e = byId.get(m.id) ||
{ id: m.id, tps: 0, ttft: 0, tpot: 0, rps: 0, kv: 0,
p50: 0, p95: 0, p99: 0, err: 0 };
e.display = m.display || m.id;
e.vendor = m.vendor || "—";
e.kind = m.kind || "chat";
e.params = m.params || "—";
e.quant = m.quant || "—";
e.ctx = m.ctx || 0;
e.framework = m.framework || "—";
e.nodes = Array.isArray(m.nodes) ? m.nodes : [];
e.vram = m.vram || 0;
e.route = m.route || "";
e.tags = Array.isArray(m.tags) ? m.tags : [];
e.state = m.state; // serving|idle|online|stopped
e.resident = !!lv.resident; // 真实驻留探针(后端权威)
e.metricsSource = lv.metrics || "none";
if (lv.p50 !== undefined) {
e.p50 = Math.round(lv.p50);
e.p95 = Math.round(lv.p95);
e.p99 = Math.round(lv.p99);
}
if (!live.models[m.id]) live.models[m.id] = makeModelMetrics();
const ms = live.models[m.id];
const upd = (k, v) => { if (v === undefined || v === null) return;
ms[k].now = v; ms[k].hist.shift(); ms[k].hist.push(v); };
upd("tps", lv.tps); upd("rps", lv.rps); upd("kv", lv.kv);
upd("ttft", lv.ttft); upd("tpot", lv.tpot);
upd("running", lv.running); upd("waiting", lv.waiting); // 并发(执行中)+ 排队
next.push(e);
});
const keep = new Set(next.map((x) => x.id));
Object.keys(live.models).forEach((id) => {
if (!keep.has(id)) delete live.models[id]; // 后端已不返回 → 清掉
});
MODELS.length = 0; // 原地替换, 保持数组引用
Array.prototype.push.apply(MODELS, next);
}
// ── GB10 Spark GPU 环 = 加速器活跃度(驻留就绪基线 + 实时推理)。
// GB10 无可靠算力计数器，DCGM_GPU_UTIL/功率滞后失真(实测)。语义改为:
// 后端真实 resident 探针(vLLM 可达且模型已加载) → 12% 基线
// 含义="权重已驻留·预热·0 请求在途"，非真闲置；
// 有真实推理 → 按真实 tps 升至 18~100%。discrete dGPU 节点保留真实 DCGM。
NODES.forEach((n) => {
if (/gateway/i.test(n.role)) return; // 网关(discrete)节点 DCGM util 可靠, 不走推导
const ns = live.nodes[n.id]; if (!ns) return;
let act = 0;
MODELS.forEach((m) => {
// 任何有真实推理指标的后端(vLLM / llama.cpp) → 都参与节点活跃度推导
if (!(m.metricsSource === "vllm" || m.metricsSource === "llamacpp" || m.metricsSource === "sglang")) return;
if (!(m.nodes || []).includes(n.id)) return;
const mm = live.models[m.id];
if (!mm) return;
if (m.resident || m.state === "serving" || m.state === "idle")
act = Math.max(act, 12); // 驻留就绪基线
if (m.state === "serving" || mm.tps.now > 0) // 真实推理活跃
act = Math.max(act, Math.min(100, Math.max(18, mm.tps.now / 60 * 100)));
});
ns.gpu.now = Math.round(act);
ns.gpu.hist.shift(); ns.gpu.hist.push(ns.gpu.now); // 滚动一拍: 节点循环已跳过 Spark 原始DCGM, 此处独占驱动 → 60拍历史连续(热力图/趋势图有数据)
});
// ── cluster tps/kv：从 vLLM 真实模型指标聚合滚动（无 Prometheus range 源）──
if (p.models) {
const vm = MODELS.filter((m) => (m.metricsSource === "vllm" || m.metricsSource === "llamacpp" || m.metricsSource === "sglang") && live.models[m.id]);
const cTps = vm.reduce((a, m) => a + (live.models[m.id].tps.now || 0), 0);
const cKv = vm.length ? Math.max(...vm.map((m) => live.models[m.id].kv.now || 0)) : 0;
live.cluster.tpsNow = cTps;
live.cluster.kvNow = cKv;
const rollC = (key, val) => {
let a = live.cluster[key];
if (!Array.isArray(a)) { a = []; live.cluster[key] = a; }
if (a.length < HIST) { while (a.length < HIST) a.push(val); }
else { a.push(val); a.shift(); }
};
rollC("tps", cTps);
rollC("kv", cKv);
}
// ── alerts (replace whole list) ──
if (p.alerts) live.alerts = p.alerts;
// ── log (fetched separately, but mirror if attached) ──
// 后端 log 的 t 是字符串；前端 Telemetry 用 e.t.getTime()/toLocaleTimeString
// 必须是 Date，否则整段 Telemetry 崩（同 genLogEntry 教训）。归一化。
if (Array.isArray(p.log)) live.log = p.log.map((e) => ({
t: new Date(e.t), meth: e.meth || "", model: e.model || "—",
status: e.status || "200", lat: e.lat,
}));
}
// ── Mode selection ──────────────────────────────────────────────────
async function pickMode() {
const url = new URL(location.href);
const q = url.searchParams.get("mode");
if (q === "live" || q === "mock") return q; // 显式 ?mode= 强制覆盖
// 探活优先：后端健康就 LIVE，绝不被陈旧 localStorage("mock") 卡死
// （踩坑：Tweaks 选过 Mock 会持久化 aim.mode=mock，旧逻辑优先于探活
// 导致后端再健康也永远显 MOCK）。健康则顺手清掉陈旧 mock 标记。
try {
const r = await fetch("/api/health", { cache: "no-store",
signal: AbortSignal.timeout(2500) });
if (r.ok) {
if (localStorage.getItem("aim.mode") === "mock") localStorage.removeItem("aim.mode");
return "live";
}
} catch (e) {}
// 仅探活失败时才参考 localStorage 提示，否则 mock
return localStorage.getItem("aim.mode") === "live" ? "live" : "mock";
}
function switchMode(next) {
if (next === mode) return;
localStorage.setItem("aim.mode", next);
if (next === "live") startLive(); else startMock();
emit();
}
// ── Display config (cluster_name, timezone) ────────────────────────
// Loaded once from /api/config; mutated in place so consumers see fresh
// values on the next re-render (Nav re-renders every 1s clock tick).
// timezone=null → browser-local (default). Set via display.timezone in
// hearth.yaml when you want timestamps pinned to a fixed IANA zone.
const displayConfig = { cluster_name: "Hearth", timezone: null };
async function loadConfig() {
try {
const r = await fetch("/api/config", { cache: "no-store",
signal: AbortSignal.timeout(2500) });
if (r.ok) Object.assign(displayConfig, await r.json());
} catch (e) { /* keep defaults — browser-local timezone */ }
}
const _tzOpt = () => displayConfig.timezone ? { timeZone: displayConfig.timezone } : {};
function formatTime(d) {
return d.toLocaleTimeString("en-US", { hour12: false, ..._tzOpt() });
}
function formatDate(d) {
return d.toLocaleDateString("en-US",
{ weekday: "short", month: "short", day: "numeric", ..._tzOpt() });
}
// ── Energy trends (24h / 7d / 30d, day-vs-night) ─────────────────
// Refreshed every 60s — these are aggregates that don't move in
// sub-minute scale, no point hammering the endpoint at SSE cadence.
async function loadEnergyTrends() {
try {
const r = await fetch("/api/energy/trends", { cache: "no-store",
signal: AbortSignal.timeout(8000) });
if (r.ok) { live.energyTrends = await r.json(); emit(); }
} catch (e) { /* keep last successful snapshot */ }
}
// ── Public API ──────────────────────────────────────────────────────
window.AIData = {
NODES, MODELS, live, totals, subscribe,
get mode() { return mode; },
get status() { return connStatus; },
get displayConfig() { return displayConfig; },
formatTime, formatDate,
switchMode,
setIntervalMs(ms) {
intervalMs = ms;
if (mode === "mock" && running) { stopMock(); mockTimer = setInterval(mockTick, ms); }
// SSE rate is controlled by the backend's TICK_SEC env var.
},
pause() { running = false; stopMock(); stopSSE(); },
resume() { running = true; if (mode === "live") startLive(); else startMock(); },
};
// Boot
seedMock();
loadConfig(); // fire-and-forget; first render uses defaults, ~250ms later switches
loadEnergyTrends();
setInterval(loadEnergyTrends, 60_000);
pickMode().then((m) => {
if (m === "live") startLive(); else startMock();
});
})();