@abraca/dabra 1.0.2 → 1.0.3

package/src/webrtc/FileTransferChannel.ts

@@ -0,0 +1,359 @@
+import EventEmitter from "../EventEmitter.ts";
+import { DataChannelRouter } from "./DataChannelRouter.ts";
+import {
+	CHANNEL_NAMES,
+	FILE_MSG,
+	DEFAULT_FILE_CHUNK_SIZE,
+	TRANSFER_ID_BYTES,
+	SHA256_BYTES,
+	type FileTransferMeta,
+	type FileTransferStatus,
+} from "./types.ts";
+
+/**
+ * Handle for tracking a file transfer in progress.
+ */
+export class FileTransferHandle extends EventEmitter {
+	public readonly transferId: string;
+	public progress = 0;
+	public status: FileTransferStatus = "pending";
+
+	private abortController = new AbortController();
+
+	constructor(transferId: string) {
+		super();
+		this.transferId = transferId;
+	}
+
+	cancel(): void {
+		this.status = "cancelled";
+		this.abortController.abort();
+		this.emit("cancelled");
+	}
+
+	get signal(): AbortSignal {
+		return this.abortController.signal;
+	}
+
+	/** @internal */
+	_setProgress(p: number): void {
+		this.progress = p;
+		this.emit("progress", p);
+	}
+
+	/** @internal */
+	_setStatus(s: FileTransferStatus): void {
+		this.status = s;
+	}
+}
+
+interface ReceiveState {
+	meta: FileTransferMeta;
+	chunks: (Uint8Array | null)[];
+	receivedCount: number;
+}
+
+/**
+ * Chunked binary file transfer over a dedicated WebRTC data channel.
+ */
+export class FileTransferChannel extends EventEmitter {
+	private receives = new Map<string, ReceiveState>();
+	private chunkSize: number;
+	private channelMessageHandler: ((data: { name: string; data: any }) => void) | null = null;
+
+	constructor(
+		private readonly router: DataChannelRouter,
+		chunkSize?: number,
+	) {
+		super();
+		this.chunkSize = chunkSize ?? DEFAULT_FILE_CHUNK_SIZE;
+
+		this.channelMessageHandler = ({ name, data }: { name: string; data: any }) => {
+			if (name === CHANNEL_NAMES.FILE_TRANSFER) {
+				this.handleMessage(data);
+			}
+		};
+		this.router.on("channelMessage", this.channelMessageHandler);
+	}
+
+	/** Send a file to a peer. Returns a handle for tracking progress. */
+	async send(
+		file: File | Blob,
+		filename: string,
+	): Promise<FileTransferHandle> {
+		const transferId = generateTransferId();
+		const handle = new FileTransferHandle(transferId);
+		const transferIdBytes = hexToBytes(transferId);
+
+		const totalSize = file.size;
+		const totalChunks = Math.ceil(totalSize / this.chunkSize);
+		const mimeType =
+			file instanceof File ? file.type : "application/octet-stream";
+
+		const meta: FileTransferMeta = {
+			transferId,
+			filename,
+			mimeType,
+			totalSize,
+			chunkSize: this.chunkSize,
+			totalChunks,
+		};
+
+		const channel = this.router.getChannel(CHANNEL_NAMES.FILE_TRANSFER);
+		if (!channel || channel.readyState !== "open") {
+			handle._setStatus("error");
+			handle.emit("error", new Error("File transfer channel not open"));
+			return handle;
+		}
+
+		// Send start message.
+		const startMsg = new Uint8Array(
+			1 + new TextEncoder().encode(JSON.stringify(meta)).length,
+		);
+		startMsg[0] = FILE_MSG.START;
+		startMsg.set(new TextEncoder().encode(JSON.stringify(meta)), 1);
+		channel.send(startMsg);
+
+		handle._setStatus("sending");
+
+		// Read and send chunks.
+		const arrayBuffer = await file.arrayBuffer();
+		const fileBytes = new Uint8Array(arrayBuffer);
+
+		// SHA-256 for integrity check.
+		const hashBuffer = await crypto.subtle.digest("SHA-256", fileBytes);
+		const hashBytes = new Uint8Array(hashBuffer);
+
+		for (let i = 0; i < totalChunks; i++) {
+			if (handle.signal.aborted) {
+				// Send cancel.
+				const cancelMsg = new Uint8Array(1 + TRANSFER_ID_BYTES);
+				cancelMsg[0] = FILE_MSG.CANCEL;
+				cancelMsg.set(transferIdBytes, 1);
+				channel.send(cancelMsg);
+				return handle;
+			}
+
+			const offset = i * this.chunkSize;
+			const chunk = fileBytes.slice(
+				offset,
+				Math.min(offset + this.chunkSize, totalSize),
+			);
+
+			// [type(1)] [transferId(16)] [chunkIndex(4)] [chunk data]
+			const msg = new Uint8Array(
+				1 + TRANSFER_ID_BYTES + 4 + chunk.length,
+			);
+			msg[0] = FILE_MSG.CHUNK;
+			msg.set(transferIdBytes, 1);
+			new DataView(msg.buffer).setUint32(
+				1 + TRANSFER_ID_BYTES,
+				i,
+				false,
+			);
+			msg.set(chunk, 1 + TRANSFER_ID_BYTES + 4);
+
+			// Wait for bufferedAmount to drop before sending more chunks
+			// to avoid overwhelming the data channel.
+			while (channel.bufferedAmount > this.chunkSize * 4) {
+				await new Promise<void>((resolve) => setTimeout(resolve, 10));
+				if (handle.signal.aborted) return handle;
+			}
+
+			channel.send(msg);
+			handle._setProgress((i + 1) / totalChunks);
+		}
+
+		// Send complete message.
+		const completeMsg = new Uint8Array(
+			1 + TRANSFER_ID_BYTES + SHA256_BYTES,
+		);
+		completeMsg[0] = FILE_MSG.COMPLETE;
+		completeMsg.set(transferIdBytes, 1);
+		completeMsg.set(hashBytes, 1 + TRANSFER_ID_BYTES);
+		channel.send(completeMsg);
+
+		handle._setStatus("complete");
+		handle.emit("complete");
+
+		return handle;
+	}
+
+	private handleMessage(data: ArrayBuffer | Uint8Array): void {
+		const buf = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+		if (buf.length < 1) return;
+
+		const type = buf[0];
+
+		switch (type) {
+			case FILE_MSG.START:
+				this.handleStart(buf);
+				break;
+			case FILE_MSG.CHUNK:
+				this.handleChunk(buf);
+				break;
+			case FILE_MSG.COMPLETE:
+				this.handleComplete(buf);
+				break;
+			case FILE_MSG.CANCEL:
+				this.handleCancel(buf);
+				break;
+		}
+	}
+
+	private handleStart(buf: Uint8Array): void {
+		const json = new TextDecoder().decode(buf.slice(1));
+		let meta: FileTransferMeta;
+		try {
+			meta = JSON.parse(json);
+		} catch {
+			return;
+		}
+
+		this.receives.set(meta.transferId, {
+			meta,
+			chunks: new Array(meta.totalChunks).fill(null),
+			receivedCount: 0,
+		});
+
+		this.emit("receiveStart", meta);
+	}
+
+	private handleChunk(buf: Uint8Array): void {
+		if (buf.length < 1 + TRANSFER_ID_BYTES + 4) return;
+
+		const transferId = bytesToHex(
+			buf.slice(1, 1 + TRANSFER_ID_BYTES),
+		);
+		const chunkIndex = new DataView(buf.buffer, buf.byteOffset).getUint32(
+			1 + TRANSFER_ID_BYTES,
+			false,
+		);
+		const chunkData = buf.slice(1 + TRANSFER_ID_BYTES + 4);
+
+		const state = this.receives.get(transferId);
+		if (!state) return;
+
+		if (chunkIndex < state.chunks.length && !state.chunks[chunkIndex]) {
+			state.chunks[chunkIndex] = chunkData;
+			state.receivedCount++;
+
+			const progress = state.receivedCount / state.meta.totalChunks;
+			this.emit("receiveProgress", {
+				transferId,
+				received: state.receivedCount,
+				total: state.meta.totalChunks,
+				progress,
+			});
+		}
+	}
+
+	private async handleComplete(buf: Uint8Array): Promise<void> {
+		if (buf.length < 1 + TRANSFER_ID_BYTES + SHA256_BYTES) return;
+
+		const transferId = bytesToHex(
+			buf.slice(1, 1 + TRANSFER_ID_BYTES),
+		);
+		const expectedHash = buf.slice(1 + TRANSFER_ID_BYTES, 1 + TRANSFER_ID_BYTES + SHA256_BYTES);
+
+		const state = this.receives.get(transferId);
+		if (!state) return;
+
+		// Assemble the file.
+		const totalSize = state.meta.totalSize;
+		const assembled = new Uint8Array(totalSize);
+		let offset = 0;
+
+		for (let i = 0; i < state.chunks.length; i++) {
+			const chunk = state.chunks[i];
+			if (!chunk) {
+				this.emit("receiveError", {
+					transferId,
+					error: `Missing chunk ${i}`,
+				});
+				this.receives.delete(transferId);
+				return;
+			}
+			assembled.set(chunk, offset);
+			offset += chunk.length;
+		}
+
+		// Verify SHA-256 integrity.
+		const actualHashBuffer = await crypto.subtle.digest(
+			"SHA-256",
+			assembled,
+		);
+		const actualHash = new Uint8Array(actualHashBuffer);
+
+		if (!constantTimeEqual(expectedHash, actualHash)) {
+			this.emit("receiveError", {
+				transferId,
+				error: "SHA-256 integrity check failed",
+			});
+			this.receives.delete(transferId);
+			return;
+		}
+
+		const blob = new Blob([assembled], { type: state.meta.mimeType });
+
+		this.emit("receiveComplete", {
+			transferId,
+			blob,
+			filename: state.meta.filename,
+			mimeType: state.meta.mimeType,
+			size: state.meta.totalSize,
+		});
+
+		this.receives.delete(transferId);
+	}
+
+	private handleCancel(buf: Uint8Array): void {
+		if (buf.length < 1 + TRANSFER_ID_BYTES) return;
+
+		const transferId = bytesToHex(
+			buf.slice(1, 1 + TRANSFER_ID_BYTES),
+		);
+		this.receives.delete(transferId);
+		this.emit("receiveCancelled", { transferId });
+	}
+
+	destroy(): void {
+		if (this.channelMessageHandler) {
+			this.router.off("channelMessage", this.channelMessageHandler);
+			this.channelMessageHandler = null;
+		}
+		this.receives.clear();
+		this.removeAllListeners();
+	}
+}
+
+// ── Utilities ───────────────────────────────────────────────────────────────
+
+function generateTransferId(): string {
+	const bytes = new Uint8Array(TRANSFER_ID_BYTES);
+	crypto.getRandomValues(bytes);
+	return bytesToHex(bytes);
+}
+
+function bytesToHex(bytes: Uint8Array): string {
+	return Array.from(bytes)
+		.map((b) => b.toString(16).padStart(2, "0"))
+		.join("");
+}
+
+function hexToBytes(hex: string): Uint8Array {
+	const bytes = new Uint8Array(hex.length / 2);
+	for (let i = 0; i < hex.length; i += 2) {
+		bytes[i / 2] = parseInt(hex.slice(i, i + 2), 16);
+	}
+	return bytes;
+}
+
+function constantTimeEqual(a: Uint8Array, b: Uint8Array): boolean {
+	if (a.length !== b.length) return false;
+	let result = 0;
+	for (let i = 0; i < a.length; i++) {
+		result |= a[i] ^ b[i];
+	}
+	return result === 0;
+}

package/src/webrtc/PeerConnection.ts

@@ -0,0 +1,133 @@
+import EventEmitter from "../EventEmitter.ts";
+import { DataChannelRouter } from "./DataChannelRouter.ts";
+
+export class PeerConnection extends EventEmitter {
+	public readonly connection: RTCPeerConnection;
+	public readonly router: DataChannelRouter;
+	public readonly peerId: string;
+	private pendingCandidates: RTCIceCandidateInit[] = [];
+	private hasRemoteDescription = false;
+
+	constructor(
+		peerId: string,
+		iceServers: RTCIceServer[],
+	) {
+		super();
+
+		this.peerId = peerId;
+
+		this.connection = new RTCPeerConnection({ iceServers });
+		this.router = new DataChannelRouter(this.connection);
+
+		this.connection.onicecandidate = (event) => {
+			if (event.candidate) {
+				this.emit("iceCandidate", {
+					peerId: this.peerId,
+					candidate: JSON.stringify(event.candidate.toJSON()),
+				});
+			}
+		};
+
+		this.connection.oniceconnectionstatechange = () => {
+			const state = this.connection.iceConnectionState;
+			this.emit("iceStateChange", { peerId: this.peerId, state });
+
+			if (state === "failed") {
+				this.emit("iceFailed", { peerId: this.peerId });
+			}
+		};
+
+		this.connection.onconnectionstatechange = () => {
+			this.emit("connectionStateChange", {
+				peerId: this.peerId,
+				state: this.connection.connectionState,
+			});
+		};
+	}
+
+	get connectionState(): RTCPeerConnectionState {
+		return this.connection.connectionState;
+	}
+
+	get iceConnectionState(): RTCIceConnectionState {
+		return this.connection.iceConnectionState;
+	}
+
+	/** Create an SDP offer (initiator side). */
+	async createOffer(iceRestart = false): Promise<string> {
+		const offer = await this.connection.createOffer(
+			iceRestart ? { iceRestart: true } : undefined,
+		);
+		await this.connection.setLocalDescription(offer);
+		return JSON.stringify(this.connection.localDescription?.toJSON());
+	}
+
+	/** Set a remote offer and create an answer (receiver side). Returns the SDP answer. */
+	async setRemoteOffer(sdp: string): Promise<string> {
+		const offer = JSON.parse(sdp) as RTCSessionDescriptionInit;
+		await this.connection.setRemoteDescription(
+			new RTCSessionDescription(offer),
+		);
+		this.hasRemoteDescription = true;
+		await this.flushPendingCandidates();
+
+		const answer = await this.connection.createAnswer();
+		await this.connection.setLocalDescription(answer);
+		return JSON.stringify(this.connection.localDescription?.toJSON());
+	}
+
+	/** Set the remote answer (initiator side). */
+	async setRemoteAnswer(sdp: string): Promise<void> {
+		const answer = JSON.parse(sdp) as RTCSessionDescriptionInit;
+		await this.connection.setRemoteDescription(
+			new RTCSessionDescription(answer),
+		);
+		this.hasRemoteDescription = true;
+		await this.flushPendingCandidates();
+	}
+
+	/** Add a remote ICE candidate. Queues if remote description not yet set. */
+	async addIceCandidate(candidateJson: string): Promise<void> {
+		const candidate = JSON.parse(candidateJson) as RTCIceCandidateInit;
+
+		if (!this.hasRemoteDescription) {
+			this.pendingCandidates.push(candidate);
+			return;
+		}
+
+		await this.connection.addIceCandidate(new RTCIceCandidate(candidate));
+	}
+
+	private async flushPendingCandidates(): Promise<void> {
+		for (const candidate of this.pendingCandidates) {
+			await this.connection.addIceCandidate(
+				new RTCIceCandidate(candidate),
+			);
+		}
+		this.pendingCandidates = [];
+	}
+
+	close(): void {
+		this.router.close();
+		try {
+			this.connection.close();
+		} catch {
+			// Ignore
+		}
+	}
+
+	destroy(): void {
+		this.router.destroy();
+		this.connection.onicecandidate = null;
+		this.connection.oniceconnectionstatechange = null;
+		this.connection.onconnectionstatechange = null;
+
+		try {
+			this.connection.close();
+		} catch {
+			// Ignore
+		}
+
+		this.removeAllListeners();
+	}
+}