Files
pipelines/web/src/app.js
T
alan bd09c55c47 Merge lane-go: titles, verdicts, human stage, line result format, stale-client guard
Integrates nine commits of reviewed work from the lane-go branch after the
automated resolver failed on this merge five times (each attempt dying on the
malformed-result defect whose fix is contained in this same merge).

Integration decisions:
- Search: kept main's shipped design (Store.Search + SearchResponse.Results) and
  dropped lane-go's parallel, older attempt (an unused Message.Matches field, an
  absent runs.search, and two partial TUI plumbing blocks). lane-go itself did not
  compile: protocol.SearchMatch was undefined and model.go referenced searchNav,
  requestSearch and applyRunNav, which exist nowhere. Those partial TUI blocks are
  removed; the queued TUI omni-search item will implement the surface properly on
  main's design.
- Both sides' additions are kept where they are independent: run titles and
  provenance, the human decision stage and its CLI/TUI surface, the derived stage
  verdict, the stale-client guard, the line-oriented result format, and main's
  search command.
- The search key's help label is now "/ omni search"; the two tests asserting the
  old label are updated rather than the label reverted.
- docs/cli.md and the packaged operations reference carry both sides' text.

Verified: go build ./... , go vet ./... and the full go test ./... suite pass.
2026-10-16 22:21:43 +01:00

523 lines
15 KiB
JavaScript

// Spike web UI: pipeline list + run detail over the live WebSocket protocol.
// Deliberately small and DOM-only (no framework, no build step). Every value
// that came from the server is set with textContent, never innerHTML.
import { PipelinesClient } from "./client.js";
import { PipelinesRepository } from "./repository.js";
import { validateServerUrl, resolveArtifactUrl } from "./serverUrl.js";
const STORAGE_KEY = "pipelines.web.serverUrl.v2";
/**
* The page is normally served by serve.mjs, which also proxies /connect to the
* Pipelines server. Defaulting to this page's own origin therefore points at
* that proxy and keeps the page and the WebSocket same-origin — the server
* rejects a cross-origin upgrade with 403. Nothing is hardcoded: the value is
* derived from wherever the page was loaded, and the user can override it.
*/
function defaultServerUrl() {
if (typeof location === "undefined" || !location.host) return "";
const scheme = location.protocol === "https:" ? "wss" : "ws";
return `${scheme}://${location.host}/connect`;
}
const client = new PipelinesClient();
const repo = new PipelinesRepository(client);
const state = {
view: "pipelines",
url: localStorage.getItem(STORAGE_KEY) ?? defaultServerUrl(),
connection: client.state,
pipelines: [],
runs: [],
usage: null,
pipelineDetail: null,
runDetail: null,
selectedPipelineId: null,
selectedRunId: null,
loading: false,
error: "",
};
let runPoll = null;
// ---------------------------------------------------------------------------
// DOM helpers
// ---------------------------------------------------------------------------
function h(tag, props = {}, ...children) {
const node = document.createElement(tag);
for (const [key, value] of Object.entries(props)) {
if (value == null || value === false) continue;
if (key === "class") node.className = value;
else if (key === "text") node.textContent = value;
else if (key.startsWith("on") && typeof value === "function") {
node.addEventListener(key.slice(2).toLowerCase(), value);
} else node.setAttribute(key, value === true ? "" : String(value));
}
for (const child of children.flat()) {
if (child == null || child === false) continue;
node.append(child instanceof Node ? child : document.createTextNode(String(child)));
}
return node;
}
function fmtSeconds(total) {
const s = Math.max(0, Math.round(total));
const hh = Math.floor(s / 3600);
const mm = Math.floor((s % 3600) / 60);
const ss = s % 60;
if (hh > 0) return `${hh}h ${mm}m ${ss}s`;
if (mm > 0) return `${mm}m ${ss}s`;
return `${ss}s`;
}
function fmtTime(iso) {
if (!iso) return "—";
const ms = Date.parse(iso);
return Number.isNaN(ms) ? iso : new Date(ms).toLocaleString();
}
function fmtDuration(startIso, finishIso) {
if (!startIso) return "—";
const start = Date.parse(startIso);
if (Number.isNaN(start)) return "—";
const end = finishIso ? Date.parse(finishIso) : Date.now();
if (Number.isNaN(end)) return "—";
// A future start (clock skew) reads as 0s, matching the Android client.
return fmtSeconds(Math.max(0, (end - start) / 1000));
}
function statusClass(status) {
return `chip chip-${String(status || "unknown").toLowerCase()}`;
}
function isExecuting(run) {
return Boolean(run && run.executing);
}
// ---------------------------------------------------------------------------
// Rendering
// ---------------------------------------------------------------------------
const header = h("header", { class: "topbar" });
const content = h("main", { id: "content" });
document.body.append(header, content);
function renderHeader() {
header.replaceChildren(
h("div", { class: "brand" }, h("strong", { text: "Pipelines" }), h("span", { class: "muted", text: "web spike" })),
h(
"div",
{ class: "connbar" },
h("input", {
id: "url",
type: "text",
placeholder: "ws://HOST:PORT/connect",
value: state.url,
spellcheck: "false",
oninput: (e) => {
state.url = e.target.value;
},
}),
h("button", {
id: "connectBtn",
text: state.connection.kind === "connected" ? "Disconnect" : "Connect",
onclick: onConnectClicked,
}),
h("span", { class: "state", id: "stateBadge" }, connectionLabel()),
),
);
}
function connectionLabel() {
const c = state.connection;
switch (c.kind) {
case "connected":
return h("span", { class: "dot ok" }, "connected");
case "connecting":
return h("span", { class: "dot warn" }, `connecting… (attempt ${c.attempt})`);
case "disconnected":
return h("span", { class: "dot bad" }, `disconnected${c.reason ? ` — ${c.reason}` : ""}${c.retrying ? " (retrying)" : ""}`);
default:
return h("span", { class: "dot idle" }, "idle");
}
}
function render() {
renderHeader();
renderContent();
}
function renderContent() {
const nodes = [];
if (state.error) {
nodes.push(h("div", { class: "banner error" }, h("strong", { text: "Error: " }), state.error));
}
nodes.push(
h(
"nav",
{ class: "tabs" },
tabButton("pipelines", `Pipelines (${state.pipelines.length})`),
tabButton("runs", `Runs (${state.runs.length})`),
h("span", { class: "spacer" }),
h("button", { class: "ghost", text: "Refresh", onclick: () => loadCurrentView(true) }),
),
);
const split = h("div", { class: "split" });
if (state.view === "pipelines") {
split.append(renderPipelineList(), renderPipelineDetail());
} else {
split.append(renderRunList(), renderRunDetail());
}
nodes.push(split);
content.replaceChildren(...nodes);
}
function tabButton(view, label) {
return h("button", {
class: `tab${state.view === view ? " active" : ""}`,
text: label,
onclick: () => {
state.view = view;
state.error = "";
renderContent();
if (view === "runs" && !state.runs.length) loadCurrentView();
if (view === "pipelines" && !state.pipelines.length) loadCurrentView();
},
});
}
function renderPipelineList() {
const list = h("div", { class: "list" });
if (state.loading && !state.pipelines.length) {
list.append(h("div", { class: "muted pad", text: "Loading…" }));
return list;
}
if (!state.pipelines.length) {
list.append(h("div", { class: "muted pad", text: "No pipelines." }));
return list;
}
for (const p of state.pipelines) {
list.append(
h(
"button",
{
class: `row${state.selectedPipelineId === p.id ? " selected" : ""}`,
onclick: () => selectPipeline(p),
},
h("span", { class: "row-title", text: p.name || `pipeline ${p.id}` }),
h("span", { class: "row-meta", text: `#${p.id} · v${p.version} · ${p.stages} stage${p.stages === 1 ? "" : "s"}` }),
),
);
}
return list;
}
function renderPipelineDetail() {
const d = state.pipelineDetail;
const pane = h("div", { class: "detail" });
if (!d) {
pane.append(h("div", { class: "muted pad", text: "Select a pipeline." }));
return pane;
}
pane.append(
h("h2", { text: d.name || `pipeline ${d.id}` }),
h(
"div",
{ class: "kv" },
kv("ID / version", `#${d.id} · v${d.version}`),
kv("Stages", String(d.stages ?? (d.graph?.stages?.length ?? 0))),
kv("Content hash", d.content_hash || "—"),
kv("Created", fmtTime(d.created_at)),
kv("Updated", fmtTime(d.updated_at)),
kv("Latest version", d.latest_version ? String(d.latest_version) : "—"),
),
);
const stages = d.graph?.stages ?? [];
if (stages.length) {
pane.append(h("h3", { text: "Stages" }));
const ul = h("ul", { class: "stages" });
for (const s of stages) {
const outcomes = Object.keys(s.edges ?? {}).join(", ");
ul.append(
h(
"li",
{},
h("code", { text: s.key }),
s.type ? h("span", { class: "chip", text: s.type }) : null,
outcomes ? h("span", { class: "muted", text: `→ ${outcomes}` }) : null,
),
);
}
pane.append(ul);
}
return pane;
}
function renderRunList() {
const list = h("div", { class: "list" });
if (state.usage) {
list.append(
h(
"div",
{ class: "usage" },
h("span", { text: `${state.usage.total} total` }),
h("span", { class: "ok", text: `${state.usage.succeeded} succeeded` }),
h("span", { class: "bad", text: `${state.usage.failed} failed` }),
h("span", { class: "warn", text: `${state.usage.active} active` }),
),
);
}
if (state.loading && !state.runs.length) {
list.append(h("div", { class: "muted pad", text: "Loading…" }));
return list;
}
if (!state.runs.length) {
list.append(h("div", { class: "muted pad", text: "No runs." }));
return list;
}
for (const r of state.runs) {
list.append(
h(
"button",
{
class: `row${state.selectedRunId === r.id ? " selected" : ""}`,
onclick: () => selectRun(r.id),
},
h(
"span",
{ class: "row-head" },
h("span", { class: "row-title", text: r.title || r.name || `run ${r.id}` }),
h("span", { class: statusClass(r.status), text: r.status || "unknown" }),
),
h(
"span",
{ class: "row-meta" },
`#${r.id} · ${fmtTime(r.created_at)} · `,
isExecuting(r) ? h("em", { text: fmtDuration(r.created_at, "") }) : fmtDuration(r.created_at, r.finished_at),
),
r.diagnostic ? h("span", { class: "row-diag", text: r.diagnostic }) : null,
),
);
}
return list;
}
function renderRunDetail() {
const d = state.runDetail;
const pane = h("div", { class: "detail" });
if (!d) {
pane.append(h("div", { class: "muted pad", text: "Select a run." }));
return pane;
}
pane.append(
h(
"h2",
{},
d.title || d.name || `run ${d.id}`,
h("span", { class: statusClass(d.status), text: d.status || "unknown" }),
),
h(
"div",
{ class: "kv" },
kv("Run ID", `#${d.id}`),
kv("Pipeline", `#${d.pipeline_id} @ v${d.version}`),
kv("Outcome", d.outcome || "—"),
kv("Current stage", d.current_stage || "—"),
kv("Started", fmtTime(d.created_at)),
kv("Duration", isExecuting(d) ? `${fmtDuration(d.created_at, "")} (running)` : fmtDuration(d.created_at, d.finished_at)),
kv("Completed steps", String(d.completed_steps ?? 0)),
d.diagnostic ? kv("Diagnostic", d.diagnostic) : null,
),
);
const steps = d.steps ?? [];
pane.append(h("h3", { text: `Steps (${steps.length})` }));
if (!steps.length) {
pane.append(h("div", { class: "muted pad", text: "No steps recorded yet." }));
return pane;
}
const list = h("div", { class: "steps" });
for (const s of steps) {
list.append(
h(
"div",
{ class: "step" },
h(
"div",
{ class: "step-head" },
h("code", { text: `${s.sequence}. ${s.stage}` }),
h("span", { class: statusClass(s.status), text: s.status || "unknown" }),
s.outcome ? h("span", { class: "chip", text: s.outcome }) : null,
h("span", { class: "muted", text: fmtDuration(s.started_at, s.finished_at) }),
),
h(
"div",
{ class: "kv tight" },
kv("Target", s.target || "—"),
kv("Visit", s.control ? `${s.control.visit}/${s.control.max_visits}` : "—"),
kv("Session", s.session_id || "—"),
s.diagnostic ? kv("Diagnostic", s.diagnostic) : null,
),
renderArtifacts(s),
),
);
}
pane.append(list);
return pane;
}
function renderArtifacts(step) {
const artifacts = step.artifacts ?? [];
if (!artifacts.length) return null;
const wrap = h("div", { class: "artifacts" }, h("span", { class: "muted", text: "Artifacts: " }));
for (const a of artifacts) {
const href = resolveArtifactUrl(state.url, a.url);
if (href) {
wrap.append(h("a", { href, target: "_blank", rel: "noreferrer", text: a.name || a.url }));
} else {
wrap.append(h("span", { class: "muted", text: `${a.name || a.url} (no server URL)` }));
}
}
return wrap;
}
function kv(key, value) {
return h(
"div",
{ class: "kv-row" },
h("span", { class: "kv-key", text: key }),
h("span", { class: "kv-val", text: value }),
);
}
// ---------------------------------------------------------------------------
// Actions
// ---------------------------------------------------------------------------
function setError(err) {
state.error = err instanceof Error ? err.message : String(err);
state.loading = false;
renderContent();
}
function onConnectClicked() {
if (state.connection.kind === "connected") {
repo.disconnect();
stopRunPoll();
return;
}
const validated = validateServerUrl(state.url);
if (!validated.valid) {
state.error = validated.message;
renderContent();
return;
}
state.error = "";
localStorage.setItem(STORAGE_KEY, state.url.trim());
repo.connect(validated);
// The `state` listener kicks off the initial load once connected.
}
async function onConnected() {
try {
await repo.ping();
} catch (err) {
setError(err);
return;
}
await loadCurrentView();
}
async function loadCurrentView(force = false) {
if (state.connection.kind !== "connected") {
state.error = "Connect to the server first.";
renderContent();
return;
}
state.loading = true;
state.error = "";
renderContent();
try {
if (state.view === "pipelines") {
state.pipelines = await repo.listPipelines();
} else {
const { runs, usage } = await repo.listRuns();
state.runs = runs;
state.usage = usage;
}
state.loading = false;
renderContent();
// Keep the current selection fresh after a refresh.
if (force && state.view === "runs" && state.selectedRunId) {
await selectRun(state.selectedRunId, { silent: true });
}
} catch (err) {
setError(err);
}
}
async function selectPipeline(summary) {
state.selectedPipelineId = summary.id;
state.pipelineDetail = null;
renderContent();
try {
state.pipelineDetail = await repo.getPipeline(summary.id, summary.version);
renderContent();
} catch (err) {
setError(err);
}
}
async function selectRun(id, { silent = false } = {}) {
state.selectedRunId = id;
if (!silent) {
state.runDetail = null;
renderContent();
}
try {
state.runDetail = await repo.getRun(id);
renderContent();
updateRunPoll();
} catch (err) {
if (!silent) setError(err);
else stopRunPoll();
}
}
function updateRunPoll() {
stopRunPoll();
if (state.view === "runs" && state.selectedRunId && isExecuting(state.runDetail)) {
runPoll = setInterval(() => selectRun(state.selectedRunId, { silent: true }), 1000);
}
}
function stopRunPoll() {
if (runPoll) {
clearInterval(runPoll);
runPoll = null;
}
}
// ---------------------------------------------------------------------------
// Boot
// ---------------------------------------------------------------------------
client.addEventListener("state", (event) => {
const next = event.detail;
const wasConnected = state.connection.kind === "connected";
const previousKind = state.connection.kind;
state.connection = next;
if (next.kind === "connected" && !wasConnected) {
onConnected();
}
if (next.kind !== "connected" && previousKind === "connected") {
stopRunPoll();
}
render();
});
// Prefill from a previous session only; the user still confirms with Connect.
render();