// 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();