@abraca/dabra 1.0.21 → 1.0.23

package/src/webrtc/DevicePairingChannel.ts

@@ -12,7 +12,7 @@
 
 import { sha256 } from "@noble/hashes/sha256";
 import EventEmitter from "../EventEmitter.ts";
-import type { AbracadabraClient } from "../AbracadabraClient.ts";
+import { AbracadabraClient } from "../AbracadabraClient.ts";
 import { AbracadabraWebRTC } from "./AbracadabraWebRTC.ts";
 import type { E2EEIdentity } from "./E2EEChannel.ts";
 
@@ -22,6 +22,7 @@ import type { E2EEIdentity } from "./E2EEChannel.ts";
 const CODE_CHARSET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
 const CODE_LENGTH = 6;
 const PAIRING_TIMEOUT_MS = 5 * 60 * 1000; // 5 minutes
+const SIGNALING_CONNECT_TIMEOUT_MS = 5_000; // 5 seconds before trying fallback
 const PAIRING_CHANNEL = "device-pairing";
 
 // ── Types ───────────────────────────────────────────────────────────────────
@@ -29,12 +30,22 @@ const PAIRING_CHANNEL = "device-pairing";
 export interface DevicePairingConfig {
 	/** Server base URL (http/https). */
 	serverUrl: string;
-	/** JWT token or async token factory for signaling auth. */
-	token: string | (() => string) | (() => Promise<string>);
+	/**
+	 * JWT token or async token factory for signaling auth.
+	 * When omitted, a short-lived anonymous pairing token is fetched automatically
+	 * from `POST /auth/pairing-token`.
+	 */
+	token?: string | (() => string) | (() => Promise<string>);
 	/** E2EE identity (Ed25519 public key + X25519 private key). */
 	e2ee: E2EEIdentity;
 	/** ICE servers. Defaults to Google STUN. */
 	iceServers?: RTCIceServer[];
+	/**
+	 * Fallback signaling server URL. If the primary server is unreachable,
+	 * signaling will retry through this server. The actual pairing data is
+	 * E2EE-encrypted, so the relay server cannot read it.
+	 */
+	fallbackSignalingUrl?: string;
 	/** WebSocket polyfill (for Node.js). */
 	WebSocketPolyfill?: any;
 }
@@ -106,6 +117,8 @@ export class DevicePairingChannel extends EventEmitter {
 	private _destroyed = false;
 	private _pendingRequest: PairingRequest | null = null;
 	private _connectedPeerId: string | null = null;
+	private _usingFallback = false;
+	private _resolvedIceServers: RTCIceServer[] | undefined;
 
 	readonly role: PairingRole;
 	readonly pairingCode: string;
@@ -279,14 +292,66 @@ export class DevicePairingChannel extends EventEmitter {
 
 	// ── Private ─────────────────────────────────────────────────────────
 
+	private async resolveToken(
+		serverUrl?: string,
+	): Promise<string | (() => string) | (() => Promise<string>)> {
+		// Use provided token if connecting to the primary server.
+		if (this.config.token && serverUrl === this.config.serverUrl) {
+			return this.config.token;
+		}
+
+		// Fetch a short-lived anonymous pairing token from the target server.
+		let base = serverUrl ?? this.config.serverUrl;
+		while (base.endsWith("/")) base = base.slice(0, -1);
+		const resp = await fetch(`${base}/auth/pairing-token`, {
+			method: "POST",
+		});
+		if (!resp.ok) {
+			throw new Error(
+				`Failed to fetch pairing token: ${resp.status} ${resp.statusText}`,
+			);
+		}
+		const { token } = (await resp.json()) as { token: string };
+		return token;
+	}
+
 	private start(): void {
+		this.connectToServer(this.config.serverUrl);
+
+		// Auto-destroy after timeout.
+		this.timeoutHandle = setTimeout(() => {
+			if (!this._destroyed) {
+				this.emit("error", new Error("Pairing timed out"));
+				this.destroy();
+			}
+		}, PAIRING_TIMEOUT_MS);
+	}
+
+	private connectToServer(serverUrl: string, signalingUrl?: string): void {
 		const roomId = codeToRoomId(this.pairingCode);
 
+		// Resolve token (possibly async) — uses a factory so SignalingSocket can await it.
+		const tokenPromise = this.resolveToken(serverUrl);
+		const tokenFactory = async (): Promise<string> => {
+			const t = await tokenPromise;
+			if (typeof t === "function") return await t();
+			return t;
+		};
+
+		// Fetch ICE servers from the target server if none configured.
+		if (!this.config.iceServers) {
+			const client = new AbracadabraClient({ url: serverUrl });
+			client.getIceServers().then((servers) => {
+				if (servers.length > 0) this._resolvedIceServers = servers;
+			});
+		}
+
 		this.webrtc = new AbracadabraWebRTC({
 			docId: roomId,
-			url: this.config.serverUrl,
-			token: this.config.token,
-			iceServers: this.config.iceServers,
+			url: serverUrl,
+			signalingUrl: signalingUrl ?? undefined,
+			token: tokenFactory,
+			iceServers: this.config.iceServers ?? this._resolvedIceServers,
 			e2ee: this.config.e2ee,
 			enableDocSync: false,
 			enableAwarenessSync: false,
@@ -295,6 +360,12 @@ export class DevicePairingChannel extends EventEmitter {
 			WebSocketPolyfill: this.config.WebSocketPolyfill,
 		});
 
+		let connected = false;
+
+		this.webrtc.on("connected", () => {
+			connected = true;
+		});
+
 		this.webrtc.on("e2eeEstablished", ({ peerId }: { peerId: string }) => {
 			this._connectedPeerId = peerId;
 			this.emit("connected");
@@ -320,17 +391,34 @@ export class DevicePairingChannel extends EventEmitter {
 			},
 		);
 
-		// Auto-destroy after timeout.
-		this.timeoutHandle = setTimeout(() => {
-			if (!this._destroyed) {
-				this.emit("error", new Error("Pairing timed out"));
-				this.destroy();
-			}
-		}, PAIRING_TIMEOUT_MS);
+		// If a fallback signaling server is configured, try it after a timeout.
+		if (this.config.fallbackSignalingUrl && !signalingUrl) {
+			const fallbackTimer = setTimeout(() => {
+				if (this._destroyed || connected) return;
+				// Primary server didn't connect in time — try fallback.
+				if (this.webrtc) {
+					this.webrtc.destroy();
+					this.webrtc = null;
+				}
+				this._usingFallback = true;
+				this.emit("fallback", { url: this.config.fallbackSignalingUrl });
+				this.connectToServer(
+					this.config.fallbackSignalingUrl!,
+				);
+			}, SIGNALING_CONNECT_TIMEOUT_MS);
+
+			// Clear fallback timer if primary succeeds.
+			this.webrtc.on("connected", () => clearTimeout(fallbackTimer));
+		}
 
 		this.webrtc.connect();
 	}
 
+	/** Whether the connection fell back to the fallback signaling server. */
+	get usingFallback(): boolean {
+		return this._usingFallback;
+	}
+
 	private sendMessage(msg: PairingMsg): void {
 		if (!this.webrtc || !this._connectedPeerId) return;
 		// Send via the custom message path — the E2EE layer on the data channel

package/src/webrtc/SignalingSocket.ts

@@ -238,8 +238,8 @@ export class SignalingSocket extends EventEmitter {
 
 			case "joined":
 				this.emit("joined", {
-					peerId: msg.peer_id,
-					userId: msg.user_id,
+					peer_id: msg.peer_id,
+					user_id: msg.user_id,
 					muted: msg.muted,
 					video: msg.video,
 					screen: msg.screen,