Files
pipelines/web/src/client.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

234 lines
6.6 KiB
JavaScript

// 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;
}
}
}