fengming 0.3.3 → 0.3.5

package/dist/monitor-DwccYPfp.js

@@ -0,0 +1,1024 @@
+import { i as __toESM } from "./chunk-2rV9d50f.js";
+import { n as resolvePreferredFengMingTmpDir } from "./tmp-fengming-dir-0p6iJKE-.js";
+import { t as createTypingCallbacks } from "./typing-DPZlHKCS.js";
+import "./channel-runtime-COf2zvd3.js";
+import "./infra-runtime-BFrpRc_V.js";
+import { i as resolveDirectDmAuthorizationOutcome, o as resolveSenderCommandAuthorizationWithRuntime } from "./command-auth-Dz_pdczs.js";
+import { A as sendTyping, C as pauseSession, D as getUpdates, E as getConfig, G as logger, I as deriveRawAccountId, K as resolveStateDir, M as redactToken, S as getRemainingPauseMs, W as readFrameworkAllowFromList, _ as TypingStatus, a as applyWeixinMessageSendingHook, b as decryptAesEcb, d as isMediaItem, g as MessageItemType, h as downloadRemoteImageToTemp, i as StreamingMarkdownFilter, j as redactBody, m as weixinMessageToMsgContext, n as sendMessageItemWeixin, o as emitWeixinMessageSent, p as setContextToken, r as sendMessageWeixin, t as sendWeixinMediaFile, u as getContextTokenFromMsgContext, v as getMimeFromFilename, y as buildCdnDownloadUrl, z as loadWeixinAccount } from "./send-media-cOciBxcg.js";
+import fs from "node:fs";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+//#region extensions/weixin/src/api/config-cache.ts
+const CONFIG_CACHE_TTL_MS = 1440 * 60 * 1e3;
+const CONFIG_CACHE_INITIAL_RETRY_MS = 2e3;
+const CONFIG_CACHE_MAX_RETRY_MS = 3600 * 1e3;
+/**
+* Per-user getConfig cache with periodic random refresh (within 24h) and
+* exponential-backoff retry (up to 1h) on failure.
+*/
+var WeixinConfigManager = class {
+	constructor(apiOpts, log) {
+		this.apiOpts = apiOpts;
+		this.log = log;
+		this.cache = /* @__PURE__ */ new Map();
+	}
+	async getForUser(userId, contextToken) {
+		const now = Date.now();
+		const entry = this.cache.get(userId);
+		if (!entry || now >= entry.nextFetchAt) {
+			let fetchOk = false;
+			try {
+				const resp = await getConfig({
+					baseUrl: this.apiOpts.baseUrl,
+					token: this.apiOpts.token,
+					ilinkUserId: userId,
+					contextToken
+				});
+				if (resp.ret === 0) {
+					this.cache.set(userId, {
+						config: { typingTicket: resp.typing_ticket ?? "" },
+						everSucceeded: true,
+						nextFetchAt: now + Math.random() * CONFIG_CACHE_TTL_MS,
+						retryDelayMs: CONFIG_CACHE_INITIAL_RETRY_MS
+					});
+					this.log(`[weixin] config ${entry?.everSucceeded ? "refreshed" : "cached"} for ${userId}`);
+					fetchOk = true;
+				}
+			} catch (err) {
+				this.log(`[weixin] getConfig failed for ${userId} (ignored): ${String(err)}`);
+			}
+			if (!fetchOk) {
+				const prevDelay = entry?.retryDelayMs ?? CONFIG_CACHE_INITIAL_RETRY_MS;
+				const nextDelay = Math.min(prevDelay * 2, CONFIG_CACHE_MAX_RETRY_MS);
+				if (entry) {
+					entry.nextFetchAt = now + nextDelay;
+					entry.retryDelayMs = nextDelay;
+				} else this.cache.set(userId, {
+					config: { typingTicket: "" },
+					everSucceeded: false,
+					nextFetchAt: now + CONFIG_CACHE_INITIAL_RETRY_MS,
+					retryDelayMs: CONFIG_CACHE_INITIAL_RETRY_MS
+				});
+			}
+		}
+		return this.cache.get(userId)?.config ?? { typingTicket: "" };
+	}
+};
+//#endregion
+//#region extensions/weixin/src/config/reply-progress.ts
+function resolveReplyProgressMessagesEnabled(cfg) {
+	return (cfg.channels?.["openclaw-weixin"])?.replyProgressMessages !== false;
+}
+//#endregion
+//#region extensions/weixin/src/cdn/pic-decrypt.ts
+/**
+* Download raw bytes from the CDN (no decryption).
+*/
+async function fetchCdnBytes(url, label) {
+	let res;
+	try {
+		res = await fetch(url);
+	} catch (err) {
+		const cause = err.cause ?? err.code ?? "(no cause)";
+		logger.error(`${label}: fetch network error url=${url} err=${String(err)} cause=${String(cause)}`);
+		throw err;
+	}
+	logger.debug(`${label}: response status=${res.status} ok=${res.ok}`);
+	if (!res.ok) {
+		const body = await res.text().catch(() => "(unreadable)");
+		const msg = `${label}: CDN download ${res.status} ${res.statusText} body=${body}`;
+		logger.error(msg);
+		throw new Error(msg);
+	}
+	return Buffer.from(await res.arrayBuffer());
+}
+/**
+* Parse CDNMedia.aes_key into a raw 16-byte AES key.
+*
+* Two encodings are seen in the wild:
+*   - base64(raw 16 bytes)          → images (aes_key from media field)
+*   - base64(hex string of 16 bytes) → file / voice / video
+*
+* In the second case, base64-decoding yields 32 ASCII hex chars which must
+* then be parsed as hex to recover the actual 16-byte key.
+*/
+function parseAesKey(aesKeyBase64, label) {
+	const decoded = Buffer.from(aesKeyBase64, "base64");
+	if (decoded.length === 16) return decoded;
+	if (decoded.length === 32 && /^[0-9a-fA-F]{32}$/.test(decoded.toString("ascii"))) return Buffer.from(decoded.toString("ascii"), "hex");
+	const msg = `${label}: aes_key must decode to 16 raw bytes or 32-char hex string, got ${decoded.length} bytes (base64="${aesKeyBase64}")`;
+	logger.error(msg);
+	throw new Error(msg);
+}
+/**
+* Download and AES-128-ECB decrypt a CDN media file. Returns plaintext Buffer.
+* aesKeyBase64: CDNMedia.aes_key JSON field (see parseAesKey for supported formats).
+*/
+async function downloadAndDecryptBuffer(encryptedQueryParam, aesKeyBase64, cdnBaseUrl, label, fullUrl) {
+	const key = parseAesKey(aesKeyBase64, label);
+	let url;
+	if (fullUrl) url = fullUrl;
+	else url = buildCdnDownloadUrl(encryptedQueryParam, cdnBaseUrl);
+	logger.debug(`${label}: fetching url=${url}`);
+	const encrypted = await fetchCdnBytes(url, label);
+	logger.debug(`${label}: downloaded ${encrypted.byteLength} bytes, decrypting`);
+	const decrypted = decryptAesEcb(encrypted, key);
+	logger.debug(`${label}: decrypted ${decrypted.length} bytes`);
+	return decrypted;
+}
+/**
+* Download plain (unencrypted) bytes from the CDN. Returns the raw Buffer.
+*/
+async function downloadPlainCdnBuffer(encryptedQueryParam, cdnBaseUrl, label, fullUrl) {
+	let url;
+	if (fullUrl) url = fullUrl;
+	else url = buildCdnDownloadUrl(encryptedQueryParam, cdnBaseUrl);
+	logger.debug(`${label}: fetching url=${url}`);
+	return fetchCdnBytes(url, label);
+}
+//#endregion
+//#region extensions/weixin/src/media/silk-transcode.ts
+/** Default sample rate for Weixin voice messages. */
+const SILK_SAMPLE_RATE = 24e3;
+/**
+* Wrap raw pcm_s16le bytes in a WAV container.
+* Mono channel, 16-bit signed little-endian.
+*/
+function pcmBytesToWav(pcm, sampleRate) {
+	const pcmBytes = pcm.byteLength;
+	const totalSize = 44 + pcmBytes;
+	const buf = Buffer.allocUnsafe(totalSize);
+	let offset = 0;
+	buf.write("RIFF", offset);
+	offset += 4;
+	buf.writeUInt32LE(totalSize - 8, offset);
+	offset += 4;
+	buf.write("WAVE", offset);
+	offset += 4;
+	buf.write("fmt ", offset);
+	offset += 4;
+	buf.writeUInt32LE(16, offset);
+	offset += 4;
+	buf.writeUInt16LE(1, offset);
+	offset += 2;
+	buf.writeUInt16LE(1, offset);
+	offset += 2;
+	buf.writeUInt32LE(sampleRate, offset);
+	offset += 4;
+	buf.writeUInt32LE(sampleRate * 2, offset);
+	offset += 4;
+	buf.writeUInt16LE(2, offset);
+	offset += 2;
+	buf.writeUInt16LE(16, offset);
+	offset += 2;
+	buf.write("data", offset);
+	offset += 4;
+	buf.writeUInt32LE(pcmBytes, offset);
+	offset += 4;
+	Buffer.from(pcm.buffer, pcm.byteOffset, pcm.byteLength).copy(buf, offset);
+	return buf;
+}
+/**
+* Try to transcode a SILK audio buffer to WAV using silk-wasm.
+* silk-wasm's decode() returns { data: Uint8Array (pcm_s16le), duration: number }.
+*
+* Returns a WAV Buffer on success, or null if silk-wasm is unavailable or decoding fails.
+* Callers should fall back to passing the raw SILK file when null is returned.
+*/
+async function silkToWav(silkBuf) {
+	try {
+		const { decode } = await import("./lib-5nplq6jB.js").then((m) => /* @__PURE__ */ __toESM(m.default, 1));
+		logger.debug(`silkToWav: decoding ${silkBuf.length} bytes of SILK`);
+		const result = await decode(silkBuf, SILK_SAMPLE_RATE);
+		logger.debug(`silkToWav: decoded duration=${result.duration}ms pcmBytes=${result.data.byteLength}`);
+		const wav = pcmBytesToWav(result.data, SILK_SAMPLE_RATE);
+		logger.debug(`silkToWav: WAV size=${wav.length}`);
+		return wav;
+	} catch (err) {
+		logger.warn(`silkToWav: transcode failed, will use raw silk err=${String(err)}`);
+		return null;
+	}
+}
+//#endregion
+//#region extensions/weixin/src/media/media-download.ts
+const WEIXIN_MEDIA_MAX_BYTES = 100 * 1024 * 1024;
+/**
+* Download and decrypt media from a single MessageItem.
+* Returns the populated WeixinInboundMediaOpts fields; empty object on unsupported type or failure.
+*/
+async function downloadMediaFromItem(item, deps) {
+	const { cdnBaseUrl, saveMedia, log, errLog, label } = deps;
+	const result = {};
+	if (item.type === MessageItemType.IMAGE) {
+		const img = item.image_item;
+		if (!img?.media?.encrypt_query_param && !img?.media?.full_url) return result;
+		const aesKeyBase64 = img.aeskey ? Buffer.from(img.aeskey, "hex").toString("base64") : img.media.aes_key;
+		logger.debug(`${label} image: encrypt_query_param=${(img.media.encrypt_query_param ?? "").slice(0, 40)}... hasAesKey=${Boolean(aesKeyBase64)} aeskeySource=${img.aeskey ? "image_item.aeskey" : "media.aes_key"} full_url=${Boolean(img.media.full_url)}`);
+		try {
+			const saved = await saveMedia(aesKeyBase64 ? await downloadAndDecryptBuffer(img.media.encrypt_query_param ?? "", aesKeyBase64, cdnBaseUrl, `${label} image`, img.media.full_url) : await downloadPlainCdnBuffer(img.media.encrypt_query_param ?? "", cdnBaseUrl, `${label} image-plain`, img.media.full_url), void 0, "inbound", WEIXIN_MEDIA_MAX_BYTES);
+			result.decryptedPicPath = saved.path;
+			logger.debug(`${label} image saved: ${saved.path}`);
+		} catch (err) {
+			logger.error(`${label} image download/decrypt failed: ${String(err)}`);
+			errLog(`weixin ${label} image download/decrypt failed: ${String(err)}`);
+		}
+	} else if (item.type === MessageItemType.VOICE) {
+		const voice = item.voice_item;
+		if (!voice?.media?.encrypt_query_param && !voice?.media?.full_url || !voice?.media?.aes_key) return result;
+		try {
+			const silkBuf = await downloadAndDecryptBuffer(voice.media.encrypt_query_param ?? "", voice.media.aes_key, cdnBaseUrl, `${label} voice`, voice.media.full_url);
+			logger.debug(`${label} voice: decrypted ${silkBuf.length} bytes, attempting silk transcode`);
+			const wavBuf = await silkToWav(silkBuf);
+			if (wavBuf) {
+				const saved = await saveMedia(wavBuf, "audio/wav", "inbound", WEIXIN_MEDIA_MAX_BYTES);
+				result.decryptedVoicePath = saved.path;
+				result.voiceMediaType = "audio/wav";
+				logger.debug(`${label} voice: saved WAV to ${saved.path}`);
+			} else {
+				const saved = await saveMedia(silkBuf, "audio/silk", "inbound", WEIXIN_MEDIA_MAX_BYTES);
+				result.decryptedVoicePath = saved.path;
+				result.voiceMediaType = "audio/silk";
+				logger.debug(`${label} voice: silk transcode unavailable, saved raw SILK to ${saved.path}`);
+			}
+		} catch (err) {
+			logger.error(`${label} voice download/transcode failed: ${String(err)}`);
+			errLog(`weixin ${label} voice download/transcode failed: ${String(err)}`);
+		}
+	} else if (item.type === MessageItemType.FILE) {
+		const fileItem = item.file_item;
+		if (!fileItem?.media?.encrypt_query_param && !fileItem?.media?.full_url || !fileItem?.media?.aes_key) return result;
+		try {
+			const buf = await downloadAndDecryptBuffer(fileItem.media.encrypt_query_param ?? "", fileItem.media.aes_key, cdnBaseUrl, `${label} file`, fileItem.media.full_url);
+			const mime = getMimeFromFilename(fileItem.file_name ?? "file.bin");
+			const saved = await saveMedia(buf, mime, "inbound", WEIXIN_MEDIA_MAX_BYTES, fileItem.file_name ?? void 0);
+			result.decryptedFilePath = saved.path;
+			result.fileMediaType = mime;
+			logger.debug(`${label} file: saved to ${saved.path} mime=${mime}`);
+		} catch (err) {
+			logger.error(`${label} file download failed: ${String(err)}`);
+			errLog(`weixin ${label} file download failed: ${String(err)}`);
+		}
+	} else if (item.type === MessageItemType.VIDEO) {
+		const videoItem = item.video_item;
+		if (!videoItem?.media?.encrypt_query_param && !videoItem?.media?.full_url || !videoItem?.media?.aes_key) return result;
+		try {
+			const saved = await saveMedia(await downloadAndDecryptBuffer(videoItem.media.encrypt_query_param ?? "", videoItem.media.aes_key, cdnBaseUrl, `${label} video`, videoItem.media.full_url), "video/mp4", "inbound", WEIXIN_MEDIA_MAX_BYTES);
+			result.decryptedVideoPath = saved.path;
+			logger.debug(`${label} video: saved to ${saved.path}`);
+		} catch (err) {
+			logger.error(`${label} video download failed: ${String(err)}`);
+			errLog(`weixin ${label} video download failed: ${String(err)}`);
+		}
+	}
+	return result;
+}
+//#endregion
+//#region extensions/weixin/src/messaging/debug-mode.ts
+/**
+* Per-bot debug mode toggle, persisted to disk so it survives gateway restarts.
+*
+* State file: `<stateDir>/openclaw-weixin/debug-mode.json`
+* Format:     `{ "accounts": { "<accountId>": true, ... } }`
+*
+* When enabled, processOneMessage appends a timing summary after each
+* AI reply is delivered to the user.
+*/
+function resolveDebugModePath() {
+	return path.join(resolveStateDir(), "openclaw-weixin", "debug-mode.json");
+}
+function loadState() {
+	try {
+		const raw = fs.readFileSync(resolveDebugModePath(), "utf-8");
+		const parsed = JSON.parse(raw);
+		if (parsed && typeof parsed.accounts === "object") return parsed;
+	} catch {}
+	return { accounts: {} };
+}
+function saveState(state) {
+	const filePath = resolveDebugModePath();
+	fs.mkdirSync(path.dirname(filePath), { recursive: true });
+	fs.writeFileSync(filePath, JSON.stringify(state, null, 2), "utf-8");
+}
+/** Toggle debug mode for a bot account. Returns the new state. */
+function toggleDebugMode(accountId) {
+	const state = loadState();
+	const next = !state.accounts[accountId];
+	state.accounts[accountId] = next;
+	try {
+		saveState(state);
+	} catch (err) {
+		logger.error(`debug-mode: failed to persist state: ${String(err)}`);
+	}
+	return next;
+}
+/** Check whether debug mode is active for a bot account. */
+function isDebugMode(accountId) {
+	return loadState().accounts[accountId] === true;
+}
+//#endregion
+//#region extensions/weixin/src/messaging/error-notice.ts
+/**
+* Send a plain-text error notice back to the user.
+* Fire-and-forget: errors are logged but never thrown, so callers stay unaffected.
+* No-op when contextToken is absent (we have no conversation reference to reply into).
+*/
+async function sendWeixinErrorNotice(params) {
+	if (!params.contextToken) logger.warn(`sendWeixinErrorNotice: no contextToken for to=${params.to}, sending without context`);
+	try {
+		await sendMessageWeixin({
+			to: params.to,
+			text: params.message,
+			opts: {
+				baseUrl: params.baseUrl,
+				token: params.token,
+				contextToken: params.contextToken,
+				...params.runId ? { runId: params.runId } : {}
+			}
+		});
+		logger.debug(`sendWeixinErrorNotice: sent to=${params.to}`);
+	} catch (err) {
+		params.errLog(`[weixin] sendWeixinErrorNotice failed to=${params.to}: ${String(err)}`);
+	}
+}
+//#endregion
+//#region extensions/weixin/src/messaging/reply-progress-sender.ts
+function normalizeToolStatus(status) {
+	if (status === "completed") return "completed";
+	if (status === "failed") return "failed";
+	if (status === "blocked") return "blocked";
+	return "unknown";
+}
+var WeixinReplyProgressSender = class {
+	constructor(deps) {
+		this.finalized = false;
+		this.sendChain = Promise.resolve();
+		this.runId = deps.runId;
+		this.to = deps.to;
+		this.accountId = deps.accountId;
+		this.opts = {
+			...deps.opts,
+			runId: deps.runId
+		};
+	}
+	get replyOptions() {
+		return {
+			runId: this.runId,
+			onItemEvent: (payload) => this.handleToolItemEvent(payload)
+		};
+	}
+	enqueueMessage(item, label) {
+		if (this.finalized) return;
+		this.sendChain = this.sendChain.then(async () => {
+			await sendMessageItemWeixin({
+				to: this.to,
+				item,
+				opts: this.opts,
+				label
+			});
+		}).catch((err) => {
+			logger.warn(`${label}: failed to=${this.to} accountId=${this.accountId} runId=${this.runId} err=${String(err)}`);
+		});
+	}
+	handleToolItemEvent(payload) {
+		if (this.finalized) return;
+		if (payload.kind !== "tool") return;
+		if (payload.phase !== "start" && payload.phase !== "end") return;
+		const now = Date.now();
+		const toolName = payload.name?.trim() || payload.title?.trim() || "tool";
+		const toolCallId = payload.itemId?.trim() || void 0;
+		if (payload.phase === "start") {
+			this.enqueueMessage({
+				type: MessageItemType.TOOL_CALL_START,
+				create_time_ms: now,
+				is_completed: false,
+				tool_call_start_item: {
+					tool_name: toolName,
+					tool_call_id: toolCallId
+				}
+			}, "sendToolCallStartMessage");
+			return;
+		}
+		this.enqueueMessage({
+			type: MessageItemType.TOOL_CALL_RESULT,
+			create_time_ms: now,
+			is_completed: true,
+			tool_call_result_item: {
+				tool_name: toolName,
+				tool_call_id: toolCallId,
+				status: normalizeToolStatus(payload.status)
+			}
+		}, "sendToolCallResultMessage");
+	}
+	async finalize() {
+		if (this.finalized) return;
+		this.finalized = true;
+		try {
+			await this.sendChain;
+		} catch (err) {
+			logger.warn(`WeixinReplyProgressSender.finalize: send drain failed runId=${this.runId} err=${String(err)}`);
+		}
+	}
+};
+//#endregion
+//#region extensions/weixin/src/messaging/slash-commands.ts
+/** 发送回复消息 */
+async function sendReply(ctx, text) {
+	const opts = {
+		baseUrl: ctx.baseUrl,
+		token: ctx.token,
+		contextToken: ctx.contextToken
+	};
+	await sendMessageWeixin({
+		to: ctx.to,
+		text,
+		opts
+	});
+}
+/** 处理 /echo 指令 */
+async function handleEcho(ctx, args, receivedAt, eventTimestamp) {
+	const message = args.trim();
+	if (message) await sendReply(ctx, message);
+	const eventTs = eventTimestamp ?? 0;
+	const platformDelay = eventTs > 0 ? `${receivedAt - eventTs}ms` : "N/A";
+	await sendReply(ctx, [
+		"⏱ 通道耗时",
+		`├ 事件时间: ${eventTs > 0 ? new Date(eventTs).toISOString() : "N/A"}`,
+		`├ 平台→插件: ${platformDelay}`,
+		`└ 插件处理: ${Date.now() - receivedAt}ms`
+	].join("\n"));
+}
+/**
+* 尝试处理斜杠指令
+*
+* @returns handled=true 表示该消息已作为指令处理，不需要继续走 AI 管道
+*/
+async function handleSlashCommand(content, ctx, receivedAt, eventTimestamp) {
+	const trimmed = content.trim();
+	if (!trimmed.startsWith("/")) return { handled: false };
+	const spaceIdx = trimmed.indexOf(" ");
+	const command = spaceIdx === -1 ? trimmed.toLowerCase() : trimmed.slice(0, spaceIdx).toLowerCase();
+	const args = spaceIdx === -1 ? "" : trimmed.slice(spaceIdx + 1);
+	logger.info(`[weixin] Slash command: ${command}, args: ${args.slice(0, 50)}`);
+	try {
+		switch (command) {
+			case "/echo":
+				await handleEcho(ctx, args, receivedAt, eventTimestamp);
+				return { handled: true };
+			case "/toggle-debug":
+				await sendReply(ctx, toggleDebugMode(ctx.accountId) ? "Debug 模式已开启" : "Debug 模式已关闭");
+				return { handled: true };
+			default: return { handled: false };
+		}
+	} catch (err) {
+		logger.error(`[weixin] Slash command error: ${String(err)}`);
+		try {
+			await sendReply(ctx, `❌ 指令执行失败: ${String(err).slice(0, 200)}`);
+		} catch {}
+		return { handled: true };
+	}
+}
+//#endregion
+//#region extensions/weixin/src/messaging/process-message.ts
+const MEDIA_OUTBOUND_TEMP_DIR = path.join(resolvePreferredFengMingTmpDir(), "weixin/media/outbound-temp");
+/** Extract text body from item_list (for slash command detection). */
+function extractTextBody(itemList) {
+	if (!itemList?.length) return "";
+	for (const item of itemList) if (item.type === MessageItemType.TEXT && item.text_item?.text != null) return String(item.text_item.text);
+	return "";
+}
+/**
+* Process a single inbound message: route → download media → dispatch reply.
+* Extracted from the monitor loop to keep monitoring and message handling separate.
+*/
+async function processOneMessage(full, deps) {
+	if (!deps?.channelRuntime) {
+		logger.error(`processOneMessage: channelRuntime is undefined, skipping message from=${full.from_user_id}`);
+		deps.errLog("processOneMessage: channelRuntime is undefined, skip");
+		return;
+	}
+	const receivedAt = Date.now();
+	const debug = isDebugMode(deps.accountId);
+	const debugTrace = [];
+	const debugTs = { received: receivedAt };
+	const textBody = extractTextBody(full.item_list);
+	if (textBody.startsWith("/")) {
+		if ((await handleSlashCommand(textBody, {
+			to: full.from_user_id ?? "",
+			contextToken: full.context_token,
+			baseUrl: deps.baseUrl,
+			token: deps.token,
+			accountId: deps.accountId,
+			log: deps.log,
+			errLog: deps.errLog
+		}, receivedAt, full.create_time_ms)).handled) {
+			logger.info(`[weixin] Slash command handled, skipping AI pipeline`);
+			return;
+		}
+	}
+	if (debug) {
+		const itemTypes = full.item_list?.map((i) => i.type).join(",") ?? "none";
+		debugTrace.push("── 收消息 ──", `│ seq=${full.seq ?? "?"} msgId=${full.message_id ?? "?"} from=${full.from_user_id ?? "?"}`, `│ body="${textBody.slice(0, 40)}${textBody.length > 40 ? "…" : ""}" (len=${textBody.length}) itemTypes=[${itemTypes}]`, `│ sessionId=${full.session_id ?? "?"} contextToken=${full.context_token ? "present" : "none"}`);
+	}
+	const mediaOpts = {};
+	const hasDownloadableMedia = (m) => m?.encrypt_query_param || m?.full_url;
+	const mainMediaItem = full.item_list?.find((i) => i.type === MessageItemType.IMAGE && hasDownloadableMedia(i.image_item?.media)) ?? full.item_list?.find((i) => i.type === MessageItemType.VIDEO && hasDownloadableMedia(i.video_item?.media)) ?? full.item_list?.find((i) => i.type === MessageItemType.FILE && hasDownloadableMedia(i.file_item?.media)) ?? full.item_list?.find((i) => i.type === MessageItemType.VOICE && hasDownloadableMedia(i.voice_item?.media) && !i.voice_item?.text);
+	const refMediaItem = !mainMediaItem ? full.item_list?.find((i) => i.type === MessageItemType.TEXT && i.ref_msg?.message_item && isMediaItem(i.ref_msg.message_item))?.ref_msg?.message_item : void 0;
+	const mediaDownloadStart = Date.now();
+	const mediaItem = mainMediaItem ?? refMediaItem;
+	if (mediaItem) {
+		const label = refMediaItem ? "ref" : "inbound";
+		const downloaded = await downloadMediaFromItem(mediaItem, {
+			cdnBaseUrl: deps.cdnBaseUrl,
+			saveMedia: deps.channelRuntime.media.saveMediaBuffer,
+			log: deps.log,
+			errLog: deps.errLog,
+			label
+		});
+		Object.assign(mediaOpts, downloaded);
+	}
+	const mediaDownloadMs = Date.now() - mediaDownloadStart;
+	if (debug) debugTrace.push(mediaItem ? `│ mediaDownload: type=${mediaItem.type} cost=${mediaDownloadMs}ms` : "│ mediaDownload: none");
+	const ctx = weixinMessageToMsgContext(full, deps.accountId, mediaOpts);
+	const rawBody = ctx.Body?.trim() ?? "";
+	ctx.CommandBody = rawBody;
+	const senderId = full.from_user_id ?? "";
+	const { senderAllowedForCommands, commandAuthorized } = await resolveSenderCommandAuthorizationWithRuntime({
+		cfg: deps.config,
+		rawBody,
+		isGroup: false,
+		dmPolicy: "pairing",
+		configuredAllowFrom: [],
+		configuredGroupAllowFrom: [],
+		senderId,
+		isSenderAllowed: (id, list) => list.length === 0 || list.includes(id),
+		/** Pairing: framework credentials `*-allowFrom.json`, with account `userId` fallback for legacy installs. */
+		readAllowFromStore: async () => {
+			const fromStore = readFrameworkAllowFromList(deps.accountId);
+			if (fromStore.length > 0) return fromStore;
+			const uid = loadWeixinAccount(deps.accountId)?.userId?.trim();
+			return uid ? [uid] : [];
+		},
+		runtime: deps.channelRuntime.commands
+	});
+	const directDmOutcome = resolveDirectDmAuthorizationOutcome({
+		isGroup: false,
+		dmPolicy: "pairing",
+		senderAllowedForCommands
+	});
+	if (directDmOutcome === "disabled" || directDmOutcome === "unauthorized") {
+		logger.info(`authorization: dropping message from=${senderId} outcome=${directDmOutcome}`);
+		return;
+	}
+	ctx.CommandAuthorized = commandAuthorized;
+	logger.debug(`authorization: senderId=${senderId} commandAuthorized=${String(commandAuthorized)} senderAllowed=${String(senderAllowedForCommands)}`);
+	if (debug) debugTrace.push("── 鉴权 & 路由 ──", `│ auth: cmdAuthorized=${String(commandAuthorized)} senderAllowed=${String(senderAllowedForCommands)}`);
+	const route = deps.channelRuntime.routing.resolveAgentRoute({
+		cfg: deps.config,
+		channel: "openclaw-weixin",
+		accountId: deps.accountId,
+		peer: {
+			kind: "direct",
+			id: ctx.To
+		}
+	});
+	logger.debug(`resolveAgentRoute: agentId=${route.agentId ?? "(none)"} sessionKey=${route.sessionKey ?? "(none)"} mainSessionKey=${route.mainSessionKey ?? "(none)"}`);
+	if (!route.agentId) logger.error(`resolveAgentRoute: no agentId resolved for peer=${ctx.To} accountId=${deps.accountId} — message will not be dispatched`);
+	if (debug) {
+		debugTrace.push(`│ route: agent=${route.agentId ?? "none"} session=${route.sessionKey ?? "none"}`);
+		debugTs.preDispatch = Date.now();
+	}
+	ctx.SessionKey = route.sessionKey;
+	const storePath = deps.channelRuntime.session.resolveStorePath(deps.config.session?.store, { agentId: route.agentId });
+	const finalized = deps.channelRuntime.reply.finalizeInboundContext(ctx);
+	logger.info(`inbound: from=${finalized.From} to=${finalized.To} bodyLen=${(finalized.Body ?? "").length} hasMedia=${Boolean(finalized.MediaPath ?? finalized.MediaUrl)}`);
+	logger.debug(`inbound context: ${redactBody(JSON.stringify(finalized))}`);
+	await deps.channelRuntime.session.recordInboundSession({
+		storePath,
+		sessionKey: route.sessionKey,
+		ctx: finalized,
+		updateLastRoute: {
+			sessionKey: route.mainSessionKey,
+			channel: "openclaw-weixin",
+			to: ctx.To,
+			accountId: deps.accountId
+		},
+		onRecordError: (err) => deps.errLog(`recordInboundSession: ${String(err)}`)
+	});
+	logger.debug(`recordInboundSession: done storePath=${storePath} sessionKey=${route.sessionKey ?? "(none)"}`);
+	const contextToken = getContextTokenFromMsgContext(ctx);
+	if (contextToken) setContextToken(deps.accountId, full.from_user_id ?? "", contextToken);
+	const runId = randomUUID();
+	const replyProgressSender = resolveReplyProgressMessagesEnabled(deps.config) ? new WeixinReplyProgressSender({
+		runId,
+		to: ctx.To,
+		accountId: deps.accountId,
+		opts: {
+			baseUrl: deps.baseUrl,
+			token: deps.token,
+			contextToken
+		}
+	}) : void 0;
+	const humanDelay = deps.channelRuntime.reply.resolveHumanDelayConfig(deps.config, route.agentId);
+	const hasTypingTicket = Boolean(deps.typingTicket);
+	const typingCallbacks = createTypingCallbacks({
+		start: hasTypingTicket ? () => sendTyping({
+			baseUrl: deps.baseUrl,
+			token: deps.token,
+			body: {
+				ilink_user_id: ctx.To,
+				typing_ticket: deps.typingTicket,
+				status: TypingStatus.TYPING
+			}
+		}) : async () => {},
+		stop: hasTypingTicket ? () => sendTyping({
+			baseUrl: deps.baseUrl,
+			token: deps.token,
+			body: {
+				ilink_user_id: ctx.To,
+				typing_ticket: deps.typingTicket,
+				status: TypingStatus.CANCEL
+			}
+		}) : async () => {},
+		onStartError: (err) => deps.log(`[weixin] typing send error: ${String(err)}`),
+		onStopError: (err) => deps.log(`[weixin] typing cancel error: ${String(err)}`),
+		keepaliveIntervalMs: 5e3
+	});
+	/** Delivery records populated synchronously at deliver() entry, safe to read in finally. */
+	const debugDeliveries = [];
+	const { dispatcher, replyOptions, markDispatchIdle } = deps.channelRuntime.reply.createReplyDispatcherWithTyping({
+		humanDelay,
+		typingCallbacks,
+		deliver: async (payload) => {
+			const rawText = payload.text ?? "";
+			let text = (() => {
+				const f = new StreamingMarkdownFilter();
+				return f.feed(rawText) + f.flush();
+			})();
+			const mediaUrl = payload.mediaUrl ?? payload.mediaUrls?.[0];
+			logger.debug(`outbound payload: ${redactBody(JSON.stringify(payload))}`);
+			logger.info(`outbound: to=${ctx.To} contextToken=${redactToken(contextToken)} textLen=${text.length} mediaUrl=${mediaUrl ? "present" : "none"}`);
+			if (debug) debugDeliveries.push({
+				textLen: text.length,
+				media: mediaUrl ? "present" : "none",
+				preview: `${text.slice(0, 60)}${text.length > 60 ? "…" : ""}`,
+				ts: Date.now()
+			});
+			const sendingResult = await applyWeixinMessageSendingHook({
+				to: ctx.To,
+				text,
+				accountId: deps.accountId,
+				mediaUrl,
+				runId
+			});
+			if (sendingResult.cancelled) {
+				logger.info(`outbound: cancelled by message_sending hook to=${ctx.To}`);
+				return;
+			}
+			text = sendingResult.text;
+			try {
+				if (mediaUrl) {
+					let filePath;
+					if (!mediaUrl.includes("://") || mediaUrl.startsWith("file://")) {
+						if (mediaUrl.startsWith("file://")) filePath = new URL(mediaUrl).pathname;
+						else if (!path.isAbsolute(mediaUrl)) {
+							filePath = path.resolve(mediaUrl);
+							logger.debug(`outbound: resolved relative path ${mediaUrl} -> ${filePath}`);
+						} else filePath = mediaUrl;
+						logger.debug(`outbound: local file path resolved filePath=${filePath}`);
+					} else if (mediaUrl.startsWith("http://") || mediaUrl.startsWith("https://")) {
+						logger.debug(`outbound: downloading remote mediaUrl=${mediaUrl.slice(0, 80)}...`);
+						filePath = await downloadRemoteImageToTemp(mediaUrl, MEDIA_OUTBOUND_TEMP_DIR);
+						logger.debug(`outbound: remote image downloaded to filePath=${filePath}`);
+					} else {
+						logger.warn(`outbound: unrecognized mediaUrl scheme, sending text only mediaUrl=${mediaUrl.slice(0, 80)}`);
+						await sendMessageWeixin({
+							to: ctx.To,
+							text,
+							opts: {
+								baseUrl: deps.baseUrl,
+								token: deps.token,
+								contextToken,
+								runId
+							}
+						});
+						emitWeixinMessageSent({
+							to: ctx.To,
+							content: text,
+							success: true,
+							accountId: deps.accountId,
+							runId
+						});
+						logger.info(`outbound: text sent to=${ctx.To}`);
+						return;
+					}
+					await sendWeixinMediaFile({
+						filePath,
+						to: ctx.To,
+						text,
+						opts: {
+							baseUrl: deps.baseUrl,
+							token: deps.token,
+							contextToken,
+							runId
+						},
+						cdnBaseUrl: deps.cdnBaseUrl
+					});
+					emitWeixinMessageSent({
+						to: ctx.To,
+						content: text,
+						success: true,
+						accountId: deps.accountId,
+						runId
+					});
+					logger.info(`outbound: media sent OK to=${ctx.To}`);
+				} else {
+					logger.debug(`outbound: sending text message to=${ctx.To}`);
+					await sendMessageWeixin({
+						to: ctx.To,
+						text,
+						opts: {
+							baseUrl: deps.baseUrl,
+							token: deps.token,
+							contextToken,
+							runId
+						}
+					});
+					emitWeixinMessageSent({
+						to: ctx.To,
+						content: text,
+						success: true,
+						accountId: deps.accountId,
+						runId
+					});
+					logger.info(`outbound: text sent OK to=${ctx.To}`);
+				}
+			} catch (err) {
+				emitWeixinMessageSent({
+					to: ctx.To,
+					content: text,
+					success: false,
+					error: String(err),
+					accountId: deps.accountId,
+					runId
+				});
+				logger.error(`outbound: FAILED to=${ctx.To} mediaUrl=${mediaUrl ?? "none"} err=${String(err)} stack=${err.stack ?? ""}`);
+				throw err;
+			}
+		},
+		onError: (err, info) => {
+			deps.errLog(`weixin reply ${info.kind}: ${String(err)}`);
+			const errMsg = err instanceof Error ? err.message : String(err);
+			let notice;
+			if (errMsg.includes("remote media download failed") || errMsg.includes("fetch")) notice = `⚠️ 媒体文件下载失败，请检查链接是否可访问。`;
+			else if (errMsg.includes("getUploadUrl") || errMsg.includes("CDN upload") || errMsg.includes("upload_param")) notice = `⚠️ 媒体文件上传失败，请稍后重试。`;
+			else notice = `⚠️ 消息发送失败：${errMsg}`;
+			sendWeixinErrorNotice({
+				to: ctx.To,
+				contextToken,
+				message: notice,
+				baseUrl: deps.baseUrl,
+				token: deps.token,
+				runId,
+				errLog: deps.errLog
+			});
+		}
+	});
+	logger.debug(`dispatchReplyFromConfig: starting agentId=${route.agentId ?? "(none)"}`);
+	try {
+		await deps.channelRuntime.reply.withReplyDispatcher({
+			dispatcher,
+			run: () => deps.channelRuntime.reply.dispatchReplyFromConfig({
+				ctx: finalized,
+				cfg: deps.config,
+				dispatcher,
+				replyOptions: {
+					...replyOptions,
+					...replyProgressSender?.replyOptions ?? {},
+					disableBlockStreaming: true
+				}
+			})
+		});
+		logger.debug(`dispatchReplyFromConfig: done agentId=${route.agentId ?? "(none)"}`);
+	} catch (err) {
+		logger.error(`dispatchReplyFromConfig: error agentId=${route.agentId ?? "(none)"} err=${String(err)}`);
+		throw err;
+	} finally {
+		markDispatchIdle();
+		await replyProgressSender?.finalize();
+		logger.info(`debug-check: accountId=${deps.accountId} debug=${String(debug)} hasContextToken=${Boolean(contextToken)}`);
+		if (debug && contextToken) {
+			const dispatchDoneAt = Date.now();
+			const eventTs = full.create_time_ms ?? 0;
+			const platformDelay = eventTs > 0 ? `${receivedAt - eventTs}ms` : "N/A";
+			const inboundProcessMs = (debugTs.preDispatch ?? receivedAt) - receivedAt;
+			const aiMs = dispatchDoneAt - (debugTs.preDispatch ?? receivedAt);
+			const totalTime = eventTs > 0 ? `${dispatchDoneAt - eventTs}ms` : `${dispatchDoneAt - receivedAt}ms`;
+			if (debugDeliveries.length > 0) {
+				debugTrace.push("── 回复 ──");
+				for (const d of debugDeliveries) debugTrace.push(`│ textLen=${d.textLen} media=${d.media}`, `│ text="${d.preview}"`);
+				const firstTs = debugDeliveries[0].ts;
+				debugTrace.push(`│ deliver耗时: ${dispatchDoneAt - firstTs}ms`);
+			} else debugTrace.push("── 回复 ──", "│ (deliver未捕获)");
+			debugTrace.push("── 耗时 ──", `├ 平台→插件: ${platformDelay}`, `├ 入站处理(auth+route+media): ${inboundProcessMs}ms (mediaDownload: ${mediaDownloadMs}ms)`, `├ AI生成+回复: ${aiMs}ms`, `├ 总耗时: ${totalTime}`, `└ eventTime: ${eventTs > 0 ? new Date(eventTs).toISOString() : "N/A"}`);
+			const timingText = `⏱ Debug 全链路\n${debugTrace.join("\n")}`;
+			logger.info(`debug-timing: sending to=${ctx.To}`);
+			try {
+				await sendMessageWeixin({
+					to: ctx.To,
+					text: timingText,
+					opts: {
+						baseUrl: deps.baseUrl,
+						token: deps.token,
+						contextToken,
+						runId
+					}
+				});
+				logger.info(`debug-timing: sent OK`);
+			} catch (debugErr) {
+				logger.error(`debug-timing: send FAILED err=${String(debugErr)}`);
+			}
+		}
+	}
+}
+//#endregion
+//#region extensions/weixin/src/storage/sync-buf.ts
+function resolveAccountsDir() {
+	return path.join(resolveStateDir(), "openclaw-weixin", "accounts");
+}
+/**
+* Path to the persistent get_updates_buf file for an account.
+* Stored alongside account data: ~/.openclaw/openclaw-weixin/accounts/{accountId}.sync.json
+*/
+function getSyncBufFilePath(accountId) {
+	return path.join(resolveAccountsDir(), `${accountId}.sync.json`);
+}
+/** Legacy single-account syncbuf (pre multi-account): `.openclaw-weixin-sync/default.json`. */
+function getLegacySyncBufDefaultJsonPath() {
+	return path.join(resolveStateDir(), "agents", "default", "sessions", ".openclaw-weixin-sync", "default.json");
+}
+function readSyncBufFile(filePath) {
+	try {
+		const raw = fs.readFileSync(filePath, "utf-8");
+		const data = JSON.parse(raw);
+		if (typeof data.get_updates_buf === "string") return data.get_updates_buf;
+	} catch {}
+}
+/**
+* Load persisted get_updates_buf.
+* Falls back in order:
+*   1. Primary path (normalized accountId, new installs)
+*   2. Compat path (raw accountId derived from pattern, old installs)
+*   3. Legacy single-account path (very old installs without multi-account support)
+*/
+function loadGetUpdatesBuf(filePath) {
+	const value = readSyncBufFile(filePath);
+	if (value !== void 0) return value;
+	const rawId = deriveRawAccountId(path.basename(filePath, ".sync.json"));
+	if (rawId) {
+		const compatValue = readSyncBufFile(path.join(resolveAccountsDir(), `${rawId}.sync.json`));
+		if (compatValue !== void 0) return compatValue;
+	}
+	return readSyncBufFile(getLegacySyncBufDefaultJsonPath());
+}
+/**
+* Persist get_updates_buf. Creates parent dir if needed.
+*/
+function saveGetUpdatesBuf(filePath, getUpdatesBuf) {
+	const dir = path.dirname(filePath);
+	fs.mkdirSync(dir, { recursive: true });
+	fs.writeFileSync(filePath, JSON.stringify({ get_updates_buf: getUpdatesBuf }, null, 0), "utf-8");
+}
+//#endregion
+//#region extensions/weixin/src/monitor/monitor.ts
+const DEFAULT_LONG_POLL_TIMEOUT_MS = 35e3;
+const MAX_CONSECUTIVE_FAILURES = 3;
+const BACKOFF_DELAY_MS = 3e4;
+const RETRY_DELAY_MS = 2e3;
+/**
+* Long-poll loop: getUpdates -> normalize -> recordInboundSession -> dispatchReplyFromConfig.
+* Runs until abort.
+*/
+async function monitorWeixinProvider(opts) {
+	const { baseUrl, cdnBaseUrl, token, accountId, config, channelRuntime, abortSignal, longPollTimeoutMs, setStatus } = opts;
+	const log = opts.runtime?.log ?? (() => {});
+	const errLog = opts.runtime?.error ?? ((m) => log(m));
+	const aLog = logger.withAccount(accountId);
+	if (!channelRuntime) {
+		const msg = "channelRuntime missing on monitor opts; gateway must inject ChannelGatewayContext.channelRuntime";
+		aLog.error(msg);
+		throw new Error(msg);
+	}
+	log(`weixin monitor started (${baseUrl}, account=${accountId})`);
+	aLog.info(`Monitor started: baseUrl=${baseUrl} timeoutMs=${longPollTimeoutMs ?? DEFAULT_LONG_POLL_TIMEOUT_MS}`);
+	const syncFilePath = getSyncBufFilePath(accountId);
+	aLog.debug(`syncFilePath: ${syncFilePath}`);
+	const previousGetUpdatesBuf = loadGetUpdatesBuf(syncFilePath);
+	let getUpdatesBuf = previousGetUpdatesBuf ?? "";
+	if (previousGetUpdatesBuf) {
+		log(`[weixin] resuming from previous sync buf (${getUpdatesBuf.length} bytes)`);
+		aLog.debug(`Using previous get_updates_buf (${getUpdatesBuf.length} bytes)`);
+	} else {
+		log(`[weixin] no previous sync buf, starting fresh`);
+		aLog.info(`No previous get_updates_buf found, starting fresh`);
+	}
+	const configManager = new WeixinConfigManager({
+		baseUrl,
+		token
+	}, log);
+	let nextTimeoutMs = longPollTimeoutMs ?? DEFAULT_LONG_POLL_TIMEOUT_MS;
+	let consecutiveFailures = 0;
+	while (!abortSignal?.aborted) try {
+		aLog.debug(`getUpdates: get_updates_buf=${getUpdatesBuf.substring(0, 50)}..., timeoutMs=${nextTimeoutMs}`);
+		const resp = await getUpdates({
+			baseUrl,
+			token,
+			get_updates_buf: getUpdatesBuf,
+			timeoutMs: nextTimeoutMs,
+			abortSignal
+		});
+		aLog.debug(`getUpdates response: ret=${resp.ret}, msgs=${resp.msgs?.length ?? 0}, get_updates_buf_length=${resp.get_updates_buf?.length ?? 0}`);
+		if (resp.longpolling_timeout_ms != null && resp.longpolling_timeout_ms > 0) {
+			nextTimeoutMs = resp.longpolling_timeout_ms;
+			aLog.debug(`Updated next poll timeout: ${nextTimeoutMs}ms`);
+		}
+		if (resp.ret !== void 0 && resp.ret !== 0 || resp.errcode !== void 0 && resp.errcode !== 0) {
+			if (resp.errcode === -14 || resp.ret === -14) {
+				pauseSession(accountId);
+				const pauseMs = getRemainingPauseMs(accountId);
+				errLog(`weixin getUpdates: session expired (errcode -14), pausing bot for ${Math.ceil(pauseMs / 6e4)} min`);
+				aLog.error(`getUpdates: session expired (errcode=${resp.errcode} ret=${resp.ret}), pausing all requests for ${Math.ceil(pauseMs / 6e4)} min`);
+				consecutiveFailures = 0;
+				await sleep(pauseMs, abortSignal);
+				continue;
+			}
+			consecutiveFailures += 1;
+			errLog(`weixin getUpdates failed: ret=${resp.ret} errcode=${resp.errcode} errmsg=${resp.errmsg ?? ""} (${consecutiveFailures}/${MAX_CONSECUTIVE_FAILURES})`);
+			aLog.error(`getUpdates failed: ret=${resp.ret} errcode=${resp.errcode} errmsg=${resp.errmsg} response=${redactBody(JSON.stringify(resp))}`);
+			if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+				errLog(`weixin getUpdates: ${MAX_CONSECUTIVE_FAILURES} consecutive failures, backing off 30s`);
+				aLog.error(`getUpdates: ${MAX_CONSECUTIVE_FAILURES} consecutive failures, backing off 30s`);
+				consecutiveFailures = 0;
+				await sleep(BACKOFF_DELAY_MS, abortSignal);
+			} else await sleep(RETRY_DELAY_MS, abortSignal);
+			continue;
+		}
+		consecutiveFailures = 0;
+		setStatus?.({
+			accountId,
+			lastEventAt: Date.now()
+		});
+		if (resp.get_updates_buf != null && resp.get_updates_buf !== "") {
+			saveGetUpdatesBuf(syncFilePath, resp.get_updates_buf);
+			getUpdatesBuf = resp.get_updates_buf;
+			aLog.debug(`Saved new get_updates_buf (${getUpdatesBuf.length} bytes)`);
+		}
+		const list = resp.msgs ?? [];
+		for (const full of list) {
+			aLog.info(`inbound message: from=${full.from_user_id} types=${full.item_list?.map((i) => i.type).join(",") ?? "none"}`);
+			const now = Date.now();
+			setStatus?.({
+				accountId,
+				lastEventAt: now,
+				lastInboundAt: now
+			});
+			const fromUserId = full.from_user_id ?? "";
+			await processOneMessage(full, {
+				accountId,
+				config,
+				channelRuntime,
+				baseUrl,
+				cdnBaseUrl,
+				token,
+				typingTicket: (await configManager.getForUser(fromUserId, full.context_token)).typingTicket,
+				log: opts.runtime?.log ?? (() => {}),
+				errLog
+			});
+		}
+	} catch (err) {
+		if (abortSignal?.aborted) {
+			aLog.info(`Monitor stopped (aborted)`);
+			return;
+		}
+		consecutiveFailures += 1;
+		errLog(`weixin getUpdates error (${consecutiveFailures}/${MAX_CONSECUTIVE_FAILURES}): ${String(err)}`);
+		aLog.error(`getUpdates error: ${String(err)}, stack=${err.stack}`);
+		if (consecutiveFailures >= MAX_CONSECUTIVE_FAILURES) {
+			errLog(`weixin getUpdates: ${MAX_CONSECUTIVE_FAILURES} consecutive failures, backing off 30s`);
+			aLog.error(`getUpdates: ${MAX_CONSECUTIVE_FAILURES} consecutive failures, backing off 30s`);
+			consecutiveFailures = 0;
+			await sleep(3e4, abortSignal);
+		} else await sleep(2e3, abortSignal);
+	}
+	aLog.info(`Monitor ended`);
+}
+function sleep(ms, signal) {
+	return new Promise((resolve, reject) => {
+		const t = setTimeout(resolve, ms);
+		signal?.addEventListener("abort", () => {
+			clearTimeout(t);
+			reject(/* @__PURE__ */ new Error("aborted"));
+		}, { once: true });
+	});
+}
+//#endregion
+export { monitorWeixinProvider };