@coclaw/openclaw-coclaw 0.6.2 → 0.7.1

package/openclaw.plugin.json

@@ -2,7 +2,6 @@
   "id": "openclaw-coclaw",
   "name": "CoClaw",
   "description": "OpenClaw CoClaw channel plugin for remote chat",
-  "channels": ["coclaw"],
   "configSchema": {
     "type": "object",
     "additionalProperties": false,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@coclaw/openclaw-coclaw",
-  "version": "0.6.2",
+  "version": "0.7.1",
   "type": "module",
   "license": "Apache-2.0",
   "description": "OpenClaw CoClaw channel plugin for remote chat",
@@ -63,6 +63,9 @@
     "release:check": "bash ./scripts/release-check.sh",
     "release:versions": "npm view @coclaw/openclaw-coclaw versions --json --registry=https://registry.npmjs.org/ && npm view @coclaw/openclaw-coclaw versions --json"
   },
+  "dependencies": {
+    "werift": "^0.19.0"
+  },
   "devDependencies": {
     "c8": "^10.1.3",
     "eslint": "^9.39.2"

package/src/auto-upgrade/worker-verify.js

@@ -23,7 +23,7 @@ const CMD_TIMEOUT_MS = 30_000;
  * @param {Function} [opts.execFileFn]
  * @returns {Promise<string>}
  */
-function exec(cmd, args, opts) {
+function runCmd(cmd, args, opts) {
 	const doExecFile = opts?.execFileFn ?? nodeExecFile;
 	return new Promise((resolve, reject) => {
 		doExecFile(cmd, args, { timeout: CMD_TIMEOUT_MS, shell: true }, (err, stdout) => {
@@ -44,7 +44,7 @@ function exec(cmd, args, opts) {
 export async function waitForGateway(opts) {
 	// 主动触发重启，不依赖 OpenClaw 的文件变更自动重启策略
 	try {
-		await exec('openclaw', ['gateway', 'restart'], opts);
+		await runCmd('openclaw', ['gateway', 'restart'], opts);
 	}
 	catch {
 		// restart 命令失败不阻断流程，仍尝试等待
@@ -56,7 +56,7 @@ export async function waitForGateway(opts) {
 
 	while (Date.now() - start < timeout) {
 		try {
-			const output = await exec('openclaw', ['gateway', 'status'], opts);
+			const output = await runCmd('openclaw', ['gateway', 'status'], opts);
 			if (output.includes('running')) return;
 		}
 		catch {
@@ -76,7 +76,7 @@ export async function waitForGateway(opts) {
  * @returns {Promise<void>}
  */
 export async function verifyPluginLoaded(pluginId, opts) {
-	const output = await exec('openclaw', ['plugins', 'list'], opts);
+	const output = await runCmd('openclaw', ['plugins', 'list'], opts);
 	if (!output.includes(pluginId)) {
 		throw new Error(`Plugin ${pluginId} not found in plugins list`);
 	}
@@ -89,7 +89,7 @@ export async function verifyPluginLoaded(pluginId, opts) {
  * @returns {Promise<string>} 返回版本号
  */
 export async function verifyUpgradeHealth(opts) {
-	const output = await exec(
+	const output = await runCmd(
 		'openclaw',
 		['gateway', 'call', 'coclaw.upgradeHealth', '--json'],
 		opts,

package/src/channel-plugin.js

@@ -22,7 +22,7 @@ export const coclawChannelPlugin = {
 	capabilities: {
 		chatTypes: ['direct'],
 		nativeCommands: true,
-		media: false,
+		media: true,
 		reactions: false,
 		threads: false,
 		polls: false,

package/src/realtime-bridge.js

@@ -97,6 +97,7 @@ export class RealtimeBridge {
 		this.serverHbTimer = null;
 		this.__serverHbMissCount = 0;
 		this.__deviceIdentity = null;
+		this.webrtcPeer = null;
 	}
 
 	__resolveWebSocket() {
@@ -512,6 +513,7 @@ export class RealtimeBridge {
 			}
 			if (payload.type === 'res' || payload.type === 'event') {
 				this.__forwardToServer(payload);
+				this.webrtcPeer?.broadcast(payload);
 			}
 		});
 
@@ -580,7 +582,7 @@ export class RealtimeBridge {
 		const ready = await this.__waitGatewayReady();
 		if (!ready || !this.gatewayWs || this.gatewayWs.readyState !== 1) {
 			this.__logDebug(`gateway req drop (offline): id=${payload.id} method=${payload.method}`);
-			this.__forwardToServer({
+			const errorRes = {
 				type: 'res',
 				id: payload.id,
 				ok: false,
@@ -588,7 +590,9 @@ export class RealtimeBridge {
 					code: 'GATEWAY_OFFLINE',
 					message: 'Gateway is offline',
 				},
-			});
+			};
+			this.__forwardToServer(errorRes);
+			this.webrtcPeer?.broadcast(errorRes);
 			return;
 		}
 		try {
@@ -601,7 +605,7 @@ export class RealtimeBridge {
 			}));
 		}
 		catch {
-			this.__forwardToServer({
+			const errorRes = {
 				type: 'res',
 				id: payload.id,
 				ok: false,
@@ -609,7 +613,9 @@ export class RealtimeBridge {
 					code: 'GATEWAY_SEND_FAILED',
 					message: 'Failed to send request to gateway',
 				},
-			});
+			};
+			this.__forwardToServer(errorRes);
+			this.webrtcPeer?.broadcast(errorRes);
 		}
 	}
 
@@ -696,6 +702,24 @@ export class RealtimeBridge {
 					catch {}
 					return;
 				}
+				if (payload?.type?.startsWith('rtc:')) {
+					try {
+						if (!this.webrtcPeer) {
+							const { WebRtcPeer } = await import('./webrtc-peer.js');
+							this.webrtcPeer = new WebRtcPeer({
+								onSend: (msg) => this.__forwardToServer(msg),
+								onRequest: (dcPayload) => {
+									void this.__handleGatewayRequestFromServer(dcPayload);
+								},
+								logger: this.logger,
+							});
+						}
+						await this.webrtcPeer.handleSignaling(payload);
+					} catch (err) {
+						this.logger.warn?.(`[coclaw/rtc] signaling error (or werift not found): ${err?.message}`);
+					}
+					return;
+				}
 				if (payload?.type === 'req' || payload?.type === 'rpc.req') {
 					void this.__handleGatewayRequestFromServer({
 						id: payload.id,
@@ -720,6 +744,12 @@ export class RealtimeBridge {
 			this.serverWs = null;
 			this.intentionallyClosed = false;
 			this.__closeGatewayWs();
+			if (this.webrtcPeer) {
+				try { await this.webrtcPeer.closeAll(); }
+				/* c8 ignore next 3 -- 防御性兜底，werift close 异常时不可崩溃 gateway */
+				catch (e) { this.logger.warn?.(`[coclaw/rtc] closeAll failed: ${e?.message}`); }
+				this.webrtcPeer = null;
+			}
 
 			if (event?.code === 4001 || event?.code === 4003) {
 				try {
@@ -778,6 +808,10 @@ export class RealtimeBridge {
 			this.reconnectTimer = null;
 		}
 		this.__closeGatewayWs();
+		if (this.webrtcPeer) {
+			await this.webrtcPeer.closeAll().catch(() => {});
+			this.webrtcPeer = null;
+		}
 		const sock = this.serverWs;
 		if (sock) {
 			this.intentionallyClosed = true;

package/src/webrtc-peer.js

@@ -0,0 +1,192 @@
+import { RTCPeerConnection as WeriftRTCPeerConnection } from 'werift';
+
+/**
+ * 管理多个 WebRTC PeerConnection（以 connId 为粒度）。
+ * Plugin 作为被叫方：收到 UI 的 offer → 回复 answer。
+ */
+export class WebRtcPeer {
+	/**
+	 * @param {object} opts
+	 * @param {function} opts.onSend - 将信令消息交给 RealtimeBridge 发送
+	 * @param {function} [opts.onRequest] - DataChannel 收到 req 消息时的回调 (payload, connId) => void
+	 * @param {object} [opts.logger] - pino 风格 logger
+	 * @param {function} [opts.PeerConnection] - 可替换的构造函数（测试用）
+	 */
+	constructor({ onSend, onRequest, logger, PeerConnection }) {
+		this.__onSend = onSend;
+		this.__onRequest = onRequest;
+		this.logger = logger ?? console;
+		this.__PeerConnection = PeerConnection ?? WeriftRTCPeerConnection;
+		/** @type {Map<string, { pc: object, rpcChannel: object|null }>} */
+		this.__sessions = new Map();
+	}
+
+	/** 处理来自 Server 转发的信令消息 */
+	async handleSignaling(msg) {
+		const connId = msg.fromConnId ?? msg.toConnId;
+		if (msg.type === 'rtc:offer') {
+			await this.__handleOffer(msg);
+		} else if (msg.type === 'rtc:ice') {
+			await this.__handleIce(msg);
+		} else if (msg.type === 'rtc:ready' || msg.type === 'rtc:closed') {
+			this.__logDebug(`${msg.type} from ${connId}`);
+			if (msg.type === 'rtc:closed') {
+				await this.closeByConnId(connId);
+			}
+		}
+	}
+
+	/** 关闭指定 connId 的 PeerConnection */
+	async closeByConnId(connId) {
+		const session = this.__sessions.get(connId);
+		if (!session) return;
+		this.__sessions.delete(connId);
+		await session.pc.close();
+		this.logger.info?.(`[coclaw/rtc] [${connId}] closed`);
+	}
+
+	/** 关闭所有 PeerConnection */
+	async closeAll() {
+		const closing = [...this.__sessions.keys()].map((id) => this.closeByConnId(id));
+		await Promise.all(closing);
+	}
+
+	/** 向所有已打开的 rpcChannel 广播 */
+	broadcast(payload) {
+		const data = 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}`); }
+			}
+		}
+	}
+
+	async __handleOffer(msg) {
+		const connId = msg.fromConnId;
+		this.logger.info?.(`[coclaw/rtc] offer received from ${connId}, creating answer`);
+
+		// 同一 connId 重复 offer → 先关闭旧连接
+		if (this.__sessions.has(connId)) {
+			await this.closeByConnId(connId);
+		}
+
+		// 从 Server 注入的 turnCreds 构建 iceServers
+		// werift 的 urls 必须是单个 string，每个 URL 独立一个对象
+		const iceServers = [];
+		if (msg.turnCreds) {
+			const { urls, username, credential } = msg.turnCreds;
+			for (const url of urls) {
+				const server = { urls: url };
+				if (url.startsWith('turn:')) {
+					server.username = username;
+					server.credential = credential;
+				}
+				iceServers.push(server);
+			}
+		}
+
+		const pc = new this.__PeerConnection({ iceServers });
+		const session = { pc, rpcChannel: null };
+		this.__sessions.set(connId, session);
+
+		// ICE candidate → 发给 UI
+		pc.onicecandidate = ({ candidate }) => {
+			if (!candidate) return;
+			this.__onSend({
+				type: 'rtc:ice',
+				toConnId: connId,
+				payload: {
+					candidate: candidate.candidate,
+					sdpMid: candidate.sdpMid,
+					sdpMLineIndex: candidate.sdpMLineIndex,
+				},
+			});
+		};
+
+		// 连接状态变更
+		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}`);
+				}
+			} else if (state === 'failed' || state === 'closed') {
+				this.__sessions.delete(connId);
+			}
+		};
+
+		// 监听 UI 创建的 DataChannel
+		pc.ondatachannel = ({ channel }) => {
+			this.logger.info?.(`[coclaw/rtc] [${connId}] DataChannel "${channel.label}" received`);
+			if (channel.label === 'rpc') {
+				session.rpcChannel = channel;
+				this.__setupDataChannel(connId, channel);
+			}
+		};
+
+		// offer → answer
+		try {
+			await pc.setRemoteDescription({ type: 'offer', sdp: msg.payload.sdp });
+			const answer = await pc.createAnswer();
+			await pc.setLocalDescription(answer);
+
+			this.__onSend({
+				type: 'rtc:answer',
+				toConnId: connId,
+				payload: { sdp: answer.sdp },
+			});
+			this.logger.info?.(`[coclaw/rtc] answer sent to ${connId}`);
+		} catch (err) {
+			// SDP 协商失败 → 清理已入 Map 的 session，避免泄漏
+			this.__sessions.delete(connId);
+			await pc.close().catch(() => {});
+			throw err;
+		}
+	}
+
+	async __handleIce(msg) {
+		const connId = msg.fromConnId;
+		const session = this.__sessions.get(connId);
+		if (!session) {
+			this.__logDebug(`ICE candidate from ${connId} but no session`);
+			return;
+		}
+		await session.pc.addIceCandidate(msg.payload);
+		this.__logDebug(`[${connId}] ICE candidate added`);
+	}
+
+	__setupDataChannel(connId, dc) {
+		dc.onopen = () => {
+			this.logger.info?.(`[coclaw/rtc] [${connId}] DataChannel "${dc.label}" opened`);
+		};
+		dc.onclose = () => {
+			this.logger.info?.(`[coclaw/rtc] [${connId}] DataChannel "${dc.label}" closed`);
+			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') {
+					this.__onRequest?.(payload, connId);
+				} else {
+					this.__logDebug(`[${connId}] unknown DC message type: ${payload.type}`);
+				}
+			} catch (err) {
+				this.logger.warn?.(`[coclaw/rtc] [${connId}] DC message parse failed: ${err.message}`);
+			}
+		};
+	}
+
+	__logDebug(message) {
+		if (typeof this.logger?.debug === 'function') {
+			this.logger.debug(`[coclaw/rtc] ${message}`);
+		}
+	}
+}