@coclaw/openclaw-coclaw 0.14.0 → 0.14.1

package/index.js

@@ -14,10 +14,77 @@ import { AutoUpgradeScheduler } from './src/auto-upgrade/updater.js';
 import { getPackageInfo } from './src/auto-upgrade/updater-check.js';
 import { createFileHandler } from './src/file-manager/handler.js';
 import { abortAgentRun } from './src/agent-abort.js';
+import { remoteLog } from './src/remote-log.js';
 
 import { getPluginVersion, __resetPluginVersion } from './src/plugin-version.js';
 export { getPluginVersion, __resetPluginVersion };
 
+// 侧门注册表观测：patch OpenClaw embeddedRunState.activeRuns 的 set/delete，
+// 用于跟踪 sessionId 何时注册/注销（agent 取消流程实际读取的就是这张表）。
+// OpenClaw 侧门形状变化时（缺失 / 抛异常），通过 remoteLog 上报为升级契约变更的早期信号。
+const PATCH_LABELS = [
+	['embedded.activeRuns', () => globalThis[Symbol.for('openclaw.embeddedRunState')]?.activeRuns],
+];
+
+function installAbortRegistryDiag(logger) {
+	const installed = [];
+	const missing = [];
+	try {
+		for (const [label, resolve] of PATCH_LABELS) {
+			if (patchMapLogging(resolve(), label, logger)) installed.push(label);
+			else missing.push(label);
+		}
+	}
+	catch (err) {
+		logger?.warn?.(`[coclaw.diag] installAbortRegistryDiag failed: ${String(err?.message ?? err)}`);
+		remoteLog(`abort.patch-failed reason=${String(err?.message ?? err)}`);
+		return;
+	}
+	remoteLog(`abort.patch installed=${installed.join(',') || 'none'} missing=${missing.join(',') || 'none'}`);
+}
+
+function patchMapLogging(map, label, logger) {
+	if (!map || typeof map.set !== 'function' || typeof map.delete !== 'function') return false;
+	if (map.__coclawDiagPatched) return true;
+	// 先打 idempotent 标记：若 map 是 frozen/sealed/Proxy 致 defineProperty 抛，
+	// 立即返回 false 让上层归入 missing；不留下半装好的 wrapper 状态
+	try {
+		Object.defineProperty(map, '__coclawDiagPatched', { value: true, enumerable: false });
+	}
+	catch (err) {
+		logger?.warn?.(`[coclaw.diag] cannot mark ${label} patched: ${String(err?.message ?? err)}`);
+		return false;
+	}
+	const origSet = map.set.bind(map);
+	const origDel = map.delete.bind(map);
+	// log 行包 try/catch 兜底：上游若把 Map 换成有 throwing getter（如 Proxy）的对象，
+	// 不能让本插件的诊断 log 把 OpenClaw 内部 set/delete 流程带崩
+	const safeLog = (msg) => {
+		try { logger?.info?.(msg); } catch { /* swallow — diag log 不得影响主流程 */ }
+	};
+	const safeSize = () => {
+		try { return map.size; } catch { return '?'; }
+	};
+	map.set = (key, value) => {
+		const res = origSet(key, value);
+		safeLog(`[coclaw.diag] ${label}.set key=${stringifyKey(key)} size=${safeSize()}`);
+		return res;
+	};
+	map.delete = (key) => {
+		let had;
+		try { had = map.has(key); } catch { had = '?'; }
+		const res = origDel(key);
+		safeLog(`[coclaw.diag] ${label}.delete key=${stringifyKey(key)} had=${had} size=${safeSize()}`);
+		return res;
+	};
+	return true;
+}
+
+function stringifyKey(k) {
+	if (typeof k === 'string') return k;
+	try { return JSON.stringify(k); } catch { return String(k); }
+}
+
 /* c8 ignore start */
 function parseCommandArgs(args) {
 	const tokens = (args ?? '').split(/\s+/).filter(Boolean);
@@ -65,6 +132,7 @@ const plugin = {
 	register(api) {
 		setRuntime(api.runtime);
 		const logger = api?.logger ?? console;
+		installAbortRegistryDiag(logger);
 		const manager = createSessionManager({ logger });
 		const topicManager = new TopicManager({ logger });
 		const chatHistoryManager = new ChatHistoryManager({ logger });
@@ -460,6 +528,7 @@ const plugin = {
 
 		// 取消正在执行的 embedded agent run（通过 OpenClaw 全局 symbol 侧门）
 		// 侧门不存在 / sessionId 未注册 / handle.abort 抛异常时返回 { ok:false, reason } —— UI 静默降级
+		// UI 可能在 OpenClaw 注册 sessionId 前点 STOP（注册空窗期），此时返回 not-found；UI 会按 500ms 间隔重试。
 		api.registerGatewayMethod('coclaw.agent.abort', ({ params, respond }) => {
 			try {
 				const sessionId = params?.sessionId;
@@ -468,9 +537,18 @@ const plugin = {
 					respondInvalid(respond, 'sessionId is required');
 					return;
 				}
-				logger.info?.(`[coclaw.agent.abort] request sessionId=${sessionId}`);
-				const result = abortAgentRun(sessionId, logger);
-				logger.info?.(`[coclaw.agent.abort] result sessionId=${sessionId} ok=${result.ok}${result.reason ? ` reason=${result.reason}` : ''}${result.error ? ` error=${result.error}` : ''}`);
+				const result = abortAgentRun(sessionId);
+				// not-found 是 UI 重试期常态（注册空窗），不打日志避免噪音；其余分支保留 info
+				if (result.reason !== 'not-found') {
+					logger.info?.(`[coclaw.agent.abort] result sessionId=${sessionId} ok=${result.ok}${result.reason ? ` reason=${result.reason}` : ''}${result.error ? ` error=${result.error}` : ''}`);
+				}
+				if (result.ok) {
+					remoteLog(`abort.success sid=${sessionId}`);
+				}
+				else if (result.reason === 'not-supported') {
+					// 侧门缺失或 handle shape 变化：OpenClaw 升级契约变更的早期信号
+					remoteLog(`abort.not-supported sid=${sessionId}`);
+				}
 				respond(true, result);
 			}
 			catch (err) {

package/package.json

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

package/src/agent-abort.js

@@ -9,91 +9,20 @@
  */
 
 const EMBEDDED_RUN_STATE_KEY = Symbol.for('openclaw.embeddedRunState');
-const REPLY_RUN_STATE_KEY = Symbol.for('openclaw.replyRunRegistry');
-
-/* c8 ignore start */ // 临时诊断代码，定位完问题会删除
-/**
- * 诊断用：从 reply-run-registry 全局单例中解析 sessionId → sessionKey 映射及概览
- * @param {string} sessionId
- * @returns {string}
- */
-function describeReplyRunRegistry(sessionId) {
-	const state = globalThis[REPLY_RUN_STATE_KEY];
-	if (!state) return 'reply.state=absent';
-	const parts = [];
-	const runs = state.activeRunsByKey;
-	if (runs && typeof runs.size === 'number') {
-		parts.push(`reply.activeRunsByKey.size=${runs.size}`);
-		try {
-			const ks = [];
-			if (typeof runs.keys === 'function') {
-				for (const k of runs.keys()) {
-					ks.push(k);
-					if (ks.length >= 10) break;
-				}
-			}
-			parts.push(`reply.keys=${JSON.stringify(ks)}`);
-		}
-		catch (e) {
-			parts.push(`reply.keysErr=${String(e?.message ?? e)}`);
-		}
-	}
-	else {
-		parts.push('reply.activeRunsByKey=absent');
-	}
-	const byId = state.activeKeysBySessionId;
-	if (byId && typeof byId.get === 'function') {
-		try {
-			const mapped = byId.get(sessionId);
-			parts.push(`reply.keyForSid=${mapped === undefined ? 'null' : JSON.stringify(mapped)}`);
-		}
-		catch (e) {
-			parts.push(`reply.keyForSidErr=${String(e?.message ?? e)}`);
-		}
-	}
-	else {
-		parts.push('reply.activeKeysBySessionId=absent');
-	}
-	return parts.join(' ');
-}
-/* c8 ignore stop */
 
 /**
  * 尝试取消 sessionId 对应的 embedded agent run
  * @param {string} sessionId
- * @param {{ info?: Function }} [logger] - 可选 logger；传入时在 not-found 分支 dump activeRuns 诊断信息
  * @returns {{ ok: true } | { ok: false, reason: 'not-supported' | 'not-found' | 'abort-threw', error?: string }}
  */
-export function abortAgentRun(sessionId, logger) {
+export function abortAgentRun(sessionId) {
 	const state = globalThis[EMBEDDED_RUN_STATE_KEY];
 	if (!state || !state.activeRuns || typeof state.activeRuns.get !== 'function') {
 		return { ok: false, reason: 'not-supported' };
 	}
 	try {
 		const handle = state.activeRuns.get(sessionId);
-		if (!handle) {
-			/* c8 ignore start */ // 临时诊断代码，定位完问题会删除
-			if (logger?.info) {
-				let diag = `sessionId=${sessionId} embedded.size=${state.activeRuns.size ?? '?'}`;
-				try {
-					const ks = [];
-					if (typeof state.activeRuns.keys === 'function') {
-						for (const k of state.activeRuns.keys()) {
-							ks.push(k);
-							if (ks.length >= 10) break;
-						}
-					}
-					diag += ` embedded.keys=${JSON.stringify(ks)}`;
-				}
-				catch (e) {
-					diag += ` embedded.keysErr=${String(e?.message ?? e)}`;
-				}
-				diag += ` ${describeReplyRunRegistry(sessionId)}`;
-				logger.info(`[coclaw.agent.abort] not-found diag ${diag}`);
-			}
-			/* c8 ignore stop */
-			return { ok: false, reason: 'not-found' };
-		}
+		if (!handle) return { ok: false, reason: 'not-found' };
 		// shape 守卫：abort 字段应为函数；若不是说明 OpenClaw handle 契约变化（归入 not-supported 让 UI 提示升级）
 		if (typeof handle.abort !== 'function') return { ok: false, reason: 'not-supported' };
 		handle.abort();

package/src/platform-info.js

@@ -0,0 +1,60 @@
+import os from 'node:os';
+import process from 'node:process';
+
+// 模块级缓存：所有字段在进程生命周期内不变，缓存后 ws 重连补发零开销。
+let __cachedLine = null;
+
+/**
+ * 以 "key=value" 形式收集运行环境信息，用于诊断平台相关二进制依赖（如 pion-ipc）问题。
+ *
+ * 尽力而为：每项独立 try/catch，单项失败不影响其它项；无法获取时该字段省略。
+ * 结果在进程生命周期内缓存，重复调用零额外开销。
+ *
+ * 字段：platform / arch / node / osrel / cpu / cores / mem
+ *
+ * @returns {string} - 形如 `platform=linux arch=x64 node=v20.11.0 osrel=6.6.87 cpu="Intel Xeon" cores=8 mem=16.0GB`
+ */
+export function getPlatformInfoLine() {
+	if (__cachedLine !== null) return __cachedLine;
+	const parts = [];
+
+	tryPush(parts, 'platform', () => process.platform);
+	tryPush(parts, 'arch', () => process.arch);
+	tryPush(parts, 'node', () => process.version);
+	tryPush(parts, 'osrel', () => os.release());
+	tryPush(parts, 'cpu', () => {
+		const model = os.cpus()?.[0]?.model;
+		if (!model) return undefined;
+		// 外层包双引号以保留含空格的 model；内部双引号 / C0 控制字符 / DEL 替换为空格后折叠空白
+		const cleaned = String(model).replace(/["\x00-\x1F\x7F]/g, ' ').replace(/\s+/g, ' ').trim();
+		if (!cleaned) return undefined;
+		return `"${cleaned}"`;
+	});
+	tryPush(parts, 'cores', () => {
+		const n = os.cpus()?.length;
+		return n > 0 ? n : undefined;
+	});
+	tryPush(parts, 'mem', () => {
+		const bytes = os.totalmem();
+		if (!bytes || !Number.isFinite(bytes)) return undefined;
+		return `${(bytes / 1024 ** 3).toFixed(1)}GB`;
+	});
+
+	__cachedLine = parts.join(' ');
+	return __cachedLine;
+}
+
+/** 测试用：清缓存以便覆盖不同 monkey-patch 场景 */
+export function __resetPlatformInfoCache() {
+	__cachedLine = null;
+}
+
+function tryPush(parts, key, resolver) {
+	try {
+		const value = resolver();
+		if (value === undefined || value === null || value === '') return;
+		parts.push(`${key}=${value}`);
+	} catch {
+		// 单项失败静默跳过，不影响其它字段
+	}
+}

package/src/realtime-bridge.js

@@ -14,6 +14,7 @@ import {
 import { getRuntime } from './runtime.js';
 import { setSender as setRemoteLogSender, remoteLog } from './remote-log.js';
 import { getPluginVersion } from './plugin-version.js';
+import { getPlatformInfoLine } from './platform-info.js';
 
 const DEFAULT_GATEWAY_WS_URL = `ws://127.0.0.1:${process.env.OPENCLAW_GATEWAY_PORT || '18789'}`;
 const RECONNECT_MS = 10_000;
@@ -811,9 +812,14 @@ export class RealtimeBridge {
 			this.__clearConnectTimer();
 			this.logger.info?.(`[coclaw] realtime bridge connected: ${maskedTarget}`);
 			remoteLog('ws.connected peer=server');
+			// 顺序很重要：先注入 sender 再 remoteLog 环境信息——这样环境信息能随当前 sock
+			// 立即 flush；同时 sender 内部仅做 sock.send（不回调 remoteLog），无循环依赖。
 			setRemoteLogSender((msg) => {
 				if (sock.readyState === 1) sock.send(JSON.stringify(msg));
 			});
+			// ws 重连后补发环境信息：server 重启重连后能立即看到当前 claw 的运行环境与 webrtc 选型。
+			// __buildEnvLine 内部所有读取均为缓存值，无 native syscall。
+			remoteLog(this.__buildEnvLine());
 			this.__startServerHeartbeat(sock);
 			this.__ensureGatewayConnection();
 		});
@@ -967,12 +973,28 @@ export class RealtimeBridge {
 		this.__ndcPreloadResult = preloadResult;
 		this.__ndcCleanup = preloadResult.cleanup;
 		const implLabel = preloadResult.impl === 'ndc' ? 'node-datachannel(ndc)' : preloadResult.impl;
+		this.__implLabel = implLabel; // 缓存供 ws.open 时发送
+		// 启动信息只本地 log；远程发送统一由 ws.open 触发，避免重复
 		this.logger.info?.(`[coclaw] WebRTC impl: ${implLabel}`);
-		remoteLog(`bridge.webrtc-impl impl=${implLabel}`);
-		remoteLog(`bridge.started version=${this.__pluginVersion}`);
+		this.logger.info?.(`[coclaw] ${this.__buildEnvLine()}`);
+		remoteLog('bridge.started');
 		await this.__connectIfNeeded();
 	}
 
+	/**
+	 * 组装一条覆盖最基础环境信息的 log 行：
+	 *   coclaw.env impl=<...> plugin=<ver> openclaw=<ver> platform=<...> ... mem=<...>
+	 *
+	 * 字段值均为已缓存的轻量同步读取，无 native syscall；不调用 remoteLog，无循环依赖。
+	 */
+	__buildEnvLine() {
+		const rt = getRuntime();
+		const openclawVer = (rt?.version && rt.version !== 'unknown') ? rt.version : 'unknown';
+		const impl = this.__implLabel ?? 'pending';
+		const plugin = this.__pluginVersion ?? 'unknown';
+		return `coclaw.env impl=${impl} plugin=${plugin} openclaw=${openclawVer} ${getPlatformInfoLine()}`;
+	}
+
 	async refresh() {
 		await this.stop();
 		await this.start({