pipane 0.1.5 → 0.1.7

package/dist/server/server/rendezvous-client.js

@@ -0,0 +1,282 @@
+import { WebSocket } from "ws";
+import { RENDEZVOUS_PROTOCOL_VERSION, decodeBackendMessage, encodeRendezvousMessage, rendezvousWebSocketUrl, } from "../shared/rendezvous-protocol.js";
+import { signBackendChallenge } from "./backend-identity.js";
+export { rendezvousWebSocketUrl } from "../shared/rendezvous-protocol.js";
+export class BackendRendezvousClient {
+    endpoint;
+    identity;
+    metadata;
+    createWebSocket;
+    schedule;
+    cancelSchedule;
+    maxReconnectDelayMs;
+    statusListeners = new Set();
+    connectionListeners = new Set();
+    signalListeners = new Set();
+    closedListeners = new Set();
+    revocationListeners = new Set();
+    errorListeners = new Set();
+    activePairings = new Map();
+    pairingResolvers = new Map();
+    confirmationResolvers = new Map();
+    socket = null;
+    reconnectTimer;
+    reconnectAttempt = 0;
+    stopped = true;
+    registered = false;
+    firstRegistrationSettled = false;
+    firstRegistration;
+    resolveFirstRegistration;
+    rejectFirstRegistration;
+    _ticketPublicKey;
+    _iceServers = [];
+    constructor(options) {
+        this.endpoint = rendezvousWebSocketUrl(options.url, "backend");
+        this.identity = options.identity;
+        this.metadata = options.metadata;
+        this.createWebSocket = options.createWebSocket ?? ((url) => new WebSocket(url));
+        this.schedule = options.schedule ?? globalThis.setTimeout.bind(globalThis);
+        this.cancelSchedule = options.cancelSchedule ?? globalThis.clearTimeout.bind(globalThis);
+        this.maxReconnectDelayMs = options.maxReconnectDelayMs ?? 10_000;
+        this.firstRegistration = new Promise((resolve, reject) => {
+            this.resolveFirstRegistration = resolve;
+            this.rejectFirstRegistration = reject;
+        });
+    }
+    get isRegistered() {
+        return this.registered;
+    }
+    get ticketPublicKey() {
+        if (!this._ticketPublicKey)
+            throw new Error("Rendezvous ticket verification key is unavailable");
+        return this._ticketPublicKey;
+    }
+    get iceServers() {
+        return this._iceServers.map((server) => ({
+            ...server,
+            urls: Array.isArray(server.urls) ? [...server.urls] : server.urls,
+        }));
+    }
+    start() {
+        if (this.stopped) {
+            this.stopped = false;
+            this.open();
+        }
+        return this.firstRegistration;
+    }
+    stop() {
+        if (this.stopped)
+            return;
+        this.stopped = true;
+        this.registered = false;
+        if (this.reconnectTimer) {
+            this.cancelSchedule(this.reconnectTimer);
+            this.reconnectTimer = undefined;
+        }
+        const error = new Error("Rendezvous client stopped");
+        if (!this.firstRegistrationSettled) {
+            this.firstRegistrationSettled = true;
+            this.rejectFirstRegistration(error);
+        }
+        for (const pending of this.pairingResolvers.values())
+            pending.reject(error);
+        for (const pending of this.confirmationResolvers.values())
+            pending.reject(error);
+        this.pairingResolvers.clear();
+        this.confirmationResolvers.clear();
+        this.socket?.close(1000, "Backend stopped");
+        this.socket = null;
+    }
+    onStatus(listener) {
+        this.statusListeners.add(listener);
+        return () => this.statusListeners.delete(listener);
+    }
+    onConnectionRequest(listener) {
+        this.connectionListeners.add(listener);
+        return () => this.connectionListeners.delete(listener);
+    }
+    onSignal(listener) {
+        this.signalListeners.add(listener);
+        return () => this.signalListeners.delete(listener);
+    }
+    onConnectionClosed(listener) {
+        this.closedListeners.add(listener);
+        return () => this.closedListeners.delete(listener);
+    }
+    onAuthorizationRevoked(listener) {
+        this.revocationListeners.add(listener);
+        return () => this.revocationListeners.delete(listener);
+    }
+    onError(listener) {
+        this.errorListeners.add(listener);
+        return () => this.errorListeners.delete(listener);
+    }
+    openPairing(pairId, expiresAt) {
+        this.activePairings.set(pairId, expiresAt);
+        const existing = this.pairingResolvers.get(pairId);
+        if (existing)
+            return Promise.reject(new Error("Pairing request is already pending"));
+        const promise = new Promise((resolve, reject) => this.pairingResolvers.set(pairId, { resolve, reject }));
+        if (this.registered)
+            this.send({ type: "open_pairing", pairId, expiresAt });
+        return promise;
+    }
+    confirmPairing(connectionId) {
+        if (this.confirmationResolvers.has(connectionId))
+            return Promise.reject(new Error("Pairing confirmation is already pending"));
+        const promise = new Promise((resolve, reject) => {
+            this.confirmationResolvers.set(connectionId, { resolve, reject });
+        });
+        this.send({ type: "confirm_pairing", connectionId });
+        return promise;
+    }
+    sendSignal(connectionId, signal) {
+        this.send({ type: "signal", connectionId, signal });
+    }
+    sendIdentityBinding(connectionId, binding) {
+        this.send({ type: "connection_binding", connectionId, binding });
+    }
+    closeConnection(connectionId, reason) {
+        this.send({ type: "close_connection", connectionId, reason });
+    }
+    open() {
+        if (this.stopped)
+            return;
+        const socket = this.createWebSocket(this.endpoint);
+        this.socket = socket;
+        socket.on("message", (raw) => this.handleMessage(socket, raw.toString()));
+        socket.on("error", (error) => this.emitError(error));
+        socket.on("close", () => {
+            if (this.socket !== socket)
+                return;
+            this.socket = null;
+            const interruption = new Error("Rendezvous disconnected during pairing confirmation");
+            for (const pending of this.confirmationResolvers.values())
+                pending.reject(interruption);
+            this.confirmationResolvers.clear();
+            const wasRegistered = this.registered;
+            this.registered = false;
+            if (wasRegistered)
+                this.emitStatus(false);
+            if (!this.stopped)
+                this.scheduleReconnect();
+        });
+    }
+    handleMessage(socket, raw) {
+        if (socket !== this.socket)
+            return;
+        const decoded = decodeBackendMessage(raw);
+        if (!decoded.ok) {
+            this.emitError(new Error(decoded.error.message));
+            socket.close(1002, "Invalid rendezvous message");
+            return;
+        }
+        const message = decoded.value;
+        switch (message.type) {
+            case "challenge":
+                this.sendRaw({
+                    type: "register_backend",
+                    publicKey: this.identity.publicKey,
+                    signature: signBackendChallenge(this.identity, message.nonce),
+                    metadata: this.metadata,
+                });
+                break;
+            case "registered":
+                if (message.backendId !== this.identity.backendId) {
+                    this.emitError(new Error("Rendezvous registered an unexpected backend identity"));
+                    socket.close(1002, "Backend identity mismatch");
+                    return;
+                }
+                this._ticketPublicKey = message.ticketPublicKey;
+                this._iceServers = message.iceServers;
+                this.registered = true;
+                this.reconnectAttempt = 0;
+                this.emitStatus(true);
+                if (!this.firstRegistrationSettled) {
+                    this.firstRegistrationSettled = true;
+                    this.resolveFirstRegistration(message.backendId);
+                }
+                for (const [pairId, expiresAt] of this.activePairings) {
+                    if (expiresAt > Date.now())
+                        this.send({ type: "open_pairing", pairId, expiresAt });
+                    else
+                        this.activePairings.delete(pairId);
+                }
+                break;
+            case "pairing_opened": {
+                const pending = this.pairingResolvers.get(message.pairId);
+                this.pairingResolvers.delete(message.pairId);
+                pending?.resolve();
+                break;
+            }
+            case "pairing_confirmed": {
+                const pending = this.confirmationResolvers.get(message.connectionId);
+                this.confirmationResolvers.delete(message.connectionId);
+                this.activePairings.delete(message.pairId);
+                pending?.resolve(message);
+                break;
+            }
+            case "connection_request":
+                for (const listener of this.connectionListeners)
+                    listener({
+                        connectionId: message.connectionId,
+                        ticket: message.ticket,
+                        iceServers: message.iceServers,
+                    });
+                break;
+            case "signal":
+                for (const listener of this.signalListeners)
+                    listener(message.connectionId, message.signal);
+                break;
+            case "connection_closed": {
+                const pending = this.confirmationResolvers.get(message.connectionId);
+                this.confirmationResolvers.delete(message.connectionId);
+                pending?.reject(new Error(message.reason));
+                for (const listener of this.closedListeners)
+                    listener(message.connectionId, message.reason);
+                break;
+            }
+            case "authorization_revoked":
+                for (const listener of this.revocationListeners)
+                    listener(message);
+                break;
+            case "error": {
+                this.emitError(message);
+                if (message.connectionId) {
+                    const pending = this.confirmationResolvers.get(message.connectionId);
+                    this.confirmationResolvers.delete(message.connectionId);
+                    pending?.reject(new Error(message.message));
+                }
+                break;
+            }
+        }
+    }
+    send(command) {
+        if (!this.registered)
+            throw new Error("Backend is not registered with rendezvous");
+        this.sendRaw(command);
+    }
+    sendRaw(command) {
+        if (!this.socket || this.socket.readyState !== WebSocket.OPEN)
+            throw new Error("Rendezvous WebSocket is not connected");
+        this.socket.send(encodeRendezvousMessage({ protocolVersion: RENDEZVOUS_PROTOCOL_VERSION, ...command }));
+    }
+    scheduleReconnect() {
+        if (this.reconnectTimer || this.stopped)
+            return;
+        this.reconnectAttempt++;
+        const delay = Math.min(500 * 2 ** (this.reconnectAttempt - 1), this.maxReconnectDelayMs);
+        this.reconnectTimer = this.schedule(() => {
+            this.reconnectTimer = undefined;
+            this.open();
+        }, delay);
+    }
+    emitStatus(connected) {
+        for (const listener of this.statusListeners)
+            listener(connected);
+    }
+    emitError(error) {
+        for (const listener of this.errorListeners)
+            listener(error);
+    }
+}