shadow-claw 1.29.0 → 1.30.0

package/dist/lib/{peerjs-BdfpltIe.js → peerjs-BUS9O04I.js}

@@ -1,8 +1,8 @@
 import { n as getDb } from "./txPromise-CuGh-TGK.js";
 import { t as Signal } from "./dist-Bxg3C_zy.js";
-import { S as PEERJS_DEFAULT_HOST } from "./config--CFrw3J3.js";
-import { t as readGroupFileBytes } from "./readGroupFileBytes-C8oOe8Iu.js";
-import { Kt as writeGroupFileBytes, Zt as groupFileExists, rn as uploadGroupFile } from "./orchestrator-ClXbJ4Mb.js";
+import { S as PEERJS_DEFAULT_HOST } from "./config-DjZ9QWc4.js";
+import { t as readGroupFileBytes } from "./readGroupFileBytes-CSA7u-nJ.js";
+import { Kt as writeGroupFileBytes, Zt as groupFileExists, rn as uploadGroupFile } from "./orchestrator-C6dc-2OQ.js";
 import { ulid } from "./utils/ulid.js";
 
 //#region src/content/message-attachments.ts
@@ -670,6 +670,31 @@ var PeerTaskManager = class {
 * directly without going through the non-reactive orchestratorStore.orchestrator chain.
 */
 const transferProgressSignal = new Signal.State(null);
+let transferProgressClearTimeout = null;
+/**
+* Update transfer progress signal and cancel any pending delayed clear timer.
+*/
+function updateTransferProgress(progress) {
+	if (transferProgressClearTimeout !== null) {
+		clearTimeout(transferProgressClearTimeout);
+		transferProgressClearTimeout = null;
+	}
+	transferProgressSignal.set(progress);
+}
+/**
+* Clear transfer progress after a delay, ensuring any existing timer is reset.
+*/
+function clearTransferProgressDelayed(delayMs = 1500) {
+	if (transferProgressClearTimeout !== null) clearTimeout(transferProgressClearTimeout);
+	transferProgressClearTimeout = setTimeout(() => {
+		transferProgressSignal.set(null);
+		transferProgressClearTimeout = null;
+	}, delayMs);
+}
+/** Maximum chunk size in bytes for application-level file transfers (15 KB to stay safely under PeerJS 16,300 MTU after msgpack framing) */
+const FILE_CHUNK_SIZE = 15360;
+/** Threshold for WebRTC DataChannel bufferedAmount backpressure (64 KB) */
+const FILE_BUFFER_DRAIN_THRESHOLD = 65536;
 /**
 * A PeerJS-based WebRTC data-channel messaging channel.
 *
@@ -714,17 +739,20 @@ var PeerJsChannel = class PeerJsChannel {
 	_roomNotificationHandler = null;
 	/** Per-connection task managers keyed by remote peer ID */
 	_taskManagers = /* @__PURE__ */ new Map();
+	/** Inbound multi-chunk file transfers keyed by transferId */
+	_inboundTransfers = /* @__PURE__ */ new Map();
 	constructor() {
 		if (typeof globalThis.addEventListener === "function") globalThis.addEventListener("peerjs-dc-handle-chunk", (e) => {
 			if (e?.detail?.chunkInfo) {
+				if (this._inboundTransfers.size > 0) return;
 				const { count: rawCount, total } = e.detail.chunkInfo;
 				const received = rawCount + 1;
-				transferProgressSignal.set({
+				updateTransferProgress({
 					count: received,
 					total,
 					direction: "receive"
 				});
-				if (received >= total) setTimeout(() => transferProgressSignal.set(null), 1500);
+				if (received >= total) clearTransferProgressDelayed(1500);
 			}
 		});
 	}
@@ -823,6 +851,74 @@ var PeerJsChannel = class PeerJsChannel {
 	setRoomNotificationHandler(handler) {
 		this._roomNotificationHandler = handler;
 	}
+	/**
+	* Stream file attachments to all other members in a room over WebRTC DataConnections,
+	* tagged with the room groupId.
+	*/
+	async sendAttachmentsToRoom(room, groupId, attachments) {
+		const me = this.myPeerId;
+		const fileAttachments = (attachments || []).filter((a) => !!a.path);
+		if (fileAttachments.length === 0) return;
+		try {
+			const db = await getDb();
+			for (const att of fileAttachments) {
+				let bytes;
+				try {
+					bytes = await readGroupFileBytes(db, groupId, att.path);
+				} catch (err) {
+					console.warn(`PeerJsChannel: failed to read file ${att.path} for room:`, err);
+					continue;
+				}
+				const canonicalName = att.path;
+				const mimeType = att.mimeType || "application/octet-stream";
+				const totalChunks = Math.max(1, Math.ceil(bytes.length / FILE_CHUNK_SIZE));
+				for (const member of room.members) {
+					if (member.peerId === me) continue;
+					const conn = this._getOrOpenConnection(member.peerId);
+					if (!conn) continue;
+					try {
+						await this._waitForOpen(conn);
+						const transferId = ulid();
+						conn.send({
+							type: "__file_header",
+							id: transferId,
+							name: canonicalName,
+							mimeType,
+							size: bytes.length,
+							totalChunks,
+							chunkSize: FILE_CHUNK_SIZE,
+							groupId
+						});
+						for (let i = 0; i < totalChunks; i++) {
+							const start = i * FILE_CHUNK_SIZE;
+							const end = Math.min(start + FILE_CHUNK_SIZE, bytes.length);
+							const chunk = bytes.subarray(start, end);
+							const chunkBuf = chunk.buffer.slice(chunk.byteOffset, chunk.byteOffset + chunk.byteLength);
+							conn.send({
+								type: "__file_chunk",
+								id: transferId,
+								name: canonicalName,
+								index: i,
+								totalChunks,
+								data: chunkBuf
+							});
+							updateTransferProgress({
+								count: i + 1,
+								total: totalChunks,
+								direction: "send"
+							});
+							await this._waitForBufferDrain(conn);
+						}
+						clearTransferProgressDelayed(1500);
+					} catch (err) {
+						console.warn(`PeerJsChannel: failed to stream file ${att.path} to room member ${member.peerId}:`, err);
+					}
+				}
+			}
+		} catch (err) {
+			console.error("PeerJsChannel: failed to access DB for room file transfer", err);
+		}
+	}
 	setTyping(groupId, typing) {
 		const remotePeerId = groupId.replace(/^peer:/, "");
 		const conn = this.connections.get(remotePeerId);
@@ -915,15 +1011,39 @@ var PeerJsChannel = class PeerJsChannel {
 						const canonicalName = att.path;
 						if (!pathRemap.has(att.path)) pathRemap.set(att.path, canonicalName);
 						const mimeType = att.mimeType || "application/octet-stream";
+						const transferId = ulid();
+						const totalChunks = Math.max(1, Math.ceil(bytes.length / FILE_CHUNK_SIZE));
 						conn.send({
 							type: "__file_header",
+							id: transferId,
 							name: canonicalName,
 							mimeType,
-							size: bytes.length
+							size: bytes.length,
+							totalChunks,
+							chunkSize: FILE_CHUNK_SIZE,
+							groupId
 						});
-						const trackPromise = this._trackSendProgress(conn, bytes.length);
-						conn.send(bytes.buffer);
-						await trackPromise;
+						for (let i = 0; i < totalChunks; i++) {
+							const start = i * FILE_CHUNK_SIZE;
+							const end = Math.min(start + FILE_CHUNK_SIZE, bytes.length);
+							const chunk = bytes.subarray(start, end);
+							const chunkBuf = chunk.buffer.slice(chunk.byteOffset, chunk.byteOffset + chunk.byteLength);
+							conn.send({
+								type: "__file_chunk",
+								id: transferId,
+								name: canonicalName,
+								index: i,
+								totalChunks,
+								data: chunkBuf
+							});
+							updateTransferProgress({
+								count: i + 1,
+								total: totalChunks,
+								direction: "send"
+							});
+							await this._waitForBufferDrain(conn);
+						}
+						clearTransferProgressDelayed(1500);
 						fileParts.push({
 							kind: "file",
 							name: canonicalName,
@@ -1282,25 +1402,8 @@ var PeerJsChannel = class PeerJsChannel {
 		if (data instanceof ArrayBuffer || data instanceof Uint8Array) {
 			if (this._pendingInboundFile) {
 				const canonicalName = this._pendingInboundFile.name;
-				const groupId = `peer:${remotePeerId}`;
 				const bytes = new Uint8Array(data);
-				getDb().then(async (db) => {
-					let finalName = canonicalName;
-					let counter = 1;
-					while (await groupFileExists(db, groupId, finalName)) {
-						const lastDotIndex = canonicalName.lastIndexOf(".");
-						if (lastDotIndex > 0 && lastDotIndex < canonicalName.length - 1) {
-							const base = canonicalName.substring(0, lastDotIndex);
-							const ext = canonicalName.substring(lastDotIndex);
-							finalName = `${base} (${counter})${ext}`;
-						} else finalName = `${canonicalName} (${counter})`;
-						counter++;
-					}
-					if (finalName !== canonicalName) this._inboundRemap.set(canonicalName, finalName);
-					writeGroupFileBytes(db, groupId, finalName, bytes).catch((err) => {
-						console.error("PeerJsChannel: failed to write inbound file bytes", err);
-					});
-				});
+				this._saveInboundFile(remotePeerId, canonicalName, bytes);
 				this._pendingInboundFile = null;
 			}
 			return;
@@ -1308,11 +1411,74 @@ var PeerJsChannel = class PeerJsChannel {
 		if (!data || typeof data !== "object") return;
 		const msg = data;
 		if (msg.type === "__file_header") {
+			const transferId = msg.id || msg.name;
+			const totalChunks = msg.totalChunks || 1;
+			const existing = this._inboundTransfers.get(transferId);
+			this._inboundTransfers.set(transferId, {
+				transferId,
+				name: msg.name,
+				mimeType: msg.mimeType || "application/octet-stream",
+				size: msg.size || 0,
+				totalChunks,
+				receivedChunks: existing?.receivedChunks || /* @__PURE__ */ new Map(),
+				receivedBytes: existing?.receivedBytes || 0,
+				targetGroupId: typeof msg.groupId === "string" ? msg.groupId : void 0
+			});
 			this._pendingInboundFile = {
 				name: msg.name,
 				mimeType: msg.mimeType,
 				size: msg.size
 			};
+			updateTransferProgress({
+				count: 0,
+				total: totalChunks,
+				direction: "receive"
+			});
+			return;
+		}
+		if (msg.type === "__file_chunk") {
+			const transferId = msg.id || msg.name;
+			let transfer = this._inboundTransfers.get(transferId);
+			if (!transfer) {
+				const totalChunks = msg.totalChunks || 1;
+				transfer = {
+					transferId,
+					name: msg.name,
+					mimeType: "application/octet-stream",
+					size: 0,
+					totalChunks,
+					receivedChunks: /* @__PURE__ */ new Map(),
+					receivedBytes: 0
+				};
+				this._inboundTransfers.set(transferId, transfer);
+			}
+			const index = typeof msg.index === "number" ? msg.index : 0;
+			const chunkData = msg.data instanceof ArrayBuffer ? new Uint8Array(msg.data) : msg.data instanceof Uint8Array ? msg.data : new Uint8Array(msg.data || []);
+			if (!transfer.receivedChunks.has(index)) {
+				transfer.receivedChunks.set(index, chunkData);
+				transfer.receivedBytes += chunkData.byteLength;
+			}
+			updateTransferProgress({
+				count: transfer.receivedChunks.size,
+				total: transfer.totalChunks,
+				direction: "receive"
+			});
+			if (transfer.receivedChunks.size >= transfer.totalChunks) {
+				const completeBytes = new Uint8Array(transfer.size || transfer.receivedBytes);
+				let offset = 0;
+				for (let i = 0; i < transfer.totalChunks; i++) {
+					const part = transfer.receivedChunks.get(i);
+					if (part) {
+						completeBytes.set(part, offset);
+						offset += part.byteLength;
+					}
+				}
+				const targetGroupId = transfer.targetGroupId || `peer:${remotePeerId}`;
+				this._saveInboundFile(targetGroupId, transfer.name, completeBytes);
+				this._inboundTransfers.delete(transferId);
+				this._pendingInboundFile = null;
+				clearTransferProgressDelayed(1500);
+			}
 			return;
 		}
 		if (msg.type === "typing") {
@@ -1340,7 +1506,7 @@ var PeerJsChannel = class PeerJsChannel {
 			const action = payload.action || "";
 			const args = payload.args || {};
 			const commandId = payload.commandId || "";
-			import("./initControlPlane-DnpAzphg.js").then(({ executeClientControlCommand }) => executeClientControlCommand(action, args)).then((result) => {
+			import("./initControlPlane-C9JxQCDh.js").then(({ executeClientControlCommand }) => executeClientControlCommand(action, args)).then((result) => {
 				const conn = this.connections.get(remotePeerId);
 				if (conn) {
 					const hasError = Boolean(result?.error);
@@ -1391,6 +1557,7 @@ var PeerJsChannel = class PeerJsChannel {
 			} catch {}
 			return;
 		}
+		this._attachChunkProgressTracker(conn);
 		this.connections.set(remotePeerId, conn);
 		this._updateConnectedPeersSignal();
 		conn.on("open", () => {
@@ -1425,6 +1592,40 @@ var PeerJsChannel = class PeerJsChannel {
 		});
 	}
 	/**
+	* Intercept incoming BinaryPack chunk handling on DataConnection to track
+	* file reception progress without requiring a custom PeerJS fork.
+	*/
+	_attachChunkProgressTracker(conn) {
+		const connAny = conn;
+		if (connAny._chunkProgressPatched) return;
+		connAny._chunkProgressPatched = true;
+		const self = this;
+		const origHandleChunk = connAny._handleChunk;
+		if (typeof origHandleChunk === "function") connAny._handleChunk = function(data) {
+			if (data && typeof data === "object" && "__peerData" in data) {
+				if (self._inboundTransfers.size === 0) {
+					const id = data.__peerData;
+					const currentCount = this._chunkedData?.[id]?.count ?? 0;
+					const total = data.total;
+					if (typeof globalThis.dispatchEvent === "function" && typeof CustomEvent === "function") globalThis.dispatchEvent(new CustomEvent("peerjs-dc-handle-chunk", { detail: { chunkInfo: {
+						count: currentCount,
+						total
+					} } }));
+					else {
+						const received = currentCount + 1;
+						updateTransferProgress({
+							count: received,
+							total,
+							direction: "receive"
+						});
+						if (received >= total) clearTransferProgressDelayed(1500);
+					}
+				}
+			}
+			return origHandleChunk.call(this, data);
+		};
+	}
+	/**
 	* Handle an inbound task status update notification.
 	*/
 	_handleTaskStatusNotification(remotePeerId, params) {
@@ -1440,7 +1641,7 @@ var PeerJsChannel = class PeerJsChannel {
 		} }));
 	}
 	async _initPeer() {
-		const { Peer } = await import("./bundler-8JNIKwOs.js");
+		const { Peer } = await import("./bundler-CsL7hHMq.js");
 		const opts = {};
 		const host = this.serverConfig.host ?? "0.peerjs.com";
 		const port = this.serverConfig.port ?? 443;
@@ -1521,41 +1722,54 @@ var PeerJsChannel = class PeerJsChannel {
 		} catch {}
 	}
 	/**
-	* Track outbound send progress by polling RTCDataChannel.bufferedAmount.
-	* Resolves when all queued data has been flushed to the network.
+	* Pause execution if the underlying WebRTC DataChannel send buffer
+	* exceeds the drain threshold, preventing buffer bloat during large transfers.
 	*/
-	_trackSendProgress(conn, totalBytes) {
-		return new Promise((resolve) => {
-			const rawDc = conn._dc;
-			if (!rawDc || totalBytes === 0) {
-				this.transferProgressSignal.set(null);
-				resolve();
-				return;
-			}
-			this.transferProgressSignal.set({
-				count: 0,
-				total: totalBytes,
-				direction: "send"
-			});
+	async _waitForBufferDrain(conn, threshold = FILE_BUFFER_DRAIN_THRESHOLD) {
+		const rawDc = conn.dataChannel || conn._dc;
+		if (!rawDc || typeof rawDc.bufferedAmount !== "number") return;
+		if (rawDc.bufferedAmount <= threshold) return;
+		await new Promise((resolve) => {
 			const poll = setInterval(() => {
-				const buffered = rawDc.bufferedAmount;
-				const sent = Math.max(0, totalBytes - buffered);
-				this.transferProgressSignal.set({
-					count: sent,
-					total: totalBytes,
-					direction: "send"
-				});
-				if (buffered === 0) {
+				if (!rawDc || rawDc.bufferedAmount <= threshold) {
 					clearInterval(poll);
-					this.transferProgressSignal.set({
-						count: totalBytes,
-						total: totalBytes,
-						direction: "send"
-					});
-					setTimeout(() => this.transferProgressSignal.set(null), 1500);
 					resolve();
 				}
-			}, 80);
+			}, 20);
+			if (typeof rawDc.addEventListener === "function") {
+				const onLow = () => {
+					clearInterval(poll);
+					rawDc.removeEventListener("bufferedamountlow", onLow);
+					resolve();
+				};
+				try {
+					rawDc.bufferedAmountLowThreshold = threshold;
+					rawDc.addEventListener("bufferedamountlow", onLow, { once: true });
+				} catch {}
+			}
+		});
+	}
+	/**
+	* Persist complete received file bytes into group storage, handling
+	* duplicate filename incrementing and path remapping.
+	*/
+	_saveInboundFile(groupId, canonicalName, bytes) {
+		getDb().then(async (db) => {
+			let finalName = canonicalName;
+			let counter = 1;
+			while (await groupFileExists(db, groupId, finalName)) {
+				const lastDotIndex = canonicalName.lastIndexOf(".");
+				if (lastDotIndex > 0 && lastDotIndex < canonicalName.length - 1) {
+					const base = canonicalName.substring(0, lastDotIndex);
+					const ext = canonicalName.substring(lastDotIndex);
+					finalName = `${base} (${counter})${ext}`;
+				} else finalName = `${canonicalName} (${counter})`;
+				counter++;
+			}
+			if (finalName !== canonicalName) this._inboundRemap.set(canonicalName, finalName);
+			writeGroupFileBytes(db, groupId, finalName, bytes).catch((err) => {
+				console.error("PeerJsChannel: failed to write inbound file bytes", err);
+			});
 		});
 	}
 	_updateConnectedPeersSignal() {
@@ -1657,4 +1871,4 @@ function normalizeAttachmentPath(path) {
 
 //#endregion
 export { persistMessageAttachments as a, inferAttachmentMimeType as i, transferProgressSignal as n, shouldInlineAttachmentInChat as o, ROOM_METHOD as r, PeerJsChannel as t };
-//# sourceMappingURL=peerjs-BdfpltIe.js.map
+//# sourceMappingURL=peerjs-BUS9O04I.js.map