@abraca/dabra 1.0.21 → 1.0.23

package/dist/abracadabra-provider.esm.js

@@ -2792,7 +2792,7 @@ var AbracadabraProvider = class AbracadabraProvider extends AbracadabraBaseProvi
 		this._client = client;
 		this.abracadabraConfig = configuration;
 		this.subdocLoading = configuration.subdocLoading ?? "lazy";
-		const serverOrigin = AbracadabraProvider.deriveServerOrigin(configuration, client);
+		const serverOrigin = configuration.serverAgnostic ? void 0 : AbracadabraProvider.deriveServerOrigin(configuration, client);
 		this.offlineStore = configuration.disableOfflineStore ? null : new OfflineStore(configuration.name, serverOrigin);
 		this.on("subdocRegistered", configuration.onSubdocRegistered ?? (() => null));
 		this.on("subdocLoaded", configuration.onSubdocLoaded ?? (() => null));
@@ -3222,6 +3222,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`);
@@ -8858,8 +8870,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,
@@ -10297,6 +10309,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("");
@@ -10314,6 +10327,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;
 	}
@@ -10468,12 +10482,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,
@@ -10481,6 +10524,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");
@@ -10494,14 +10541,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));
@@ -10696,5 +10754,319 @@ var BroadcastChannelSync = class BroadcastChannelSync extends EventEmitter {
 };
 
 //#endregion
-export { AbracadabraBaseProvider, AbracadabraClient, AbracadabraProvider, AbracadabraWS, AbracadabraWebRTC, AuthMessageType, AwarenessError, BackgroundSyncManager, BackgroundSyncPersistence, BroadcastChannelSync, CHANNEL_NAMES, ConnectionTimeout, CryptoIdentityKeystore, DEFAULT_FILE_CHUNK_SIZE, DEFAULT_ICE_SERVERS, DataChannelRouter, DevicePairingChannel, DocKeyManager, DocumentCache, E2EAbracadabraProvider, E2EEChannel, E2EOfflineStore, EncryptedYMap, EncryptedYText, FileBlobStore, FileTransferChannel, FileTransferHandle, Forbidden, HocuspocusProvider, HocuspocusProviderWebsocket, KEY_EXCHANGE_CHANNEL, ManualSignaling, MessageTooBig, MessageType, OfflineStore, PeerConnection, ResetConnection, SearchIndex, SignalingSocket, SubdocMessage, Unauthorized, WebSocketStatus, WsReadyStates, YjsDataChannel, attachUpdatedAtObserver, awarenessStatesToArray, decryptField, encryptField, makeEncryptedYMap, makeEncryptedYText, readAuthMessage, writeAuthenticated, writeAuthentication, writePermissionDenied, writeTokenSyncRequest };
+//#region packages/provider/src/IdentityDoc.ts
+/**
+* Derives a deterministic UUID from an Ed25519 account-level public key.
+*
+* The result is a valid UUID v5-style string that any device sharing the
+* same identity can independently compute.  The `abracadabra:identity:`
+* prefix prevents collisions with randomly generated doc UUIDs.
+*
+* @param publicKeyB64 Base64url-encoded Ed25519 public key (32 bytes).
+*/
+function deriveIdentityDocId(publicKeyB64) {
+	const hash = sha256(new TextEncoder().encode(`abracadabra:identity:${publicKeyB64}`));
+	const bytes = new Uint8Array(hash.buffer, hash.byteOffset, 16);
+	bytes[6] = bytes[6] & 15 | 80;
+	bytes[8] = bytes[8] & 63 | 128;
+	const hex = Array.from(bytes, (b) => b.toString(16).padStart(2, "0")).join("");
+	return `${hex.slice(0, 8)}-${hex.slice(8, 12)}-${hex.slice(12, 16)}-${hex.slice(16, 20)}-${hex.slice(20, 32)}`;
+}
+/**
+* Manages a Y.Doc dedicated to user identity that syncs across trusted
+* targets only: a designated sync server, a local Tauri server, and/or
+* WebRTC P2P.
+*
+* The Y.Doc contains cross-device settings (profile, servers, spaces,
+* plugins, preferences).  Each sync target gets its own
+* AbracadabraProvider sharing the same Y.Doc, with `serverAgnostic: true`
+* so they all use one IndexedDB store.
+*/
+var IdentityDocProvider = class extends EventEmitter {
+	constructor(configuration) {
+		super();
+		this.providers = /* @__PURE__ */ new Map();
+		this.websockets = /* @__PURE__ */ new Map();
+		this.webrtc = null;
+		this._destroyed = false;
+		this.config = configuration;
+		this.docId = deriveIdentityDocId(configuration.publicKey);
+		this.document = new Y.Doc({ guid: this.docId });
+		if (configuration.autoConnect !== false) this.connect();
+	}
+	connect() {
+		if (this._destroyed) return;
+		const targets = [];
+		if (this.config.localServerUrl) targets.push({
+			url: this.config.localServerUrl,
+			key: "local"
+		});
+		if (this.config.syncServerUrl) targets.push({
+			url: this.config.syncServerUrl,
+			key: "sync"
+		});
+		for (const { url, key } of targets) {
+			if (this.providers.has(key)) continue;
+			this.connectToServer(key, url);
+		}
+		if (this.config.webrtc && !this.webrtc) this._connectWebRTC();
+	}
+	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 providerConfig = {
+			name: this.docId,
+			document: this.document,
+			websocketProvider: ws,
+			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,
+			...data
+		}));
+		this.providers.set(key, provider);
+	}
+	_connectWebRTC() {
+		const rtcConfig = this.config.webrtc;
+		if (!rtcConfig) return;
+		this.webrtc = new AbracadabraWebRTC({
+			docId: this.docId,
+			url: rtcConfig.signalingServerUrl,
+			token: rtcConfig.token,
+			document: this.document,
+			enableDocSync: true,
+			enableAwarenessSync: false,
+			enableFileTransfer: false,
+			e2ee: rtcConfig.e2ee,
+			iceServers: rtcConfig.iceServers
+		});
+	}
+	get profileMap() {
+		return this.document.getMap("profile");
+	}
+	get serversMap() {
+		return this.document.getMap("servers");
+	}
+	get spacesArray() {
+		return this.document.getArray("spaces");
+	}
+	get pluginsMap() {
+		return this.document.getMap("plugins");
+	}
+	get preferencesMap() {
+		return this.document.getMap("preferences");
+	}
+	getProfile() {
+		const m = this.profileMap;
+		return {
+			username: m.get("username"),
+			displayName: m.get("displayName"),
+			colorName: m.get("colorName"),
+			neutralColorName: m.get("neutralColorName"),
+			locale: m.get("locale"),
+			avatarUrl: m.get("avatarUrl")
+		};
+	}
+	setProfile(profile) {
+		const m = this.profileMap;
+		this.document.transact(() => {
+			for (const [key, value] of Object.entries(profile)) if (value !== void 0) m.set(key, value);
+		});
+	}
+	getServer(url) {
+		const entry = this.serversMap.get(url);
+		if (!entry) return void 0;
+		return {
+			label: entry.get("label") ?? url,
+			hubDocId: entry.get("hubDocId"),
+			entryDocId: entry.get("entryDocId"),
+			defaultRole: entry.get("defaultRole"),
+			spacesEnabled: entry.get("spacesEnabled"),
+			addedAt: entry.get("addedAt") ?? 0
+		};
+	}
+	setServer(url, entry) {
+		const m = this.serversMap;
+		this.document.transact(() => {
+			let yEntry = m.get(url);
+			if (!yEntry) {
+				yEntry = new Y.Map();
+				m.set(url, yEntry);
+			}
+			for (const [key, value] of Object.entries(entry)) if (value !== void 0) yEntry.set(key, value);
+		});
+	}
+	removeServer(url) {
+		this.serversMap.delete(url);
+	}
+	getServers() {
+		const result = /* @__PURE__ */ new Map();
+		this.serversMap.forEach((entry, url) => {
+			result.set(url, {
+				label: entry.get("label") ?? url,
+				hubDocId: entry.get("hubDocId"),
+				entryDocId: entry.get("entryDocId"),
+				defaultRole: entry.get("defaultRole"),
+				spacesEnabled: entry.get("spacesEnabled"),
+				addedAt: entry.get("addedAt") ?? 0
+			});
+		});
+		return result;
+	}
+	getSpaces() {
+		const result = [];
+		this.spacesArray.forEach((yMap) => {
+			result.push({
+				id: yMap.get("id"),
+				name: yMap.get("name"),
+				type: yMap.get("type") ?? "remote",
+				serverUrl: yMap.get("serverUrl") ?? null,
+				docId: yMap.get("docId"),
+				remoteSpaceId: yMap.get("remoteSpaceId"),
+				visibility: yMap.get("visibility") ?? "private",
+				isHub: yMap.get("isHub") ?? false,
+				order: yMap.get("order") ?? 0,
+				lastSyncedAt: yMap.get("lastSyncedAt"),
+				createdAt: yMap.get("createdAt") ?? 0
+			});
+		});
+		return result;
+	}
+	addSpace(space) {
+		const yMap = new Y.Map();
+		this.document.transact(() => {
+			for (const [key, value] of Object.entries(space)) if (value !== void 0) yMap.set(key, value);
+			this.spacesArray.push([yMap]);
+		});
+	}
+	removeSpace(spaceId) {
+		const arr = this.spacesArray;
+		for (let i = 0; i < arr.length; i++) if (arr.get(i).get("id") === spaceId) {
+			arr.delete(i, 1);
+			return;
+		}
+	}
+	updateSpace(spaceId, updates) {
+		const arr = this.spacesArray;
+		for (let i = 0; i < arr.length; i++) {
+			const yMap = arr.get(i);
+			if (yMap.get("id") === spaceId) {
+				this.document.transact(() => {
+					for (const [key, value] of Object.entries(updates)) if (value !== void 0) yMap.set(key, value);
+				});
+				return;
+			}
+		}
+	}
+	getExternalPlugins() {
+		let arr = this.pluginsMap.get("external");
+		if (!arr) {
+			arr = new Y.Array();
+			this.pluginsMap.set("external", arr);
+		}
+		return arr;
+	}
+	getDisabledBuiltins() {
+		let arr = this.pluginsMap.get("disabledBuiltins");
+		if (!arr) {
+			arr = new Y.Array();
+			this.pluginsMap.set("disabledBuiltins", arr);
+		}
+		return arr;
+	}
+	getPreference(key) {
+		return this.preferencesMap.get(key);
+	}
+	setPreference(key, value) {
+		this.preferencesMap.set(key, value);
+	}
+	/**
+	* Observe deep changes on a specific top-level map.
+	* Returns an unsubscribe function.
+	*/
+	observe(mapName, callback) {
+		const map = this.document.getMap(mapName);
+		map.observeDeep(callback);
+		return () => map.unobserveDeep(callback);
+	}
+	/**
+	* Observe changes to the spaces array.
+	* Returns an unsubscribe function.
+	*/
+	observeSpaces(callback) {
+		const arr = this.spacesArray;
+		arr.observe(callback);
+		return () => arr.unobserve(callback);
+	}
+	/**
+	* Returns true if the identity doc has no profile data yet (first use).
+	* Call this to decide whether to run migration from localStorage.
+	*/
+	isEmpty() {
+		return this.profileMap.size === 0 && this.serversMap.size === 0;
+	}
+	/**
+	* Update the sync server URL at runtime (e.g. when user changes their
+	* designated sync server in settings).
+	*/
+	setSyncServer(url) {
+		const existing = this.providers.get("sync");
+		if (existing) {
+			existing.destroy();
+			this.providers.delete("sync");
+		}
+		const existingWs = this.websockets.get("sync");
+		if (existingWs) {
+			existingWs.destroy();
+			this.websockets.delete("sync");
+		}
+		if (url) {
+			this.config = {
+				...this.config,
+				syncServerUrl: url
+			};
+			this.connectToServer("sync", url);
+		}
+	}
+	getProvider(key) {
+		return this.providers.get(key);
+	}
+	destroy() {
+		if (this._destroyed) return;
+		this._destroyed = true;
+		for (const [, provider] of this.providers) provider.destroy();
+		for (const [, ws] of this.websockets) ws.destroy();
+		if (this.webrtc) this.webrtc.disconnect?.();
+		this.providers.clear();
+		this.websockets.clear();
+		this.webrtc = null;
+		this.document.destroy();
+	}
+};
+
+//#endregion
+export { AbracadabraBaseProvider, AbracadabraClient, AbracadabraProvider, AbracadabraWS, AbracadabraWebRTC, AuthMessageType, AwarenessError, BackgroundSyncManager, BackgroundSyncPersistence, BroadcastChannelSync, CHANNEL_NAMES, ConnectionTimeout, CryptoIdentityKeystore, DEFAULT_FILE_CHUNK_SIZE, DEFAULT_ICE_SERVERS, DataChannelRouter, DevicePairingChannel, DocKeyManager, DocumentCache, E2EAbracadabraProvider, E2EEChannel, E2EOfflineStore, EncryptedYMap, EncryptedYText, FileBlobStore, FileTransferChannel, FileTransferHandle, Forbidden, HocuspocusProvider, HocuspocusProviderWebsocket, IdentityDocProvider, KEY_EXCHANGE_CHANNEL, ManualSignaling, MessageTooBig, MessageType, OfflineStore, PeerConnection, ResetConnection, SearchIndex, SignalingSocket, SubdocMessage, Unauthorized, WebSocketStatus, WsReadyStates, YjsDataChannel, attachUpdatedAtObserver, awarenessStatesToArray, decryptField, deriveIdentityDocId, encryptField, makeEncryptedYMap, makeEncryptedYText, readAuthMessage, writeAuthenticated, writeAuthentication, writePermissionDenied, writeTokenSyncRequest };
 //# sourceMappingURL=abracadabra-provider.esm.js.map