@coclaw/openclaw-coclaw 0.17.0 → 0.17.1

package/package.json

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

package/src/realtime-bridge.js

@@ -659,6 +659,14 @@ export class RealtimeBridge {
 				return;
 			}
 			if (payload.type === 'res' || payload.type === 'event') {
+				// 过滤 gateway 的管理层广播事件，这些对 WebChat / plugin 客户端无意义：
+				// - health: 全量状态快照（~3KB, ~60s 一次 + RPC 触发），给 Admin UI 的监控仪表盘用
+				// - tick: gateway WS 保活心跳（30s 一次），UI 隔着 DC 不需要，DC 自己有 probe 机制
+				// 不转发可避免后台时 rpc DC 队列被灌满。上游支持按需订阅前先在插件侧拦截。
+				if (payload.type === 'event'
+					&& (payload.event === 'health' || payload.event === 'tick')) {
+					return;
+				}
 				this.webrtcPeer?.broadcast(payload);
 			}
 		});

package/src/webrtc/rpc-send-queue.js

@@ -62,6 +62,10 @@ export class RpcSendQueue {
 	send(jsonStr) {
 		if (this.closed || this.dc.readyState !== 'open') return false;
 
+		// 诊断日志：打印每次入队的事件，跟踪 gateway 还会推哪些事件
+		// 需要时临时打开，平时保持注释避免日志噪音
+		// this.logger.info?.(`[rpc-queue${this.__tagSuffix()}] send-payload ${jsonStr}`);
+
 		const chunks = buildChunks(jsonStr, this.maxMessageSize, this.getNextMsgId);
 		const totalBytes = chunks
 			? chunks.reduce((n, c) => n + c.length, 0)
@@ -80,6 +84,8 @@ export class RpcSendQueue {
 			this.droppedCount += 1;
 			this.droppedBytes += totalBytes;
 			this.logger.warn?.(`[rpc-queue${this.__tagSuffix()}] drop reason=queue-full size=${totalBytes} queueBytes=${this.queueBytes}`);
+			// 诊断日志：定位后台长时间占队的事件来源。需要时临时打开
+			// this.logger.info?.(`[rpc-queue${this.__tagSuffix()}] dropped-payload ${jsonStr}`);
 			if (!this.queueOverflowActive) {
 				this.queueOverflowActive = true;
 				remoteLog(`rpc-queue.overflow-start${this.__tagSuffix()} queueBytes=${this.queueBytes}`);

package/src/webrtc/webrtc-peer.js

@@ -69,6 +69,17 @@ export class WebRtcPeer {
 			clearTimeout(session.__failedTimer);
 			session.__failedTimer = null;
 		}
+		// 清理 plugin-probe 定时器（避免 session 已关闭仍触发 timeout 日志，
+		// 或 500ms 调度窗口内 session 被替换时对着新 session 误发探针）
+		if (session.__pluginProbeSchedTimer) {
+			clearTimeout(session.__pluginProbeSchedTimer);
+			session.__pluginProbeSchedTimer = null;
+		}
+		if (session.__pluginProbeTimer) {
+			clearTimeout(session.__pluginProbeTimer);
+			session.__pluginProbeTimer = null;
+			session.__pluginProbeInFlight = null;
+		}
 		this.__sessions.delete(connId);
 		// 显式关闭 rpc 发送队列：dc.onclose 路径中 `sessions.get(connId)` 已返回 undefined 而短路，
 		// 此处不主动 close 会丢失 drop 汇总 remoteLog 诊断
@@ -83,6 +94,9 @@ export class WebRtcPeer {
 		if ('onselectedcandidatepairchange' in session.pc) {
 			session.pc.onselectedcandidatepairchange = null;
 		}
+		if ('oniceconnectionstatechange' in session.pc) {
+			session.pc.oniceconnectionstatechange = null;
+		}
 		await session.pc.close();
 		this.__remoteLog(`rtc.closed conn=${connId}`);
 		this.logger.info?.(`${this.__rtcTag} [${connId}] closed`);
@@ -175,6 +189,7 @@ export class WebRtcPeer {
 						toConnId: connId,
 						payload: { sdp: answer.sdp },
 					});
+					this.__remoteLog(`rtc.restart-answer-sent conn=${connId}`);
 					this.logger.info?.(`${this.__rtcTag} ICE restart answer sent to ${connId}`);
 					return;
 				} catch (err) {
@@ -245,11 +260,24 @@ export class WebRtcPeer {
 		this.__sessions.set(connId, session);
 
 		// ICE candidate → 发给 UI，并统计各类型 candidate 数量
+		// gather complete 时一并输出 host 候选的 IP:port 列表（诊断 docker/vbridge 误 gather）
 		const candidateCounts = { host: 0, srflx: 0, relay: 0 };
+		const hostAddrs = [];
+		let gatheringEmitted = false;
+		const flushGatherDiag = () => {
+			if (gatheringEmitted) return;
+			gatheringEmitted = true;
+			const hostInfo = hostAddrs.length ? ` hosts=${hostAddrs.join(',')}` : '';
+			this.__remoteLog(`rtc.ice-gathered conn=${connId} host=${candidateCounts.host} srflx=${candidateCounts.srflx} relay=${candidateCounts.relay}${hostInfo}`);
+			candidateCounts.host = 0;
+			candidateCounts.srflx = 0;
+			candidateCounts.relay = 0;
+			hostAddrs.length = 0;
+		};
 		pc.onicecandidate = ({ candidate }) => {
 			if (!candidate) {
-				// gathering 完成，输出汇总
-				this.__remoteLog(`rtc.ice-gathered conn=${connId} host=${candidateCounts.host} srflx=${candidateCounts.srflx} relay=${candidateCounts.relay}`);
+				// 浏览器路径：gathering 完成通过 null candidate 通知
+				flushGatherDiag();
 				return;
 			}
 			// 从 candidate 字符串中提取类型（typ host / typ srflx / typ relay）
@@ -257,6 +285,14 @@ export class WebRtcPeer {
 			if (typMatch && candidateCounts[typMatch[1]] !== undefined) {
 				candidateCounts[typMatch[1]]++;
 			}
+			// host 候选记录 addr:port，用于观察 pion 是否把 docker0 / br-* / loopback 等接口当成 host
+			// candidate 格式: "candidate:<foundation> <comp> <proto> <prio> <ADDR> <PORT> typ host ..."
+			if (typMatch?.[1] === 'host') {
+				const parts = candidate.candidate.split(' ');
+				if (parts.length >= 6) {
+					hostAddrs.push(`${parts[4]}:${parts[5]}`);
+				}
+			}
 			this.__onSend({
 				type: 'rtc:ice',
 				toConnId: connId,
@@ -267,6 +303,29 @@ export class WebRtcPeer {
 				},
 			});
 		};
+		// pion-node 不会在 gather complete 时 fire onicecandidate(null)，用 icegatheringstatechange 兜底。
+		// gathering→ 重置 flag 支持 ICE restart；complete→ flush 汇总
+		if ('onicegatheringstatechange' in pc) {
+			pc.onicegatheringstatechange = () => {
+				const state = pc.iceGatheringState;
+				if (state === 'gathering') {
+					gatheringEmitted = false;
+				} else if (state === 'complete') {
+					flushGatherDiag();
+				}
+			};
+		}
+
+		// ICE agent 状态（pion 暴露的独立事件）：能看到 checking / connected / failed 等纯 ICE 侧跳转，
+		// 与复合 connectionState 互补。对诊断"pion 说 connected 但 UI 看不到数据"非常关键。
+		// 仅在 pion-node 实现中可用；其他实现赋值是 no-op。
+		if ('oniceconnectionstatechange' in pc) {
+			pc.oniceconnectionstatechange = () => {
+				const cur = this.__sessions.get(connId);
+				if (!cur || cur.pc !== pc) return;
+				this.__remoteLog(`rtc.iceState conn=${connId} ${pc.iceConnectionState ?? '?'}`);
+			};
+		}
 
 		// 连接状态变更（校验 pc 归属，防止旧 PC 异步回调删除新 session）
 		pc.onconnectionstatechange = () => {
@@ -285,6 +344,7 @@ export class WebRtcPeer {
 			}
 
 			if (state === 'connected') {
+				const prevDumpState = cur.__lastDumpState;
 				// 重置 dump 去重水位（disconnected → connected → disconnected 仍能再 dump）
 				cur.__lastDumpState = null;
 				// werift: iceTransports[0].connection.nominated
@@ -298,6 +358,22 @@ export class WebRtcPeer {
 					this.logger.info?.(`${this.__rtcTag} [${connId}] ICE nominated: local=${localInfo} remote=${remoteInfo}`);
 				}
 				// pion: pair 通过独立的 selectedcandidatepairchange 事件上报
+				// ICE restart 恢复（disconnected/failed → connected）时做诊断动作：
+				// - dump 当前 session DC 状态，对照"UI 看不到 connected 时 plugin 侧看到什么"
+				// - 发一次 plugin-probe，实测 DC 是否双向可用
+				// 只对 pion 生效：werift/ndc 为兼容路径，不涉及本次调查的病态场景。
+				if (this.__impl === 'pion' && (prevDumpState === 'disconnected' || prevDumpState === 'failed')) {
+					this.__dumpSessionState(connId, cur, 'connected');
+					// 挂到 session 上，使 closeByConnId 能在 500ms 窗口内取消；
+					// 否则 session 被替换（同 connId 新 offer）时会对着新 session 误发探针。
+					if (cur.__pluginProbeSchedTimer) clearTimeout(cur.__pluginProbeSchedTimer);
+					cur.__pluginProbeSchedTimer = setTimeout(() => {
+						cur.__pluginProbeSchedTimer = null;
+						this.__sendPluginProbe(connId);
+					}, 500);
+					// unref() 避免定时器阻塞 gateway 进程退出（gateway 由其他连接保活）。
+					cur.__pluginProbeSchedTimer.unref?.();
+				}
 			} else if (state === 'disconnected' || state === 'failed' || state === 'closed') {
 				// 诊断 dump：失败/断连/关闭时输出当前 PC 上 DC 状态，定位"PC 假活/DC 死"现象
 				// - closed 由 closeByConnId 接管清理，dump 收敛诊断噪声
@@ -427,6 +503,11 @@ export class WebRtcPeer {
 				catch { /* DC 已关闭，忽略 */ }
 				return;
 			}
+			// 来自 UI 的 plugin-probe 回复：验证 plugin → UI 方向确实传达并被回传
+			if (payload.type === 'plugin-probe-ack') {
+				this.__handlePluginProbeAck(connId, payload.id);
+				return;
+			}
 			if (payload.type === 'req') {
 				// coclaw.files.* 方法本地处理，不转发 gateway
 				if (payload.method?.startsWith('coclaw.files.') && this.__onFileRpc) {
@@ -558,6 +639,59 @@ export class WebRtcPeer {
 		this.__remoteLog(`rtc.peer-transport conn=${connId} type=${payload.candidateType} proto=${payload.protocol} relay=${payload.relayProtocol ?? '-'}`);
 	}
 
+	/**
+	 * 主动探针：在 rpc DC 上发一个 plugin-probe，期待 UI 回 plugin-probe-ack。
+	 * 用于区分"pion 报告 connected 但 UI 其实没收到数据"与"UI 真的收到了但没记录事件"。
+	 * 绕过 RpcSendQueue（与 probe-ack 对称），仅测量传输层，不受应用层积压影响。
+	 * 同一 session 同时只保留一条 in-flight 探针；超时仅打日志，不影响业务恢复。
+	 */
+	__sendPluginProbe(connId) {
+		const session = this.__sessions.get(connId);
+		if (!session) return;
+		const dc = session.rpcChannel;
+		if (!dc || dc.readyState !== 'open') return;
+		// 已有 in-flight 则跳过（避免重复）
+		if (session.__pluginProbeInFlight) return;
+
+		const id = (session.__pluginProbeIdSeq = (session.__pluginProbeIdSeq ?? 0) + 1);
+		const startMs = Date.now();
+		const timer = setTimeout(() => {
+			if (session.__pluginProbeInFlight?.id === id) {
+				session.__pluginProbeInFlight = null;
+				session.__pluginProbeTimer = null;
+				this.__remoteLog(`rtc.plugin-probe conn=${connId} id=${id} timeout`);
+			}
+		}, 5000);
+		timer.unref?.();
+		session.__pluginProbeInFlight = { id, startMs };
+		session.__pluginProbeTimer = timer;
+
+		try {
+			dc.send(JSON.stringify({ type: 'plugin-probe', id }));
+			this.__remoteLog(`rtc.plugin-probe conn=${connId} id=${id} sent`);
+		} catch (err) {
+			clearTimeout(timer);
+			session.__pluginProbeInFlight = null;
+			session.__pluginProbeTimer = null;
+			this.__remoteLog(`rtc.plugin-probe conn=${connId} id=${id} send-failed msg=${err?.message ?? err}`);
+		}
+	}
+
+	/** 收到 UI 的 plugin-probe-ack：计算 RTT 并释放 in-flight 槽位 */
+	__handlePluginProbeAck(connId, id) {
+		const session = this.__sessions.get(connId);
+		if (!session) return;
+		const inFlight = session.__pluginProbeInFlight;
+		if (!inFlight || inFlight.id !== id) return; // 过期 ack，忽略
+		const rtt = Date.now() - inFlight.startMs;
+		if (session.__pluginProbeTimer) {
+			clearTimeout(session.__pluginProbeTimer);
+			session.__pluginProbeTimer = null;
+		}
+		session.__pluginProbeInFlight = null;
+		this.__remoteLog(`rtc.plugin-probe conn=${connId} id=${id} acked rtt=${rtt}`);
+	}
+
 	__remoteLog(msg) {
 		remoteLog(this.__impl ? `${msg} rtc=${this.__impl}` : msg);
 	}