bd09c55c47
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.
234 lines
6.6 KiB
JavaScript
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;
|
|
}
|
|
}
|
|
}
|