@coclaw/openclaw-coclaw 0.8.0 → 0.8.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coclaw/openclaw-coclaw",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "type": "module",
   "license": "Apache-2.0",
   "description": "OpenClaw CoClaw channel plugin for remote chat",

package/src/utils/dc-chunking.js

@@ -0,0 +1,140 @@
+/**
+ * DataChannel 应用层分片/重组
+ * 协议：普通消息用 string，分片消息用 binary（Buffer）
+ *
+ * 二进制帧格式：
+ *   Byte 0:   flag (0x01=BEGIN, 0x00=MIDDLE, 0x02=END)
+ *   Byte 1-4: msgId (uint32 BE)
+ *   Byte 5+:  UTF-8 数据片段
+ */
+
+export const FLAG_BEGIN = 0x01;
+export const FLAG_MIDDLE = 0x00;
+export const FLAG_END = 0x02;
+export const HEADER_SIZE = 5; // 1 flag + 4 msgId
+
+/** 单条消息重组缓冲区上限 */
+export const MAX_REASSEMBLY_BYTES = 50 * 1024 * 1024;
+/** 单条消息最大 chunk 数（防止无 END 的 BEGIN 泄漏） */
+export const MAX_CHUNKS_PER_MSG = 10_000;
+
+const encoder = new TextEncoder();
+const decoder = new TextDecoder();
+
+/**
+ * 按需分片并发送消息
+ * 小于 maxMessageSize 直接发 string；否则切成 binary chunk 逐个发送
+ * @param {object} dc - DataChannel（werift 或浏览器）
+ * @param {string} jsonStr - 已序列化的 JSON 字符串
+ * @param {number} maxMessageSize - 对端声明的 maxMessageSize
+ * @param {() => number} getNextMsgId - 获取下一个 msgId
+ */
+export function chunkAndSend(dc, jsonStr, maxMessageSize, getNextMsgId, logger) {
+	const fullBytes = encoder.encode(jsonStr);
+	// 快路径：不需要分片
+	if (fullBytes.byteLength <= maxMessageSize) {
+		dc.send(jsonStr);
+		return;
+	}
+
+	const chunkPayloadSize = maxMessageSize - HEADER_SIZE;
+	if (chunkPayloadSize <= 0) {
+		throw new Error(`maxMessageSize (${maxMessageSize}) too small for chunking header`);
+	}
+
+	const msgId = getNextMsgId();
+	const totalChunks = Math.ceil(fullBytes.byteLength / chunkPayloadSize);
+	logger?.info?.(`[dc-chunking] chunking msgId=${msgId}: ${fullBytes.byteLength} bytes → ${totalChunks} chunks (maxMsgSize=${maxMessageSize})`);
+
+	for (let i = 0; i < totalChunks; i++) {
+		const start = i * chunkPayloadSize;
+		const end = Math.min(start + chunkPayloadSize, fullBytes.byteLength);
+		const flag = i === 0 ? FLAG_BEGIN : (i === totalChunks - 1 ? FLAG_END : FLAG_MIDDLE);
+
+		const chunk = Buffer.allocUnsafe(HEADER_SIZE + (end - start));
+		chunk[0] = flag;
+		chunk.writeUInt32BE(msgId, 1);
+		chunk.set(fullBytes.subarray(start, end), HEADER_SIZE);
+
+		dc.send(chunk);
+	}
+}
+
+/**
+ * 创建分片重组器
+ * @param {(jsonStr: string) => void} onComplete - 完整消息回调
+ * @param {object} [opts]
+ * @param {object} [opts.logger] - warn 日志输出
+ * @returns {{ feed: (data: string|Buffer) => void, reset: () => void }}
+ */
+export function createReassembler(onComplete, opts = {}) {
+	const logger = opts.logger;
+	/** @type {Map<number, { chunks: Buffer[], totalBytes: number }>} */
+	const pending = new Map();
+
+	function feed(data) {
+		// string = 普通消息，直接交付
+		if (typeof data === 'string') {
+			onComplete(data);
+			return;
+		}
+
+		// binary = 分片 chunk
+		const buf = Buffer.isBuffer(data) ? data : Buffer.from(data);
+		if (buf.length < HEADER_SIZE) {
+			logger?.warn?.('[dc-chunking] chunk too short, discarding');
+			return;
+		}
+
+		const flag = buf[0];
+		const msgId = buf.readUInt32BE(1);
+		const payload = buf.subarray(HEADER_SIZE);
+
+		if (flag === FLAG_BEGIN) {
+			// 若已有同 msgId 的未完成重组，丢弃旧的
+			if (pending.has(msgId)) {
+				logger?.warn?.(`[dc-chunking] orphan reassembly discarded for msgId=${msgId}`);
+			}
+			pending.set(msgId, { chunks: [payload], totalBytes: payload.length });
+			return;
+		}
+
+		const entry = pending.get(msgId);
+		if (!entry) {
+			logger?.warn?.(`[dc-chunking] chunk for unknown msgId=${msgId}, discarding`);
+			return;
+		}
+
+		entry.totalBytes += payload.length;
+
+		// 安全检查：缓冲区大小上限
+		if (entry.totalBytes > MAX_REASSEMBLY_BYTES) {
+			logger?.warn?.(`[dc-chunking] reassembly buffer exceeded ${MAX_REASSEMBLY_BYTES} bytes for msgId=${msgId}, discarding`);
+			pending.delete(msgId);
+			return;
+		}
+
+		// 安全检查：chunk 数量上限
+		if (entry.chunks.length >= MAX_CHUNKS_PER_MSG) {
+			logger?.warn?.(`[dc-chunking] too many chunks for msgId=${msgId}, discarding`);
+			pending.delete(msgId);
+			return;
+		}
+
+		entry.chunks.push(payload);
+
+		if (flag === FLAG_END) {
+			pending.delete(msgId);
+			const merged = Buffer.concat(entry.chunks);
+			logger?.info?.(`[dc-chunking] reassembled msgId=${msgId}: ${entry.chunks.length} chunks, ${merged.length} bytes`);
+			onComplete(decoder.decode(merged));
+		}
+		// flag === FLAG_MIDDLE → 继续等待
+	}
+
+	function reset() {
+		pending.clear();
+	}
+
+	return { feed, reset };
+}

package/src/webrtc-peer.js

@@ -1,4 +1,5 @@
 import { RTCPeerConnection as WeriftRTCPeerConnection } from 'werift';
+import { chunkAndSend, createReassembler } from './utils/dc-chunking.js';
 
 /**
  * 管理多个 WebRTC PeerConnection（以 connId 为粒度）。
@@ -21,7 +22,7 @@ export class WebRtcPeer {
 		this.__onFileChannel = onFileChannel;
 		this.logger = logger ?? console;
 		this.__PeerConnection = PeerConnection ?? WeriftRTCPeerConnection;
-		/** @type {Map<string, { pc: object, rpcChannel: object|null }>} */
+		/** @type {Map<string, { pc: object, rpcChannel: object|null, remoteMaxMessageSize: number, nextMsgId: number }>} */
 		this.__sessions = new Map();
 	}
 
@@ -45,6 +46,9 @@ export class WebRtcPeer {
 		const session = this.__sessions.get(connId);
 		if (!session) return;
 		this.__sessions.delete(connId);
+		// 先 detach 事件，防止 pc.close() 异步触发 onconnectionstatechange 删除新 session
+		session.pc.onconnectionstatechange = null;
+		session.pc.onicecandidate = null;
 		await session.pc.close();
 		this.logger.info?.(`[coclaw/rtc] [${connId}] closed`);
 	}
@@ -55,20 +59,50 @@ export class WebRtcPeer {
 		await Promise.all(closing);
 	}
 
-	/** 向所有已打开的 rpcChannel 广播 */
+	/** 向所有已打开的 rpcChannel 广播（大消息自动分片） */
 	broadcast(payload) {
-		const data = JSON.stringify(payload);
+		const jsonStr = JSON.stringify(payload);
 		for (const [connId, session] of this.__sessions) {
 			const dc = session.rpcChannel;
 			if (dc?.readyState === 'open') {
-				try { dc.send(data); }
-				catch (err) { this.__logDebug(`[${connId}] broadcast send failed: ${err.message}`); }
+				try {
+					chunkAndSend(dc, jsonStr, session.remoteMaxMessageSize, () => session.nextMsgId++, this.logger);
+				} catch (err) {
+					this.__logDebug(`[${connId}] broadcast send failed: ${err.message}`);
+				}
 			}
 		}
 	}
 
 	async __handleOffer(msg) {
 		const connId = msg.fromConnId;
+		const isIceRestart = !!msg.payload?.iceRestart;
+
+		// ICE restart：在现有 PC 上重新协商，保持 DTLS session
+		if (isIceRestart) {
+			const existing = this.__sessions.get(connId);
+			if (existing) {
+				this.logger.info?.(`[coclaw/rtc] ICE restart offer from ${connId}, renegotiating`);
+				try {
+					await existing.pc.setRemoteDescription({ type: 'offer', sdp: msg.payload.sdp });
+					const answer = await existing.pc.createAnswer();
+					await existing.pc.setLocalDescription(answer);
+					this.__onSend({
+						type: 'rtc:answer',
+						toConnId: connId,
+						payload: { sdp: answer.sdp },
+					});
+					this.logger.info?.(`[coclaw/rtc] ICE restart answer sent to ${connId}`);
+					return;
+				} catch (err) {
+					// ICE restart 协商失败 → 回退到 full rebuild
+					this.logger.warn?.(`[coclaw/rtc] ICE restart failed for ${connId}, falling back to rebuild: ${err?.message}`);
+					await this.closeByConnId(connId);
+				}
+			}
+			// 无现有 session 或 ICE restart 失败 → 按 full rebuild 继续
+		}
+
 		this.logger.info?.(`[coclaw/rtc] offer received from ${connId}, creating answer`);
 
 		// 同一 connId 重复 offer → 先关闭旧连接
@@ -92,7 +126,12 @@ export class WebRtcPeer {
 		}
 
 		const pc = new this.__PeerConnection({ iceServers });
-		const session = { pc, rpcChannel: null };
+
+		// 从 SDP 解析对端 maxMessageSize（用于分片决策）
+		const mmsMatch = msg.payload.sdp?.match(/a=max-message-size:(\d+)/);
+		const remoteMaxMessageSize = mmsMatch ? parseInt(mmsMatch[1], 10) : 65536;
+
+		const session = { pc, rpcChannel: null, remoteMaxMessageSize, nextMsgId: 1 };
 		this.__sessions.set(connId, session);
 
 		// ICE candidate → 发给 UI
@@ -109,18 +148,24 @@ export class WebRtcPeer {
 			});
 		};
 
-		// 连接状态变更
+		// 连接状态变更（校验 pc 归属，防止旧 PC 异步回调删除新 session）
 		pc.onconnectionstatechange = () => {
 			const state = pc.connectionState;
 			this.logger.info?.(`[coclaw/rtc] [${connId}] connectionState: ${state}`);
 			if (state === 'connected') {
 				const nominated = pc.iceTransports?.[0]?.connection?.nominated;
 				if (nominated) {
-					const type = nominated.localCandidate?.type ?? 'unknown';
-					this.logger.info?.(`[coclaw/rtc] [${connId}] ICE connected via ${type}`);
+					const localC = nominated.localCandidate;
+					const remoteC = nominated.remoteCandidate;
+					const localInfo = `${localC?.type ?? '?'} ${localC?.host ?? '?'}:${localC?.port ?? '?'}`;
+					const remoteInfo = `${remoteC?.type ?? '?'} ${remoteC?.host ?? '?'}:${remoteC?.port ?? '?'}`;
+					this.logger.info?.(`[coclaw/rtc] [${connId}] ICE nominated: local=${localInfo} remote=${remoteInfo}`);
 				}
 			} else if (state === 'failed' || state === 'closed') {
-				this.__sessions.delete(connId);
+				const cur = this.__sessions.get(connId);
+				if (cur && cur.pc === pc) {
+					this.__sessions.delete(connId);
+				}
 			}
 		};
 
@@ -149,7 +194,10 @@ export class WebRtcPeer {
 			this.logger.info?.(`[coclaw/rtc] answer sent to ${connId}`);
 		} catch (err) {
 			// SDP 协商失败 → 清理已入 Map 的 session，避免泄漏
-			this.__sessions.delete(connId);
+			const cur = this.__sessions.get(connId);
+			if (cur && cur.pc === pc) {
+				this.__sessions.delete(connId);
+			}
 			await pc.close().catch(() => {});
 			throw err;
 		}
@@ -167,34 +215,47 @@ export class WebRtcPeer {
 	}
 
 	__setupDataChannel(connId, dc) {
+		const reassembler = createReassembler((jsonStr) => {
+			const payload = JSON.parse(jsonStr);
+			if (payload.type === 'req') {
+				// coclaw.file.* 方法本地处理，不转发 gateway
+				if (payload.method?.startsWith('coclaw.file.') && this.__onFileRpc) {
+					const session = this.__sessions.get(connId);
+					const sendFn = (response) => {
+						try {
+							chunkAndSend(
+								dc, JSON.stringify(response),
+								session?.remoteMaxMessageSize ?? 65536,
+								() => session.nextMsgId++,
+								this.logger,
+							);
+						} catch (err) {
+							this.__logDebug(`[${connId}] sendFn failed: ${err.message}`);
+						}
+					};
+					this.__onFileRpc(payload, sendFn, connId);
+				} else {
+					this.__onRequest?.(payload, connId);
+				}
+			} else {
+				this.__logDebug(`[${connId}] unknown DC message type: ${payload.type}`);
+			}
+		}, { logger: this.logger });
+
 		dc.onopen = () => {
 			this.logger.info?.(`[coclaw/rtc] [${connId}] DataChannel "${dc.label}" opened`);
 		};
 		dc.onclose = () => {
 			this.logger.info?.(`[coclaw/rtc] [${connId}] DataChannel "${dc.label}" closed`);
+			reassembler.reset();
 			const session = this.__sessions.get(connId);
 			if (session && dc.label === 'rpc') session.rpcChannel = null;
 		};
 		dc.onmessage = (event) => {
 			try {
-				const raw = typeof event.data === 'string' ? event.data : event.data.toString();
-				const payload = JSON.parse(raw);
-				if (payload.type === 'req') {
-					// coclaw.file.* 方法本地处理，不转发 gateway
-					if (payload.method?.startsWith('coclaw.file.') && this.__onFileRpc) {
-						const sendFn = (response) => {
-							try { dc.send(JSON.stringify(response)); }
-							catch { /* DC 可能已关闭 */ }
-						};
-						this.__onFileRpc(payload, sendFn, connId);
-					} else {
-						this.__onRequest?.(payload, connId);
-					}
-				} else {
-					this.__logDebug(`[${connId}] unknown DC message type: ${payload.type}`);
-				}
+				reassembler.feed(event.data);
 			} catch (err) {
-				this.logger.warn?.(`[coclaw/rtc] [${connId}] DC message parse failed: ${err.message}`);
+				this.logger.warn?.(`[coclaw/rtc] [${connId}] DC message error: ${err.message}`);
 			}
 		};
 	}