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.
This commit is contained in:
+522
@@ -0,0 +1,522 @@
|
||||
// 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();
|
||||
@@ -0,0 +1,233 @@
|
||||
// A single, reused WebSocket connection to /connect, mirroring
|
||||
// android/.../data/transport/PipelinesClient.kt: requests are serialized, each
|
||||
// carries a client-generated stable id, replies are matched by id, and
|
||||
// unsolicited envelopes are dropped. There is no authentication of any kind.
|
||||
//
|
||||
// DOM-free on purpose: the browser app and the Node smoke test share this exact
|
||||
// module, so the smoke test exercises the real client, not a re-implementation.
|
||||
|
||||
import { Protocol } from "./protocol.js";
|
||||
|
||||
/** A server `type:"error"` reply, surfaced with the server's own text. */
|
||||
export class ProtocolError extends Error {
|
||||
constructor(message) {
|
||||
super(message);
|
||||
this.name = "ProtocolError";
|
||||
}
|
||||
}
|
||||
|
||||
/** No live WebSocket connection is available for the request. */
|
||||
export class NotConnectedError extends Error {
|
||||
constructor(message = "Not connected to the Pipelines server") {
|
||||
super(message);
|
||||
this.name = "NotConnectedError";
|
||||
}
|
||||
}
|
||||
|
||||
const IDLE = "idle";
|
||||
const CONNECTING = "connecting";
|
||||
const CONNECTED = "connected";
|
||||
const DISCONNECTED = "disconnected";
|
||||
const NORMAL_CLOSURE = 1000;
|
||||
|
||||
export class PipelinesClient extends EventTarget {
|
||||
#WebSocketImpl;
|
||||
#backoffBaseMs;
|
||||
#backoffMaxMs;
|
||||
#requestTimeoutMs;
|
||||
#random;
|
||||
|
||||
#ws = null;
|
||||
#endpoint = null;
|
||||
#manualClose = false;
|
||||
#attempt = 0;
|
||||
#seq = 0;
|
||||
#pending = new Map(); // id -> { resolve, reject, timer }
|
||||
#queue = Promise.resolve();
|
||||
#reconnectTimer = null;
|
||||
|
||||
#state = { kind: IDLE, attempt: 0, reason: "", retrying: false };
|
||||
|
||||
constructor({
|
||||
WebSocketImpl = globalThis.WebSocket,
|
||||
backoffBaseMs = 1000,
|
||||
backoffMaxMs = 30000,
|
||||
requestTimeoutMs = 30000,
|
||||
random = Math.random,
|
||||
} = {}) {
|
||||
super();
|
||||
if (typeof WebSocketImpl !== "function") {
|
||||
throw new Error("No WebSocket implementation available");
|
||||
}
|
||||
this.#WebSocketImpl = WebSocketImpl;
|
||||
this.#backoffBaseMs = backoffBaseMs;
|
||||
this.#backoffMaxMs = backoffMaxMs;
|
||||
this.#requestTimeoutMs = requestTimeoutMs;
|
||||
this.#random = random;
|
||||
}
|
||||
|
||||
get state() {
|
||||
return { ...this.#state };
|
||||
}
|
||||
|
||||
#setState(next) {
|
||||
this.#state = next;
|
||||
this.dispatchEvent(new CustomEvent("state", { detail: this.state }));
|
||||
}
|
||||
|
||||
/** Opens (or re-opens) the connection to a validated server URL. */
|
||||
connect(validated) {
|
||||
if (!validated || !validated.valid) {
|
||||
throw new Error("server URL is not valid");
|
||||
}
|
||||
this.#endpoint = validated.wsUrl;
|
||||
this.#manualClose = false;
|
||||
this.#attempt = 0;
|
||||
this.#clearReconnect();
|
||||
this.#open();
|
||||
}
|
||||
|
||||
/** Explicit user disconnect: stops reconnection and closes the socket. */
|
||||
disconnect() {
|
||||
this.#manualClose = true;
|
||||
this.#clearReconnect();
|
||||
const socket = this.#ws;
|
||||
this.#ws = null;
|
||||
try {
|
||||
socket?.close(NORMAL_CLOSURE, "client closing");
|
||||
} catch {
|
||||
/* already closed */
|
||||
}
|
||||
this.#failPending("Disconnected");
|
||||
this.#setState({ kind: IDLE, attempt: 0, reason: "", retrying: false });
|
||||
}
|
||||
|
||||
/**
|
||||
* Sends one request and awaits the reply with the matching id. Serialized by a
|
||||
* promise chain so concurrent screens cannot interleave frames.
|
||||
*/
|
||||
async call(request) {
|
||||
const run = this.#queue.then(() => this.#doCall(request));
|
||||
// Keep the chain alive even when a call rejects.
|
||||
this.#queue = run.then(
|
||||
() => undefined,
|
||||
() => undefined,
|
||||
);
|
||||
return run;
|
||||
}
|
||||
|
||||
async #doCall(request) {
|
||||
const socket = this.#ws;
|
||||
if (!socket || this.#state.kind !== CONNECTED) throw new NotConnectedError();
|
||||
const id = `web-${++this.#seq}`;
|
||||
const payload = JSON.stringify({ ...request, id });
|
||||
|
||||
const reply = new Promise((resolve, reject) => {
|
||||
const timer = setTimeout(() => {
|
||||
this.#pending.delete(id);
|
||||
reject(new Error(`request timed out after ${this.#requestTimeoutMs}ms`));
|
||||
}, this.#requestTimeoutMs);
|
||||
this.#pending.set(id, { resolve, reject, timer });
|
||||
});
|
||||
|
||||
try {
|
||||
socket.send(payload);
|
||||
const response = await reply;
|
||||
if (response.type === Protocol.ERROR) {
|
||||
throw new ProtocolError((response.error || "").trim() || "server error");
|
||||
}
|
||||
return response;
|
||||
} finally {
|
||||
const entry = this.#pending.get(id);
|
||||
if (entry) {
|
||||
clearTimeout(entry.timer);
|
||||
this.#pending.delete(id);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#open() {
|
||||
const current = this.#endpoint;
|
||||
if (!current) return;
|
||||
this.#attempt += 1;
|
||||
this.#setState({
|
||||
kind: CONNECTING,
|
||||
attempt: this.#attempt,
|
||||
reason: "",
|
||||
retrying: false,
|
||||
});
|
||||
const socket = new this.#WebSocketImpl(current);
|
||||
this.#ws = socket;
|
||||
socket.onopen = () => {
|
||||
this.#attempt = 0;
|
||||
this.#setState({ kind: CONNECTED, attempt: 0, reason: "", retrying: false });
|
||||
};
|
||||
socket.onmessage = (event) => this.#onMessage(event.data);
|
||||
socket.onclose = (event) => {
|
||||
this.#handleClosed(`Connection closed (${event.code ?? "?"})`);
|
||||
};
|
||||
socket.onerror = () => {
|
||||
// Browsers withhold detail here; onclose carries the outcome.
|
||||
};
|
||||
}
|
||||
|
||||
#onMessage(data) {
|
||||
if (typeof data !== "string") return; // the server is text-only
|
||||
let message;
|
||||
try {
|
||||
message = JSON.parse(data);
|
||||
} catch {
|
||||
return; // malformed frame: never misattribute it to a request
|
||||
}
|
||||
const entry = message.id ? this.#pending.get(message.id) : null;
|
||||
if (entry) {
|
||||
this.#pending.delete(message.id);
|
||||
clearTimeout(entry.timer);
|
||||
entry.resolve(message);
|
||||
}
|
||||
// Unsolicited envelopes (for example the connection's initial pipeline_list)
|
||||
// have no matching id and are intentionally dropped.
|
||||
}
|
||||
|
||||
#failPending(reason) {
|
||||
for (const [id, entry] of this.#pending) {
|
||||
this.#pending.delete(id);
|
||||
clearTimeout(entry.timer);
|
||||
entry.reject(new Error(reason));
|
||||
}
|
||||
}
|
||||
|
||||
#handleClosed(reason) {
|
||||
this.#ws = null;
|
||||
this.#failPending(reason);
|
||||
if (this.#manualClose) {
|
||||
this.#setState({ kind: IDLE, attempt: 0, reason: "", retrying: false });
|
||||
return;
|
||||
}
|
||||
this.#scheduleReconnect(reason);
|
||||
}
|
||||
|
||||
#scheduleReconnect(reason) {
|
||||
if (this.#reconnectTimer) return;
|
||||
this.#setState({
|
||||
kind: DISCONNECTED,
|
||||
attempt: this.#attempt,
|
||||
reason,
|
||||
retrying: true,
|
||||
});
|
||||
const shift = Math.min(Math.max(this.#attempt - 1, 0), 6);
|
||||
const backoff = Math.min(this.#backoffBaseMs << shift, this.#backoffMaxMs);
|
||||
const jitter = Math.floor(this.#random() * 400);
|
||||
this.#reconnectTimer = setTimeout(() => {
|
||||
this.#reconnectTimer = null;
|
||||
if (!this.#manualClose && this.#endpoint) this.#open();
|
||||
}, backoff + jitter);
|
||||
}
|
||||
|
||||
#clearReconnect() {
|
||||
if (this.#reconnectTimer) {
|
||||
clearTimeout(this.#reconnectTimer);
|
||||
this.#reconnectTimer = null;
|
||||
}
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,31 @@
|
||||
// Protocol command/type constants. Mirrors the subset of
|
||||
// android/app/src/main/java/net/awan/pipelines/data/protocol/Message.kt and
|
||||
// internal/protocol/*.go used by this spike, so renames cannot drift silently.
|
||||
export const Protocol = Object.freeze({
|
||||
PING: "ping",
|
||||
PONG: "pong",
|
||||
ERROR: "error",
|
||||
|
||||
LIST: "list_pipelines",
|
||||
PIPELINE_LIST: "pipelines",
|
||||
GET_PIPELINE: "get_pipeline",
|
||||
PIPELINE: "pipeline",
|
||||
|
||||
LIST_RUNS: "list_runs",
|
||||
RUNS: "runs",
|
||||
GET_RUN: "get_run",
|
||||
RUN: "run",
|
||||
|
||||
SUCCESS_END: "#success",
|
||||
FAILURE_END: "#failure",
|
||||
});
|
||||
|
||||
export function isTerminal(target) {
|
||||
return target === Protocol.SUCCESS_END || target === Protocol.FAILURE_END;
|
||||
}
|
||||
|
||||
/** Mirrors protocol.ResolveTarget: preserve the # shorthand as an explicit terminal. */
|
||||
export function resolveTarget(outcome, target) {
|
||||
if (target !== "#") return target;
|
||||
return outcome === "error" ? Protocol.FAILURE_END : Protocol.SUCCESS_END;
|
||||
}
|
||||
@@ -0,0 +1,61 @@
|
||||
// Typed access to the existing WebSocket protocol. Request builders and id
|
||||
// matching live here so the app never constructs frames by hand or invents
|
||||
// divergent field names. Mirrors android/.../data/PipelinesRepository.kt.
|
||||
import { Protocol } from "./protocol.js";
|
||||
import { ProtocolError } from "./client.js";
|
||||
|
||||
export class PipelinesRepository {
|
||||
#client;
|
||||
|
||||
constructor(client) {
|
||||
this.#client = client;
|
||||
}
|
||||
|
||||
get connectionState() {
|
||||
return this.#client.state;
|
||||
}
|
||||
|
||||
connect(validated) {
|
||||
this.#client.connect(validated);
|
||||
}
|
||||
|
||||
disconnect() {
|
||||
this.#client.disconnect();
|
||||
}
|
||||
|
||||
ping() {
|
||||
return this.#client.call({ type: Protocol.PING });
|
||||
}
|
||||
|
||||
async listPipelines() {
|
||||
return (await this.#client.call({ type: Protocol.LIST })).pipelines ?? [];
|
||||
}
|
||||
|
||||
async getPipeline(id, version) {
|
||||
const response = await this.#client.call({
|
||||
type: Protocol.GET_PIPELINE,
|
||||
pipeline_id: id,
|
||||
version,
|
||||
});
|
||||
if (!response.detail) {
|
||||
throw new ProtocolError("The server returned no pipeline detail.");
|
||||
}
|
||||
return response.detail;
|
||||
}
|
||||
|
||||
async listRuns() {
|
||||
const response = await this.#client.call({ type: Protocol.LIST_RUNS });
|
||||
return { runs: response.runs ?? [], usage: response.usage ?? null };
|
||||
}
|
||||
|
||||
async getRun(id) {
|
||||
const response = await this.#client.call({
|
||||
type: Protocol.GET_RUN,
|
||||
run_id: id,
|
||||
});
|
||||
if (!response.run_detail) {
|
||||
throw new ProtocolError("The server returned no run detail.");
|
||||
}
|
||||
return response.run_detail;
|
||||
}
|
||||
}
|
||||
@@ -0,0 +1,107 @@
|
||||
// Server-URL validation mirroring android/.../data/transport/ServerUrl.kt and
|
||||
// internal/client/config.go: only ws/wss with a non-empty hostname and no
|
||||
// userinfo/fragment. The endpoint path defaults to /connect, matching
|
||||
// internal/server/websocket.go `GET /connect`.
|
||||
|
||||
export const ServerUrlKind = Object.freeze({
|
||||
EMPTY: "EMPTY",
|
||||
MALFORMED: "MALFORMED",
|
||||
UNSUPPORTED_SCHEME: "UNSUPPORTED_SCHEME",
|
||||
MISSING_HOST: "MISSING_HOST",
|
||||
USER_INFO: "USER_INFO",
|
||||
FRAGMENT: "FRAGMENT",
|
||||
});
|
||||
|
||||
/**
|
||||
* @returns {{valid:true, wsUrl:string, httpUrl:string, host:string, port:number, secure:boolean}
|
||||
* |{valid:false, kind:string, message:string}}
|
||||
*/
|
||||
export function validateServerUrl(raw) {
|
||||
const trimmed = (raw ?? "").trim();
|
||||
if (!trimmed) {
|
||||
return {
|
||||
valid: false,
|
||||
kind: ServerUrlKind.EMPTY,
|
||||
message:
|
||||
"Enter the Pipelines server URL, for example ws://192.168.1.20:8081/connect",
|
||||
};
|
||||
}
|
||||
|
||||
let url;
|
||||
try {
|
||||
url = new URL(trimmed);
|
||||
} catch {
|
||||
return {
|
||||
valid: false,
|
||||
kind: ServerUrlKind.MALFORMED,
|
||||
message: "That is not a valid URL.",
|
||||
};
|
||||
}
|
||||
|
||||
const scheme = url.protocol.replace(/:$/, "").toLowerCase();
|
||||
if (scheme !== "ws" && scheme !== "wss") {
|
||||
return {
|
||||
valid: false,
|
||||
kind: ServerUrlKind.UNSUPPORTED_SCHEME,
|
||||
message: `Unsupported scheme "${scheme}"; use ws:// (trusted LAN/VPN) or wss://`,
|
||||
};
|
||||
}
|
||||
if (url.username || url.password) {
|
||||
return {
|
||||
valid: false,
|
||||
kind: ServerUrlKind.USER_INFO,
|
||||
message:
|
||||
"Credentials are not supported; the server has no authentication. Remove userinfo from the URL",
|
||||
};
|
||||
}
|
||||
if (url.hash) {
|
||||
return {
|
||||
valid: false,
|
||||
kind: ServerUrlKind.FRAGMENT,
|
||||
message: "Remove the # fragment; it is not part of the server endpoint",
|
||||
};
|
||||
}
|
||||
if (!url.hostname) {
|
||||
return {
|
||||
valid: false,
|
||||
kind: ServerUrlKind.MISSING_HOST,
|
||||
message:
|
||||
"The URL is missing a host, for example ws://192.168.1.20:8081/connect",
|
||||
};
|
||||
}
|
||||
|
||||
const secure = scheme === "wss";
|
||||
const port = url.port ? Number(url.port) : secure ? 443 : 80;
|
||||
let path = url.pathname || "";
|
||||
if (!path || path === "/") path = "/connect";
|
||||
|
||||
const authority = url.host; // host + explicit port only when present
|
||||
const search = url.search || "";
|
||||
const wsUrl = `${scheme}://${authority}${path}${search}`;
|
||||
const httpUrl = `${secure ? "https" : "http"}://${authority}${path}${search}`;
|
||||
|
||||
return { valid: true, wsUrl, httpUrl, host: url.hostname, port, secure };
|
||||
}
|
||||
|
||||
/**
|
||||
* Resolves a server-relative artifact url (for example "/artifacts/55/4/shot.png")
|
||||
* against the configured server URL by mapping ws/wss to http/https and dropping
|
||||
* the /connect path. Never hardcodes a host: a blank or invalid configuration, or
|
||||
* a blank path, yields null so the UI can disable actions. An already-absolute
|
||||
* http(s) url is returned unchanged. Mirrors ServerUrl.resolveArtifactUrl.
|
||||
*/
|
||||
export function resolveArtifactUrl(configured, artifactUrl) {
|
||||
const relative = (artifactUrl ?? "").trim();
|
||||
if (!relative) return null;
|
||||
if (relative.startsWith("http://") || relative.startsWith("https://")) {
|
||||
return relative;
|
||||
}
|
||||
const validated = validateServerUrl(configured);
|
||||
if (!validated.valid) return null;
|
||||
const { secure, host, port } = validated;
|
||||
const defaultPort = secure ? 443 : 80;
|
||||
const authority = port && port !== defaultPort ? `${host}:${port}` : host;
|
||||
const origin = `${secure ? "https" : "http"}://${authority}`;
|
||||
const path = relative.startsWith("/") ? relative : `/${relative}`;
|
||||
return origin + path;
|
||||
}
|
||||
Reference in New Issue
Block a user