@coclaw/openclaw-coclaw 0.8.1 → 0.9.0

package/package.json

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

package/src/config.js

@@ -29,19 +29,24 @@ function toRecord(value) {
 }
 
 async function readJson(filePath) {
+	let raw;
 	try {
-		const raw = await fs.readFile(filePath, 'utf8');
-		if (!String(raw).trim()) {
-			return {};
-		}
-		return JSON.parse(raw);
+		raw = await fs.readFile(filePath, 'utf8');
 	}
 	catch (err) {
-		if (err?.code === 'ENOENT') {
-			return {};
-		}
+		if (err?.code === 'ENOENT') return {};
+		/* c8 ignore next 2 */
 		throw err;
 	}
+	if (!String(raw).trim()) return {};
+	try {
+		return JSON.parse(raw);
+	}
+	catch {
+		// 文件损坏，删除后当空文件处理
+		await fs.unlink(filePath).catch(() => {});
+		return {};
+	}
 }
 
 const bindingsMutex = createMutex();

package/src/file-manager/handler.js

@@ -1,7 +1,7 @@
 import fs from 'node:fs';
 import fsp from 'node:fs/promises';
 import nodePath from 'node:path';
-import { randomUUID } from 'node:crypto';
+import { randomUUID, randomBytes } from 'node:crypto';
 
 // --- 常量 ---
 
@@ -93,6 +93,7 @@ export function createFileHandler({ resolveWorkspace, logger, deps = {} }) {
 	const _readdir = deps.readdir ?? fsp.readdir;
 	const _unlink = deps.unlink ?? fsp.unlink;
 	const _rmdir = deps.rmdir ?? fsp.rmdir;
+	const _rm = deps.rm ?? fsp.rm;
 	const _stat = deps.stat ?? fsp.stat;
 	const _mkdir = deps.mkdir ?? fsp.mkdir;
 	const _rename = deps.rename ?? fsp.rename;
@@ -102,22 +103,28 @@ export function createFileHandler({ resolveWorkspace, logger, deps = {} }) {
 
 	const pathDeps = { lstat: _lstat, realpath: _realpath };
 
-	// --- RPC 处理（rpc DC 上的 coclaw.file.list / coclaw.file.delete） ---
+	// --- RPC 处理（rpc DC 上的 coclaw.files.* 方法） ---
 
 	/**
-	 * 处理 rpc DC 上的 coclaw.file.* 请求
+	 * 处理 rpc DC 上的 coclaw.files.* 请求
 	 * @param {object} payload - { id, method, params }
 	 * @param {function} sendFn - (responseObj) => void
 	 */
 	async function handleRpcRequest(payload, sendFn) {
 		const { id, method, params } = payload;
 		try {
-			if (method === 'coclaw.file.list') {
+			if (method === 'coclaw.files.list') {
 				const result = await listFiles(params);
 				sendFn({ type: 'res', id, ok: true, payload: result });
-			} else if (method === 'coclaw.file.delete') {
+			} else if (method === 'coclaw.files.delete') {
 				const result = await deleteFile(params);
 				sendFn({ type: 'res', id, ok: true, payload: result });
+			} else if (method === 'coclaw.files.mkdir') {
+				const result = await mkdirOp(params);
+				sendFn({ type: 'res', id, ok: true, payload: result });
+			} else if (method === 'coclaw.files.create') {
+				const result = await createFile(params);
+				sendFn({ type: 'res', id, ok: true, payload: result });
 			} else {
 				sendFn({
 					type: 'res', id, ok: false,
@@ -207,15 +214,19 @@ export function createFileHandler({ resolveWorkspace, logger, deps = {} }) {
 			throw e;
 		}
 		if (stat.isDirectory()) {
-			try {
-				await _rmdir(resolved);
-			} catch (e) {
-				if (e.code === 'ENOTEMPTY') {
-					const err = new Error(`Directory not empty: ${userPath}`);
-					err.code = 'NOT_EMPTY';
-					throw err;
+			if (params?.force) {
+				await _rm(resolved, { recursive: true, force: true });
+			} else {
+				try {
+					await _rmdir(resolved);
+				} catch (e) {
+					if (e.code === 'ENOTEMPTY') {
+						const err = new Error(`Directory not empty: ${userPath}`);
+						err.code = 'NOT_EMPTY';
+						throw err;
+					}
+					throw e;
 				}
-				throw e;
 			}
 		} else {
 			await _unlink(resolved);
@@ -223,6 +234,79 @@ export function createFileHandler({ resolveWorkspace, logger, deps = {} }) {
 		return {};
 	}
 
+	async function mkdirOp(params) {
+		const agentId = params?.agentId?.trim?.() || 'main';
+		const userPath = params?.path;
+		if (!userPath) {
+			const err = new Error('path is required');
+			err.code = 'PATH_DENIED';
+			throw err;
+		}
+		const workspaceDir = await resolveWorkspace(agentId);
+		const resolved = await validatePath(workspaceDir, userPath, pathDeps);
+		await _mkdir(resolved, { recursive: true });
+		return {};
+	}
+
+	async function createFile(params) {
+		const agentId = params?.agentId?.trim?.() || 'main';
+		const userPath = params?.path;
+		if (!userPath) {
+			const err = new Error('path is required');
+			err.code = 'PATH_DENIED';
+			throw err;
+		}
+		const workspaceDir = await resolveWorkspace(agentId);
+		const resolved = await validatePath(workspaceDir, userPath, pathDeps);
+
+		// 检查文件是否已存在
+		try {
+			await _lstat(resolved);
+			// 没抛异常说明存在
+			const err = new Error(`File already exists: ${userPath}`);
+			err.code = 'ALREADY_EXISTS';
+			throw err;
+		} catch (e) {
+			if (e.code === 'ALREADY_EXISTS') throw e;
+			if (e.code !== 'ENOENT') throw e;
+			// ENOENT — 不存在，继续创建
+		}
+
+		// 确保父目录存在
+		await _mkdir(nodePath.dirname(resolved), { recursive: true });
+		await (deps.writeFile ?? fsp.writeFile)(resolved, '');
+		return {};
+	}
+
+	/**
+	 * 生成唯一文件名：<name>-<4hex>.<ext>，碰撞时重试
+	 * @param {string} dir - 目标目录绝对路径
+	 * @param {string} fileName - 原始文件名
+	 * @returns {Promise<string>} 唯一文件名（仅文件名，非完整路径）
+	 */
+	async function generateUniqueName(dir, fileName) {
+		const ext = nodePath.extname(fileName);
+		const base = nodePath.basename(fileName, ext);
+		const maxAttempts = 20;
+		for (let i = 0; i < maxAttempts; i++) {
+			const hex = randomBytes(2).toString('hex');
+			const candidate = `${base}-${hex}${ext}`;
+			try {
+				await _lstat(nodePath.join(dir, candidate));
+				// 存在 → 碰撞，重试
+			} catch (e) {
+				if (e.code === 'ENOENT') return candidate;
+				/* c8 ignore next -- lstat 非 ENOENT 属罕见 IO 异常 */
+				throw e;
+			} /* c8 ignore next */
+		}
+		/* c8 ignore start -- 20 次均碰撞几乎不可能 */
+		const err = new Error(`Cannot generate unique name for: ${fileName}`);
+		err.code = 'WRITE_FAILED';
+		throw err;
+		/* c8 ignore stop */
+	}
+
 	// --- File DataChannel 处理 ---
 
 	/**
@@ -262,15 +346,20 @@ export function createFileHandler({ resolveWorkspace, logger, deps = {} }) {
 				return;
 			}
 
-			if (req.method === 'read') {
-				/* c8 ignore next 3 -- handleRead 内部已完整处理异常，此 catch 纯防御 */
-				handleRead(dc, req).catch((err) => {
-					log.warn?.(`[coclaw/file] read error: ${err.message}`);
+			if (req.method === 'GET') {
+				/* c8 ignore next 3 -- handleGet 内部已完整处理异常，此 catch 纯防御 */
+				handleGet(dc, req).catch((err) => {
+					log.warn?.(`[coclaw/file] GET error: ${err.message}`);
+				});
+			} else if (req.method === 'PUT') {
+				/* c8 ignore next 3 -- handlePut 内部已完整处理异常，此 catch 纯防御 */
+				handlePut(dc, req).catch((err) => {
+					log.warn?.(`[coclaw/file] PUT error: ${err.message}`);
 				});
-			} else if (req.method === 'write') {
-				/* c8 ignore next 3 -- handleWrite 内部已完整处理异常，此 catch 纯防御 */
-				handleWrite(dc, req).catch((err) => {
-					log.warn?.(`[coclaw/file] write error: ${err.message}`);
+			} else if (req.method === 'POST') {
+				/* c8 ignore next 3 -- handlePost 内部已完整处理异常，此 catch 纯防御 */
+				handlePost(dc, req).catch((err) => {
+					log.warn?.(`[coclaw/file] POST error: ${err.message}`);
 				});
 			} else {
 				sendError(dc, 'UNKNOWN_METHOD', `Unknown method: ${req.method}`);
@@ -278,7 +367,7 @@ export function createFileHandler({ resolveWorkspace, logger, deps = {} }) {
 		};
 	}
 
-	async function handleRead(dc, req) {
+	async function handleGet(dc, req) {
 		let workspaceDir, resolved;
 		try {
 			const agentId = req.agentId?.trim?.() || 'main'; /* c8 ignore next -- ?./?? fallback */
@@ -367,7 +456,7 @@ export function createFileHandler({ resolveWorkspace, logger, deps = {} }) {
 		});
 	}
 
-	async function handleWrite(dc, req) {
+	async function handlePut(dc, req) {
 		let workspaceDir, resolved;
 		try {
 			const agentId = req.agentId?.trim?.() || 'main';
@@ -377,7 +466,59 @@ export function createFileHandler({ resolveWorkspace, logger, deps = {} }) {
 			sendError(dc, err.code ?? 'INTERNAL_ERROR', err.message);
 			return;
 		}
+		await receiveUpload(dc, req, resolved);
+	}
+
+	async function handlePost(dc, req) {
+		let workspaceDir, dirResolved;
+		try {
+			const agentId = req.agentId?.trim?.() || 'main';
+			workspaceDir = await resolveWorkspace(agentId);
+			dirResolved = await validatePath(workspaceDir, req.path || '.', pathDeps);
+		} catch (err) {
+			sendError(dc, err.code ?? 'INTERNAL_ERROR', err.message);
+			return;
+		}
 
+		const fileName = req.fileName;
+		if (!fileName || typeof fileName !== 'string') {
+			sendError(dc, 'INVALID_INPUT', 'fileName is required for POST');
+			return;
+		}
+
+		// 确保集合目录存在
+		try {
+			await _mkdir(dirResolved, { recursive: true });
+		} catch (err) {
+			sendError(dc, 'WRITE_FAILED', `Cannot create directory: ${err.message}`);
+			return;
+		}
+
+		// 生成唯一文件名
+		let uniqueName;
+		try {
+			uniqueName = await generateUniqueName(dirResolved, fileName);
+		/* c8 ignore start -- generateUniqueName 内部已处理，此为防御 */
+		} catch (err) {
+			sendError(dc, err.code ?? 'WRITE_FAILED', err.message);
+			return;
+		}
+		/* c8 ignore stop */
+
+		const resolved = nodePath.join(dirResolved, uniqueName);
+		// 计算相对于 workspace 的路径，作为响应中的 path
+		const relativePath = nodePath.relative(workspaceDir, resolved);
+		await receiveUpload(dc, req, resolved, relativePath);
+	}
+
+	/**
+	 * 共享上传接收逻辑（PUT/POST 复用）
+	 * @param {object} dc - DataChannel
+	 * @param {object} req - 请求对象（含 size）
+	 * @param {string} resolved - 目标文件绝对路径
+	 * @param {string} [relativePath] - POST 时附带的相对路径（响应中返回）
+	 */
+	async function receiveUpload(dc, req, resolved, relativePath) {
 		const declaredSize = req.size;
 		if (!Number.isFinite(declaredSize) || declaredSize < 0) {
 			sendError(dc, 'INVALID_INPUT', 'size must be a non-negative number');
@@ -388,7 +529,7 @@ export function createFileHandler({ resolveWorkspace, logger, deps = {} }) {
 			return;
 		}
 
-		// 确保目标目录存在
+		// 确保目标目录存在（PUT 场景需要；POST 已在上层创建，幂等无害）
 		const targetDir = nodePath.dirname(resolved);
 		try {
 			await _mkdir(targetDir, { recursive: true });
@@ -460,8 +601,10 @@ export function createFileHandler({ resolveWorkspace, logger, deps = {} }) {
 							try { dc.close(); } catch { /* ignore */ }
 							return;
 						}
+						const result = { ok: true, bytes: receivedBytes };
+						if (relativePath) result.path = relativePath;
 						try {
-							dc.send(JSON.stringify({ ok: true, bytes: receivedBytes }));
+							dc.send(JSON.stringify(result));
 						/* c8 ignore next */
 						} catch { /* ignore */ }
 						/* c8 ignore next */
@@ -580,8 +723,12 @@ export function createFileHandler({ resolveWorkspace, logger, deps = {} }) {
 		// 暴露内部方法便于测试
 		__listFiles: listFiles,
 		__deleteFile: deleteFile,
-		__handleRead: handleRead,
-		__handleWrite: handleWrite,
+		__mkdirOp: mkdirOp,
+		__createFile: createFile,
+		__handleGet: handleGet,
+		__handlePut: handlePut,
+		__handlePost: handlePost,
+		__generateUniqueName: generateUniqueName,
 		__cleanupTmpFilesInDir: cleanupTmpFilesInDir,
 	};
 }

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 为粒度）。
@@ -9,7 +10,7 @@ export class WebRtcPeer {
 	 * @param {object} opts
 	 * @param {function} opts.onSend - 将信令消息交给 RealtimeBridge 发送
 	 * @param {function} [opts.onRequest] - DataChannel 收到 req 消息时的回调 (payload, connId) => void
-	 * @param {function} [opts.onFileRpc] - rpc DC 上 coclaw.file.* 请求的回调 (payload, sendFn, connId) => void
+	 * @param {function} [opts.onFileRpc] - rpc DC 上 coclaw.files.* 请求的回调 (payload, sendFn, connId) => void
 	 * @param {function} [opts.onFileChannel] - file:<transferId> DataChannel 的回调 (dc, connId) => void
 	 * @param {object} [opts.logger] - pino 风格 logger
 	 * @param {function} [opts.PeerConnection] - 可替换的构造函数（测试用）
@@ -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();
 	}
 
@@ -58,14 +59,17 @@ 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}`);
+				}
 			}
 		}
 	}
@@ -122,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
@@ -146,8 +155,11 @@ export class WebRtcPeer {
 			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') {
 				const cur = this.__sessions.get(connId);
@@ -203,34 +215,47 @@ export class WebRtcPeer {
 	}
 
 	__setupDataChannel(connId, dc) {
+		const reassembler = createReassembler((jsonStr) => {
+			const payload = JSON.parse(jsonStr);
+			if (payload.type === 'req') {
+				// coclaw.files.* 方法本地处理，不转发 gateway
+				if (payload.method?.startsWith('coclaw.files.') && 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}`);
 			}
 		};
 	}