@abraca/dabra 1.0.22 → 1.0.23

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,
@@ -10349,6 +10361,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 +10379,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 +10534,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 +10576,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");
@@ -10546,14 +10593,25 @@ var DevicePairingChannel = class DevicePairingChannel extends EventEmitter {
 		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 +10859,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 +11100,7 @@ var IdentityDocProvider = class extends EventEmitter {
 				...this.config,
 				syncServerUrl: url
 			};
-			this._connectToServer("sync", url);
+			this.connectToServer("sync", url);
 		}
 	}
 	getProvider(key) {