@coclaw/openclaw-coclaw 0.17.4 → 0.17.6

package/package.json

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

package/src/auto-upgrade/updater.js

@@ -14,6 +14,15 @@ const INITIAL_DELAY_MS = 60 * 60 * 1000; // 60 分钟
 const CHECK_INTERVAL_MS = 60 * 60 * 1000; // 1 小时
 const CHANNEL_ID = 'coclaw';
 const LOCK_FILENAME = 'upgrade.lock';
+// 锁年龄兜底：worker 最坏耗时约 36 分钟，TTL 给到约 3 倍余量。
+// 超龄一律视为过期清理，兜住 worker 被强杀未清锁 / PID 被 OS 复用给长命进程的场景，
+// 避免自动升级被永久卡住。
+// 刻意取 110 分钟而非 120 分钟：巡检间隔 60min，锁写入与巡检有秒级抖动；
+// 若 TTL 正好等于巡检间隔的整数倍，锁年龄会在第 N 次巡检时刚好 "未过期"，
+// 要等到第 N+1 次巡检才清，白白多浪费一轮。110min 保证第 2 次巡检即过期。
+// 代价是 worker 真卡超 110 分钟会多起一个并行 worker，此概率在当前超时矩阵下极低，
+// 且底层升级命令失败会走回滚，不会破坏插件。
+const LOCK_TTL_MS = 110 * 60 * 1000; // 110 分钟
 
 // ── upgrade.lock：保证同时最多一个 worker 进程 ──
 
@@ -21,10 +30,34 @@ export function getLockPath() {
 	return nodePath.join(resolveStateDir(), CHANNEL_ID, LOCK_FILENAME);
 }
 
+/**
+ * 清理过期锁文件。
+ *
+ * 成功才打 "Stale lock removed" 的 info；失败意味着系统性异常（权限/只读 FS/
+ * 路径被替换为目录等），打 warn 并上报 server，避免运维无感——这类失败若与
+ * writeUpgradeLock 同源故障叠加，会让锁陷入"每轮都判过期但写不进新 pid"的循环。
+ * { force: true } 对文件不存在本身不会抛，所以这里 catch 到的一定是真故障。
+ * 函数本身不抛——调用方无需额外 catch。
+ * @param {string} lockPath
+ * @param {'missing-pid'|'ttl-exceeded'|'pid-dead'} reason - 清理原因 token，
+ *   同时用作 remoteLog 的 key=value 字段
+ * @param {object} [logger]
+ */
+async function removeStaleLock(lockPath, reason, logger) {
+	try {
+		await fs.rm(lockPath, { force: true });
+		logger?.info?.(`[auto-upgrade] Stale lock removed (${reason})`);
+	}
+	catch (err) {
+		logger?.warn?.(`[auto-upgrade] Stale lock removal failed (${reason}): ${err?.message}`);
+		remoteLog(`upgrade.lock-cleanup-failed reason=${reason} msg=${err?.message}`);
+	}
+}
+
 /**
  * 检查升级锁是否被持有（worker 进程是否存活）
  *
- * 若锁文件存在但 PID 已死（过期锁），顺手清理残留文件。
+ * 若锁文件存在但判定为过期（PID 已死 / JSON 无效 / 超龄），顺手清理残留文件。
  * @param {object} [opts]
  * @param {object} [opts.logger]
  * @returns {Promise<boolean>}
@@ -42,8 +75,14 @@ export async function isUpgradeLocked(opts) {
 	try {
 		const lock = JSON.parse(raw);
 		if (!lock.pid) {
-			logger?.info?.('[auto-upgrade] Stale lock removed (missing pid)');
-			await fs.rm(lockPath, { force: true }).catch(() => {});
+			await removeStaleLock(lockPath, 'missing-pid', logger);
+			return false;
+		}
+		// 超龄兜底：PID 复用误判、worker 被强杀未清锁等场景下一律视为过期。
+		// ts 不可解析也当过期（writeUpgradeLock 必写 ISO 时间戳，缺字段即异常状态）。
+		const lockTs = Date.parse(lock.ts);
+		if (!Number.isFinite(lockTs) || Date.now() - lockTs > LOCK_TTL_MS) {
+			await removeStaleLock(lockPath, 'ttl-exceeded', logger);
 			return false;
 		}
 		// signal 0 不发信号，仅检查进程存活性；进程不存在时抛异常
@@ -52,8 +91,7 @@ export async function isUpgradeLocked(opts) {
 	}
 	catch {
 		// JSON 无效 / PID 已死 → 清理过期锁
-		logger?.info?.('[auto-upgrade] Stale lock removed (worker pid no longer alive)');
-		await fs.rm(lockPath, { force: true }).catch(() => {});
+		await removeStaleLock(lockPath, 'pid-dead', logger);
 		return false;
 	}
 }

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

@@ -2,8 +2,12 @@
  * worker-verify.js — 升级后验证
  *
  * 策略：触发 gateway restart → 轮询 coclaw.upgradeHealth RPC 直到返回版本
- * 严格等于 toVersion。单次调用失败（gateway 未就绪 / plugin 未注册 / JSON 非法 /
- * 版本不对）一律按"稍后重试"处理，在总超时窗口内持续尝试。
+ * ≥ toVersion（等于或更新）。单次调用失败（gateway 未就绪 / plugin 未注册 /
+ * JSON 非法 / 版本不够新）一律按"稍后重试"处理，在总超时窗口内持续尝试。
+ *
+ * 允许 > toVersion 的原因：scheduler 观察到 latest=x 并发起升级后，到实际
+ * 执行 `plugins update` 之间 npm dist-tag 可能已指向 x+1；严格等 x 会把
+ * 这种"升级到了更新版本"误判为失败并回滚。
  *
  * 磁盘 package.json 的版本仅作为诊断写入本地日志，不参与判定——openclaw 侧
  * `plugins.installs[id].installPath` 可能在 id-migration 等极端场景发生漂移，
@@ -16,6 +20,23 @@ import { execFile as nodeExecFile } from 'node:child_process';
 import { readFile } from 'node:fs/promises';
 import nodePath from 'node:path';
 
+// 与 updater-check.js 同逻辑，worker 运行在独立子进程，不跨进程复用 gateway 模块
+function isNewerVersion(a, b) {
+	const parse = (v) => v.replace(/-.*$/, '').split('.').map(Number);
+	const pa = parse(a);
+	const pb = parse(b);
+	for (let i = 0; i < 3; i++) {
+		/* c8 ignore next 2 -- ?? fallback：正常 semver 不会有缺失段 */
+		if ((pa[i] ?? 0) > (pb[i] ?? 0)) return true;
+		if ((pa[i] ?? 0) < (pb[i] ?? 0)) return false;
+	}
+	// x.y.z 相同时：release > pre-release（semver 规则）
+	const aHasPre = a.includes('-');
+	const bHasPre = b.includes('-');
+	if (bHasPre && !aHasPre) return true;
+	return false;
+}
+
 const CMD_TIMEOUT_MS = 30_000;
 const HEALTH_POLL_INTERVAL_MS = 3_000;
 // 本机 openclaw 冷启动可能需访问外部资源（AWS 诊断、ollama 探测等）
@@ -113,7 +134,7 @@ async function callUpgradeHealthOnce(opts) {
 }
 
 /**
- * 轮询 upgradeHealth 直到版本严格等于 toVersion，或总超时
+ * 轮询 upgradeHealth 直到版本 ≥ toVersion，或总超时
  * @param {string} toVersion
  * @param {object} [opts]
  * @param {Function} [opts.execFileFn]
@@ -137,7 +158,8 @@ export async function pollUpgradeHealth(toVersion, opts) {
 		attempts += 1;
 		const result = await callUpgradeHealthOnce(opts);
 		if (result.ok) {
-			if (result.version === toVersion) {
+			// 等于或更新均视为成功，覆盖"升级窗口期 dist-tag 前移"的情形
+			if (result.version === toVersion || isNewerVersion(result.version, toVersion)) {
 				return {
 					ok: true,
 					version: result.version,
@@ -146,7 +168,7 @@ export async function pollUpgradeHealth(toVersion, opts) {
 				};
 			}
 			lastVersion = result.version;
-			lastReason = `version-mismatch got=${result.version} want=${toVersion}`;
+			lastReason = `version-too-old got=${result.version} want>=${toVersion}`;
 		}
 		else {
 			lastReason = result.reason;

package/src/auto-upgrade/worker.js

@@ -22,6 +22,10 @@ import { getCurrentNpmRegistry, pickFallbackRegistry } from './registry-fallback
 const SEMVER_RE = /^\d+\.\d+\.\d+(-[\w.-]+)?$/;
 // 单次 plugins update 上限：包含 npm install 大型 native deps，慢网络 + 弱机器需较长时间
 const UPDATE_TIMEOUT_MS = 10 * 60 * 1000;
+// 回滚兜底重装旧版本走的是同一条 npm 下载链路，且触发前置本身是"备份已丢"的异常态，
+// 此时尽量兜住比快速失败更重要，与 UPDATE_TIMEOUT_MS 对齐
+const FALLBACK_INSTALL_TIMEOUT_MS = 10 * 60 * 1000;
+const FALLBACK_UNINSTALL_TIMEOUT_MS = 60 * 1000;
 
 /**
  * 执行 openclaw plugins update
@@ -73,7 +77,7 @@ async function fallbackInstallOldVersion(pkgName, version, pluginId, opts) {
 	}
 	/* c8 ignore next -- ?./?? fallback */
 	const doExecFile = opts?.execFileFn ?? nodeExecFile;
-	const run = (args, timeout = 120_000) => new Promise((resolve, reject) => {
+	const run = (args, timeout) => new Promise((resolve, reject) => {
 		doExecFile('openclaw', args, { timeout, shell: process.platform === 'win32' }, (err) => {
 			if (err) reject(err);
 			else resolve();
@@ -82,13 +86,13 @@ async function fallbackInstallOldVersion(pkgName, version, pluginId, opts) {
 
 	// 先卸载：install 不支持覆盖已安装插件
 	try {
-		await run(['plugins', 'uninstall', pluginId], 60_000);
+		await run(['plugins', 'uninstall', pluginId], FALLBACK_UNINSTALL_TIMEOUT_MS);
 	} catch {
 		// uninstall 失败不阻断，继续尝试 install
 	}
 
 	try {
-		await run(['plugins', 'install', `${pkgName}@${version}`]);
+		await run(['plugins', 'install', `${pkgName}@${version}`], FALLBACK_INSTALL_TIMEOUT_MS);
 	} catch (err) {
 		throw new Error(`fallback install failed: ${err.message}`);
 	}
@@ -171,8 +175,11 @@ export async function runUpgrade({ pluginDir, fromVersion, toVersion, pluginId,
 		catch (e) {
 			log(`[upgrade-worker] Backup cleanup failed (non-fatal): ${e.message}`);
 		}
-		await updateLastUpgrade({ from: fromVersion, to: toVersion, result: 'ok' });
-		await appendLog({ from: fromVersion, to: toVersion, result: 'ok' });
+		// 记录真实装上的版本而非目标版本——dist-tag 前移窗口下两者可能不同。
+		// 不加 fallback：若 result.ok 时 version 缺失，说明上游契约被破坏，
+		// 宁可让状态里直接暴露 undefined 便于排障，也不要用 toVersion 糊过去
+		await updateLastUpgrade({ from: fromVersion, to: result.version, result: 'ok' });
+		await appendLog({ from: fromVersion, to: result.version, result: 'ok' });
 		log('[upgrade-worker] Upgrade complete');
 	} else {
 		// 4b. 失败，回滚

package/src/realtime-bridge.js

@@ -1087,7 +1087,7 @@ export class RealtimeBridge {
 		// 1. 尝试 pion（最高优先级）
 		const preloadPionFn = this.__preloadPion
 			?? (await import('./webrtc/pion-preloader.js')).preloadPion;
-		const pionResult = await preloadPionFn().catch((err) => {
+		const pionResult = await preloadPionFn({ logger: this.logger }).catch((err) => {
 			this.logger.warn?.(`[coclaw] pion preload unexpected failure: ${err?.message}`);
 			return null;
 		});

package/src/webrtc/pion-preloader.js

@@ -1,6 +1,9 @@
 import { remoteLog as defaultRemoteLog } from '../remote-log.js';
 
-const DEFAULT_START_TIMEOUT_MS = 10_000;
+const DEFAULT_IPC_REQUEST_TIMEOUT_MS = 20_000;
+
+// 匹配 pion-node 内部视为严重的 log：IPC 请求超时、以及 Go 侧迟到的响应（主请求已 reject，响应变孤儿）
+const SEVERE_LOG_PATTERN = /request timeout|orphan response/;
 
 /**
  * 预加载 Pion WebRTC 实现：启动 pion-ipc Go 进程，返回绑定了 ipc 的 PeerConnection。
@@ -13,13 +16,15 @@ const DEFAULT_START_TIMEOUT_MS = 10_000;
  * @param {object} [deps] - 可注入依赖（测试用）
  * @param {Function} [deps.dynamicImport] - (specifier) => import(specifier)
  * @param {Function} [deps.remoteLog] - (text) => void
- * @param {number} [deps.startTimeout] - 启动超时（ms），默认 10s
+ * @param {object} [deps.logger] - plugin 本地 pino-style logger（.info/.warn/.error），用于本地调试可见性
+ * @param {number} [deps.ipcRequestTimeout] - 每次 IPC 请求的超时（ms，也用于启动 ping），默认 20s
  * @returns {Promise<{ PeerConnection: Function, cleanup: Function, impl: string, ipc: object }|null>}
  */
 export async function preloadPion(deps = {}) {
 	const log = deps.remoteLog ?? defaultRemoteLog;
+	const localLogger = deps.logger ?? null;
 	const dynamicImport = deps.dynamicImport ?? ((spec) => import(spec));
-	const startTimeout = deps.startTimeout ?? DEFAULT_START_TIMEOUT_MS;
+	const ipcRequestTimeout = deps.ipcRequestTimeout ?? DEFAULT_IPC_REQUEST_TIMEOUT_MS;
 
 	log('pion.preload');
 
@@ -42,9 +47,18 @@ export async function preloadPion(deps = {}) {
 		}
 
 		// 启动 IPC 进程（内部会 ping 验证就绪，binary 由 pion-node 自动解析）
+		// logger 回调双打：始终走 remoteLog；同时送本地 logger，严重事件（IPC 超时、orphan 响应）
+		// 升级到 error 级别，便于本地调试时一眼可见；其他运维类消息走 info。
 		ipc = new PionIpc({
-			logger: (msg) => log(`pion.ipc ${msg}`),
-			timeout: startTimeout,
+			logger: (msg) => {
+				log(`pion.ipc ${msg}`);
+				if (SEVERE_LOG_PATTERN.test(msg)) {
+					localLogger?.error?.(`[pion-ipc] ${msg}`);
+				} else {
+					localLogger?.info?.(`[pion-ipc] ${msg}`);
+				}
+			},
+			timeout: ipcRequestTimeout,
 			autoRestart: true,
 		});
 

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

@@ -83,11 +83,11 @@ export class RpcSendQueue {
 		if (this.queueBytes >= MAX_QUEUE_BYTES) {
 			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}`);
+			// 仅状态翻转点打 log（warn + remoteLog 各一次）；overflow 持续期间所有 drop 静默累加，
+			// 避免 UI 离线 + ICE 失败导致 DC 永远不 drain 时的日志刷屏
 			if (!this.queueOverflowActive) {
 				this.queueOverflowActive = true;
+				this.logger.warn?.(`[rpc-queue${this.__tagSuffix()}] overflow-start queueBytes=${this.queueBytes}`);
 				remoteLog(`rpc-queue.overflow-start${this.__tagSuffix()} queueBytes=${this.queueBytes}`);
 			}
 			return false;
@@ -173,9 +173,10 @@ export class RpcSendQueue {
 			}
 			this.queue.shift();
 			this.queueBytes -= chunk.length;
-			// 满 → 未满 状态转换
+			// 满 → 未满 状态转换：打一条带累计数的 log，与 overflow-start 对称
 			if (this.queueOverflowActive && this.queueBytes < MAX_QUEUE_BYTES) {
 				this.queueOverflowActive = false;
+				this.logger.info?.(`[rpc-queue${this.__tagSuffix()}] overflow-end dropped=${this.droppedCount} droppedBytes=${this.droppedBytes}`);
 				remoteLog(`rpc-queue.overflow-end${this.__tagSuffix()} dropped=${this.droppedCount} droppedBytes=${this.droppedBytes}`);
 			}
 		}