infracensus-collector 1.6.2 → 1.6.3

package/dist/index.js

@@ -15972,19 +15972,37 @@ ${tokenCss()}
       writeRunSiteHint();
       $("runTargets").value = (s.scanDefaults.targets || []).join(", ");
     }
-    renderLive(s.scanProgress || null);
-    // A run that has just ENDED is the moment the history gained a row, and the
-    // moment somebody wants to read it.
+    // THE AUTHORITY ON WHAT IS RUNNING, held for the history to read.
     //
-    // It is also re-read WHILE one runs, which it deliberately was not before:
-    // the detail used to be a fold of a finished run, so nothing in it changed
-    // between two polls of a scan in flight. It now carries that run's stages
-    // and the addresses it has found so far, both of which land as the scan
-    // goes \u2014 a panel somebody opened to watch their own scan cannot be a
-    // snapshot of the moment they opened it. Bounded twice over: only while the
-    // panel is open, and only while something is actually running.
-    const running = !!s.scanProgress;
-    if ($("histWrap").open && (running || (wasRunning && !running))) loadRuns();
+    // The detail used to decide "is this run live" from a boolean this paint
+    // had set on a previous tick, and then say "the collector stopped before it
+    // finished" on the strength of it \u2014 a strong claim about somebody's
+    // machine, made from a stale client-side variable. The server knows: the
+    // daemon and this console are one process, and the progress store IS the
+    // running job. Matched by jobId below, so the claim is about the run being
+    // looked at rather than about whatever was running most recently.
+    liveProgress = s.scanProgress || null;
+    renderLive(liveProgress);
+
+    const running = !!liveProgress;
+    if ($("histWrap").open) {
+      const now = Date.now();
+      if (wasRunning && !running) {
+        // The run just ended: the ledger gained its verdict, its device list and
+        // its receipt all at once, and this is the moment somebody reads them.
+        loadRuns();
+      } else if (running) {
+        // A LIVE run is repainted from the store above rather than re-read from
+        // disk, because the two carry different things and only one of them
+        // moves. The ledger records a phase when it COMPLETES \u2014 that is what
+        // makes it a ledger and not a transcript \u2014 so bars built from it jump
+        // from nothing to done and an operator watching a sweep sees a frozen
+        // panel. The live store has every report. Repainting is free; the
+        // re-read is not, so it happens on a slow beat to pick up the rest.
+        if (now - lastRunsAt > 15000) loadRuns();
+        else renderRuns(lastRuns);
+      }
+    }
     wasRunning = running;
     $("lastPollAt").textContent = fmt(s.daemon && s.daemon.lastPollAt);
     $("lastPushAt").textContent = fmt(s.daemon && s.daemon.lastPushAt);
@@ -16638,6 +16656,20 @@ ${tokenCss()}
 
   /** Was a scan running the last time we painted? Used to refresh history. */
   let wasRunning = false;
+  /** The running job as the SERVER reports it, or null. The liveness authority. */
+  let liveProgress = null;
+  /** The last fold read from the ledger, repainted between reads. */
+  let lastRuns = [];
+  /** When that read happened, so a live repaint does not re-read the file. */
+  let lastRunsAt = 0;
+  /**
+   * Which runs the operator has expanded, by start time.
+   *
+   * A live run repaints every poll, and a repaint that rebuilt the list would
+   * shut the panel somebody is reading three seconds after they opened it \u2014
+   * which is precisely the panel this whole feature exists to keep open.
+   */
+  const openRuns = new Set();
 
   /**
    * The last runs, folded from the ledger by the server.
@@ -16653,6 +16685,7 @@ ${tokenCss()}
       const res = await fetch("/ui/api/runs", { cache: "no-store" });
       if (res.status === 401) { showLogin(); return; }
       const data = await res.json().catch(() => ({ runs: [] }));
+      lastRunsAt = Date.now();
       renderRuns(data.runs || []);
       $("histNote").textContent = "";
     } catch (e) {
@@ -16662,6 +16695,7 @@ ${tokenCss()}
   }
 
   function renderRuns(runs) {
+    lastRuns = runs;
     const host = $("histBody");
     host.innerHTML = "";
     if (!runs.length) {
@@ -16671,16 +16705,33 @@ ${tokenCss()}
     }
     host.className = "";
     for (const run of runs) {
+      // IS THIS RUN THE ONE RUNNING? Answered by the server's own record of
+      // the job it is executing, not by a flag about whatever ran most
+      // recently. A run with no job id is the one-shot CLI path, which cannot be
+      // the daemon's live job and so is matched on nothing.
+      const live = run.outcome === "running" && !!liveProgress
+        && (run.jobId ? liveProgress.jobId === run.jobId : false);
+      const state = run.outcome === "running" && !live ? "stopped" : run.outcome;
+
+      // A LIVE run's stages come from the progress store, which reports every
+      // tick; the ledger only records a phase once it has finished, so bars
+      // folded from it cannot move while the work is happening.
+      const phases = live && liveProgress.phases.length
+        ? liveProgress.phases.map((ph) => ({
+            phase: ph.phase, done: ph.done, total: ph.total, note: ph.message,
+          }))
+        : (run.phases || []);
+
       const row = el("details", { class: "runrow" });
+      // Reopened across repaints \u2014 see openRuns.
+      if (openRuns.has(run.startedAt)) row.setAttribute("open", "open");
+      row.addEventListener("toggle", () => {
+        if (row.open) openRuns.add(run.startedAt);
+        else openRuns.delete(run.startedAt);
+      });
       const sum = el("summary");
       sum.appendChild(el("span", { class: "when", text: fmt(run.startedAt) }));
       sum.appendChild(el("span", { text: run.mode }));
-      // A run the LEDGER calls running is only reported as running if a scan is
-      // actually in flight. The ledger cannot tell a live daemon from one killed
-      // between two polls; the status poll can, and it is the half of the answer
-      // this side of the page holds.
-      const live = run.outcome === "running" && wasRunning;
-      const state = run.outcome === "running" && !live ? "stopped" : run.outcome;
       sum.appendChild(el("span", { class: "outcome-" + (live ? "running" : state), text:
         state === "finished" ? "finished"
         : state === "failed" ? "failed"
@@ -16710,7 +16761,7 @@ ${tokenCss()}
       // The last stage the run reported is what it is DOING, which is the
       // sentence somebody watching their own scan is looking for. A finished run
       // has no use for it; a live one has nothing else.
-      const latest = run.phases && run.phases.length ? run.phases[run.phases.length - 1] : null;
+      const latest = phases.length ? phases[phases.length - 1] : null;
       block("Current stage", [
         el("div", {
           class: state === "failed" ? "bad" : state === "incomplete" || state === "stopped" ? "warntext" : "",
@@ -16729,9 +16780,9 @@ ${tokenCss()}
       // \u2500\u2500 STAGES, AS BARS \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500
       // The same bars the live panel draws, so a finished run and a running one
       // look like the same thing at two moments.
-      if (run.phases && run.phases.length) {
+      if (phases.length) {
         const nodes = [];
-        for (const ph of run.phases) {
+        for (const ph of phases) {
           for (const n of phaseBar(ph.phase, ph.done, ph.total, ph.note)) nodes.push(n);
         }
         block("Stages", nodes);