@abraca/dabra 1.0.22 → 1.0.24

package/dist/abracadabra-provider.cjs

@@ -3252,6 +3252,18 @@ var AbracadabraClient = class {
 			auth: false
 		});
 	}
+	/**
+	* Fetch a short-lived anonymous pairing token for WebRTC signaling.
+	* No authentication required. The token only grants access to `__pairing_*` rooms.
+	*/
+	static async getPairingToken(serverUrl) {
+		let base = 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}`);
+		const { token } = await resp.json();
+		return token;
+	}
 	/** Get encryption info for a document. */
 	async getDocEncryption(docId) {
 		return this.request("GET", `/docs/${encodeURIComponent(docId)}/encryption`);
@@ -8910,8 +8922,8 @@ var SignalingSocket = class extends EventEmitter {
 				break;
 			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,
@@ -9980,7 +9992,7 @@ var AbracadabraWebRTC = class AbracadabraWebRTC extends EventEmitter {
 			channel = pc.router.createChannel(channelName, { ordered: true });
 			channel.onopen = () => {
 				const data = new TextEncoder().encode(payload);
-				pc.router.send(channelName, data);
+				pc.router.send(channelName, data).catch(() => {});
 			};
 			return;
 		}
@@ -10066,9 +10078,14 @@ var AbracadabraWebRTC = class AbracadabraWebRTC extends EventEmitter {
 			this.e2eeChannels.set(peerId, e2ee);
 			pc.router.setEncryptor(e2ee);
 			pc.router.on("channelMessage", async ({ name, data }) => {
-				if (name === KEY_EXCHANGE_CHANNEL) {
+				if (name === KEY_EXCHANGE_CHANNEL) try {
 					const buf = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
 					await e2ee.handleKeyExchange(buf);
+				} catch (err) {
+					this.emit("e2eeFailed", {
+						peerId,
+						error: err
+					});
 				}
 			});
 			pc.router.on("channelOpen", ({ name, channel }) => {
@@ -10139,7 +10156,12 @@ var AbracadabraWebRTC = class AbracadabraWebRTC extends EventEmitter {
 		try {
 			const sdp = await pc.createOffer();
 			this.signaling?.sendOffer(peerId, sdp);
-		} catch {
+		} catch (err) {
+			this.emit("error", {
+				type: "offer-failed",
+				peerId,
+				error: err
+			});
 			this.removePeer(peerId);
 		}
 	}
@@ -10157,7 +10179,12 @@ var AbracadabraWebRTC = class AbracadabraWebRTC extends EventEmitter {
 		try {
 			const answerSdp = await pc.setRemoteOffer(sdp);
 			this.signaling?.sendAnswer(from, answerSdp);
-		} catch {
+		} catch (err) {
+			this.emit("error", {
+				type: "answer-failed",
+				peerId: from,
+				error: err
+			});
 			this.removePeer(from);
 		}
 	}
@@ -10349,6 +10376,7 @@ var ManualSignaling = class extends EventEmitter {
 const CODE_CHARSET = "ABCDEFGHJKLMNPQRSTUVWXYZ23456789";
 const CODE_LENGTH = 6;
 const PAIRING_TIMEOUT_MS = 300 * 1e3;
+const SIGNALING_CONNECT_TIMEOUT_MS = 5e3;
 function generatePairingCode() {
 	const bytes = crypto.getRandomValues(new Uint8Array(CODE_LENGTH));
 	return Array.from(bytes).map((b) => CODE_CHARSET[b % 32]).join("");
@@ -10366,6 +10394,7 @@ var DevicePairingChannel = class DevicePairingChannel extends EventEmitter {
 		this._destroyed = false;
 		this._pendingRequest = null;
 		this._connectedPeerId = null;
+		this._usingFallback = false;
 		this.role = role;
 		this.pairingCode = pairingCode;
 	}
@@ -10520,12 +10549,41 @@ var DevicePairingChannel = class DevicePairingChannel extends EventEmitter {
 		}
 		this.removeAllListeners();
 	}
+	async resolveToken(serverUrl) {
+		if (this.config.token && serverUrl === this.config.serverUrl) return this.config.token;
+		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();
+		return token;
+	}
 	start() {
+		this.connectToServer(this.config.serverUrl);
+		this.timeoutHandle = setTimeout(() => {
+			if (!this._destroyed) {
+				this.emit("error", /* @__PURE__ */ new Error("Pairing timed out"));
+				this.destroy();
+			}
+		}, PAIRING_TIMEOUT_MS);
+	}
+	connectToServer(serverUrl, signalingUrl) {
+		const roomId = codeToRoomId(this.pairingCode);
+		const tokenPromise = this.resolveToken(serverUrl);
+		const tokenFactory = async () => {
+			const t = await tokenPromise;
+			if (typeof t === "function") return await t();
+			return t;
+		};
+		if (!this.config.iceServers) new AbracadabraClient({ url: serverUrl }).getIceServers().then((servers) => {
+			if (servers.length > 0) this._resolvedIceServers = servers;
+		});
 		this.webrtc = new AbracadabraWebRTC({
-			docId: codeToRoomId(this.pairingCode),
-			url: this.config.serverUrl,
-			token: this.config.token,
-			iceServers: this.config.iceServers,
+			docId: roomId,
+			url: serverUrl,
+			signalingUrl: signalingUrl ?? void 0,
+			token: tokenFactory,
+			iceServers: this.config.iceServers ?? this._resolvedIceServers,
 			e2ee: this.config.e2ee,
 			enableDocSync: false,
 			enableAwarenessSync: false,
@@ -10533,6 +10591,10 @@ var DevicePairingChannel = class DevicePairingChannel extends EventEmitter {
 			autoConnect: false,
 			WebSocketPolyfill: this.config.WebSocketPolyfill
 		});
+		let connected = false;
+		this.webrtc.on("connected", () => {
+			connected = true;
+		});
 		this.webrtc.on("e2eeEstablished", ({ peerId }) => {
 			this._connectedPeerId = peerId;
 			this.emit("connected");
@@ -10540,20 +10602,37 @@ var DevicePairingChannel = class DevicePairingChannel extends EventEmitter {
 		this.webrtc.on("customMessage", ({ peerId, payload }) => {
 			this.handleMessage(peerId, payload);
 		});
+		this.webrtc.on("e2eeFailed", ({ peerId, error }) => {
+			if (!this._destroyed) this.emit("error", /* @__PURE__ */ new Error(`E2EE failed: ${error?.message ?? error}`));
+		});
+		this.webrtc.on("error", (err) => {
+			if (!this._destroyed) this.emit("error", /* @__PURE__ */ new Error(`WebRTC: ${err?.type ?? err?.message ?? "unknown"}`));
+		});
 		this.webrtc.on("peerLeft", () => {
 			if (!this._destroyed) this.emit("error", /* @__PURE__ */ new Error("Peer disconnected"));
 		});
 		this.webrtc.on("signalingError", (err) => {
 			this.emit("error", /* @__PURE__ */ new Error(`Signaling: ${err.message}`));
 		});
-		this.timeoutHandle = setTimeout(() => {
-			if (!this._destroyed) {
-				this.emit("error", /* @__PURE__ */ new Error("Pairing timed out"));
-				this.destroy();
-			}
-		}, PAIRING_TIMEOUT_MS);
+		if (this.config.fallbackSignalingUrl && !signalingUrl) {
+			const fallbackTimer = setTimeout(() => {
+				if (this._destroyed || connected) return;
+				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);
+			this.webrtc.on("connected", () => clearTimeout(fallbackTimer));
+		}
 		this.webrtc.connect();
 	}
+	/** Whether the connection fell back to the fallback signaling server. */
+	get usingFallback() {
+		return this._usingFallback;
+	}
 	sendMessage(msg) {
 		if (!this.webrtc || !this._connectedPeerId) return;
 		this.webrtc.sendCustomMessage(this._connectedPeerId, JSON.stringify(msg));
@@ -10801,26 +10880,41 @@ var IdentityDocProvider = class extends EventEmitter {
 		});
 		for (const { url, key } of targets) {
 			if (this.providers.has(key)) continue;
-			this._connectToServer(key, url);
+			this.connectToServer(key, url);
 		}
 		if (this.config.webrtc && !this.webrtc) this._connectWebRTC();
 	}
-	_connectToServer(key, serverUrl) {
+	connectToServer(key, serverUrl) {
+		if (this._destroyed) return;
+		const existingProvider = this.providers.get(key);
+		if (existingProvider) {
+			existingProvider.destroy();
+			this.providers.delete(key);
+		}
+		const existingWs = this.websockets.get(key);
+		if (existingWs) {
+			existingWs.destroy();
+			this.websockets.delete(key);
+		}
 		const token = this.config.tokens?.[serverUrl] ?? this.config.token ?? "";
 		const ws = new AbracadabraWS({
 			url: serverUrl.replace(/^http/, "ws").replace(/\/$/, "").concat("/ws"),
 			WebSocketPolyfill: void 0
 		});
 		this.websockets.set(key, ws);
-		const provider = new AbracadabraProvider({
+		const providerConfig = {
 			name: this.docId,
 			document: this.document,
 			websocketProvider: ws,
-			token,
 			serverAgnostic: true,
 			disableOfflineStore: key !== "local" && key !== "sync" ? true : this.config.disableOfflineStore ?? false,
 			...this.config.providerDefaults
-		});
+		};
+		if (this.config.cryptoIdentity && this.config.signChallenge) {
+			providerConfig.cryptoIdentity = this.config.cryptoIdentity;
+			providerConfig.signChallenge = this.config.signChallenge;
+		} else providerConfig.token = token;
+		const provider = new AbracadabraProvider(providerConfig);
 		provider.on("synced", () => this.emit("synced", { server: key }));
 		provider.on("status", (data) => this.emit("status", {
 			server: key,
@@ -11027,7 +11121,7 @@ var IdentityDocProvider = class extends EventEmitter {
 				...this.config,
 				syncServerUrl: url
 			};
-			this._connectToServer("sync", url);
+			this.connectToServer("sync", url);
 		}
 	}
 	getProvider(key) {