svrnty-hermes-webui-plugin/static/cortex-os/runtime-health/runtime_health.js

(function () {
  "use strict";

  var endpoint = "/api/cortex-os/runtime-health";
  var states = ["healthy", "degraded", "unavailable", "unknown", "loading", "error", "redacted"];

  if (window.__cortexOsRuntimeHealthLoaded) {
    return;
  }
  window.__cortexOsRuntimeHealthLoaded = true;

  function ensurePanel() {
    var panel = document.querySelector("[data-cortex-os-runtime-health]");
    if (panel) {
      return panel;
    }

    panel = document.createElement("section");
    panel.className = "cortex-os-runtime-health";
    panel.setAttribute("data-cortex-os-runtime-health", "true");
    panel.setAttribute("data-state", "loading");

    var title = document.createElement("h2");
    title.setAttribute("data-role", "headline");
    title.textContent = "Cortex OS Runtime Health";

    var badge = document.createElement("span");
    badge.className = "cortex-os-runtime-health__badge";
    badge.setAttribute("data-role", "status");
    badge.textContent = "loading";

    var summary = document.createElement("p");
    summary.className = "cortex-os-runtime-health__summary";
    summary.setAttribute("data-role", "summary");
    summary.textContent = "Checking Runtime Health.";

    var list = document.createElement("dl");
    list.className = "cortex-os-runtime-health__signals";
    list.setAttribute("data-role", "signals");

    var details = document.createElement("section");
    details.className = "cortex-os-runtime-health__details";
    details.setAttribute("data-role", "details");

    panel.appendChild(title);
    panel.appendChild(badge);
    panel.appendChild(summary);
    panel.appendChild(list);
    panel.appendChild(details);

    var target = document.querySelector("main.main");
    if (!target) {
      return panel;
    }
    target.appendChild(panel);
    return panel;
  }

  function setState(panel, state, headline, detail, signals, payloadDetails) {
    var nextState = states.indexOf(state) >= 0 ? state : "unknown";
    panel.setAttribute("data-state", nextState);
    panel.querySelector("[data-role='headline']").textContent = headline || "Runtime Health";
    panel.querySelector("[data-role='status']").textContent = nextState;
    panel.querySelector("[data-role='summary']").textContent = detail || "redacted";
    renderSignals(panel.querySelector("[data-role='signals']"), signals || []);
    renderDetails(panel.querySelector("[data-role='details']"), payloadDetails || {});
  }

  function renderSignals(list, signals) {
    list.textContent = "";
    signals.slice(0, 3).forEach(function (signal) {
      var name = document.createElement("dt");
      var value = document.createElement("dd");
      name.textContent = signal.signal_id || "redacted";
      value.textContent = signal.state || "unknown";
      if (signal.summary) {
        value.setAttribute("title", signal.summary);
      }
      list.appendChild(name);
      list.appendChild(value);
    });
  }

  function renderKeyValues(container, title, rows) {
    var group = document.createElement("section");
    group.className = "cortex-os-runtime-health__detail-group";

    var heading = document.createElement("h3");
    heading.textContent = title;
    group.appendChild(heading);

    var list = document.createElement("dl");
    list.className = "cortex-os-runtime-health__detail-list";
    rows.forEach(function (row) {
      var key = document.createElement("dt");
      var value = document.createElement("dd");
      key.textContent = row.key || "redacted";
      value.textContent = row.value || "redacted";
      list.appendChild(key);
      list.appendChild(value);
    });
    group.appendChild(list);
    container.appendChild(group);
  }

  function renderDetails(container, detail) {
    container.textContent = "";
    var signals = detail.signals || [];
    var warnings = detail.warnings || [];
    var redactions = detail.redactions || [];
    var sourceTrace = detail.source_trace || [];
    var authority = detail.authority || {};
    var allAuthorityDenied = Object.keys(authority).every(function (key) {
      return authority[key] === false;
    });

    renderKeyValues(container, "Signals", signals.slice(0, 3).map(function (signal) {
      return {
        key: signal.signal_id || "redacted",
        value: (signal.state || "unknown") + " | " + (signal.redacted ? "redacted" : "visible") + " | " + (signal.summary || "redacted")
      };
    }));
    renderKeyValues(container, "Warnings", warnings.slice(0, 3).map(function (warning) {
      return {
        key: warning.code || "redacted",
        value: warning.message || "redacted"
      };
    }));
    renderKeyValues(container, "Redactions", redactions.slice(0, 4).map(function (redaction) {
      return {
        key: redaction.reason_code || "redacted",
        value: redaction.label || "redacted"
      };
    }));
    renderKeyValues(container, "Source Trace", sourceTrace.slice(0, 3).map(function (source) {
      return {
        key: source.source_kind || "redacted",
        value: source.label || "redacted"
      };
    }));
    renderKeyValues(container, "Authority", [{
      key: "all denied",
      value: allAuthorityDenied ? "true" : "review required"
    }]);
  }

  function renderPayload(panel, payload) {
    if (!payload || payload.ok !== true || !payload.result) {
      setState(panel, "error", "Runtime Health is unavailable.", "Runtime Health is unavailable.", []);
      return;
    }
    var displaySummary = payload.result.display_summary || {};
    setState(
      panel,
      payload.result.status,
      displaySummary.headline,
      displaySummary.detail,
      payload.result.signals,
      {
        signals: payload.result.signals,
        warnings: payload.result.warnings,
        redactions: payload.result.redactions,
        source_trace: payload.result.source_trace,
        authority: payload.result.authority
      }
    );
  }

  function loadRuntimeHealth() {
    var panel = ensurePanel();
    setState(panel, "loading", "Cortex OS Runtime Health", "Checking Runtime Health.", []);

    fetch(endpoint, {
      method: "GET",
      headers: { Accept: "application/json" },
      credentials: "same-origin",
      cache: "no-store"
    })
      .then(function (response) {
        if (!response.ok) {
          throw new Error("runtime-health-unavailable");
        }
        return response.json();
      })
      .then(function (payload) {
        renderPayload(panel, payload);
      })
      .catch(function () {
        setState(panel, "error", "Runtime Health is unavailable.", "Runtime Health is unavailable.", []);
      });
  }

  function handlePanelSwitch(event) {
    var detail = (event && event.detail) || {};
    if (detail.name === "cortex-os") {
      loadRuntimeHealth();
    }
  }

  window.addEventListener("svrnty:panel-switch", handlePanelSwitch);

  var main = document.querySelector("main.main");
  if (main && main.classList.contains("svrnty-showing-cortex-os")) {
    loadRuntimeHealth();
  }
})();