@jeik/dingtalk-connector 0.8.27 → 0.8.28

package/dist/{connection-fc6B4z4G.mjs → connection-CZ7ZoN5_.mjs}

@@ -1,4 +1,5 @@
 import { i as checkAndMarkDingtalkMessage } from "./utils-legacy-DQ3HeGHh.mjs";
+import { n as onBackgroundWorkCountChange, t as getActiveBackgroundWorkCount } from "./background-work-Cxb4b-91.mjs";
 import * as fs from "fs";
 //#region src/core/connection.ts
 /**
@@ -6,26 +7,69 @@ import * as fs from "fs";
 *
 * 职责：
 * - 管理单个钉钉账号的 WebSocket 连接
-* - 实现应用层心跳检测（10 秒间隔，90 秒超时）
+* - 实现应用层心跳检测（10 秒间隔，20 秒无 pong 超时）
 * - 处理连接重连逻辑，带指数退避
 * - 消息去重（内置 Map，5 分钟 TTL）
 *
 * 核心特性：
 * - 关闭 SDK 内置 keepAlive，使用自定义心跳
+* - connect 后等 OPEN + SYSTEM/REGISTERED 再报 ready（防首条消息丢失）
+* - 重连后先挂 pong/message/close listener 再等就绪（防幽灵重连）
 * - 详细的消息接收日志（三阶段：接收、解析、处理）
 * - 连接统计和监控（每分钟输出）
 */
 /** 心跳间隔（毫秒） */
 const HEARTBEAT_INTERVAL = 10 * 1e3;
-/** 超时阈值（毫秒） */
-const TIMEOUT_THRESHOLD = 20 * 1e3;
+/**
+* 无 pong 软超时：仅计「连续未确认」次数，不立刻 disconnect。
+* 过去这里直接 doReconnect()，会在 socket 仍 OPEN 时拆掉活连接，
+* 造成数秒空窗 → 用户连发 3~7 条消息钉钉推不到本进程（网关 UI 完全收不到）。
+*/
+const SOFT_STALE_MS = 20 * 1e3;
+/** 连续软超时次数达到该值，且 socket 非 OPEN 或 ping 失败，才硬重连 */
+const HARD_RECONNECT_AFTER_MISSES = 3;
+/** 两次硬重连之间的最小间隔（除非 socket 已死） */
+const MIN_RECONNECT_GAP_MS = 30 * 1e3;
+/**
+* 消息处理期间刷新 lastSocketAvailableTime 的间隔。
+* 必须明显小于 SOFT_STALE_MS。
+*/
+const MESSAGE_PROCESSING_KEEPALIVE_MS = 15 * 1e3;
 /** 基础退避时间（毫秒） */
 const BASE_BACKOFF_DELAY = 1e3;
 /** 最大退避时间（毫秒） */
 const MAX_BACKOFF_DELAY = 30 * 1e3;
+/** 单次等待 OPEN + REGISTERED 的超时 */
+const STREAM_READY_TIMEOUT_MS = 15e3;
+/**
+* REGISTERED 未就绪时最多完整重连次数（含首次）。
+* 超时禁止 OPEN-only 假 ready，避免「显示已连接但收不到 CALLBACK」。
+*/
+const REGISTERED_CONNECT_MAX_ATTEMPTS = 5;
+let _streamNoiseSilenced = false;
+function silenceDingtalkStreamConsoleNoise() {
+	if (_streamNoiseSilenced) return;
+	_streamNoiseSilenced = true;
+	const origConsoleInfo = console.info.bind(console);
+	console.info = (...args) => {
+		const first = args[0];
+		if (typeof first === "string") {
+			if (first === "Disconnecting.") return;
+			if (/^\[[^\]]+\] connect success$/.test(first)) return;
+		}
+		return origConsoleInfo(...args);
+	};
+}
+let _connectionNoticePrinted = false;
+function printConnectionNoticeOnce() {
+	if (_connectionNoticePrinted) return;
+	_connectionNoticePrinted = true;
+	console.log("[dingtalk-connector] ℹ️  上游 dingtalk-stream 噪音已过滤；须 OPEN+REGISTERED 才报 ready，REGISTERED 超时会强制重连（禁止假 online）。正常运行不应出现 ≤30s 周期性硬重连。");
+}
 async function monitorSingleAccount(opts) {
 	const { cfg, account, runtime, abortSignal, messageHandler, onStatusChange } = opts;
 	const { accountId } = account;
+	silenceDingtalkStreamConsoleNoise();
 	const clawdbotConfig = cfg;
 	const log = runtime?.log;
 	const { createLoggerFromConfig } = await import("./logger-BmJkQkm1.mjs");
@@ -71,43 +115,192 @@ async function monitorSingleAccount(opts) {
 	let reconnectAttempts = 0;
 	let keepAliveTimer = null;
 	let isStopped = false;
+	/** 连续 keepAlive 周期内未收到 pong / 未刷新的次数 */
+	let consecutiveStaleMisses = 0;
+	let lastHardReconnectAt = 0;
+	let wsCallbackActive = false;
 	let activeMessageProcessing = false;
 	let messageProcessingKeepAliveTimer = null;
-	/**
-	* 标记消息处理开始，启动定期更新机制
-	* 在消息处理期间，每 30 秒更新一次 lastSocketAvailableTime
-	* 防止长时间处理（如复杂的 AI 任务）触发心跳超时
-	*/
-	function markMessageProcessingStart() {
-		activeMessageProcessing = true;
-		lastSocketAvailableTime = Date.now();
-		if (messageProcessingKeepAliveTimer) clearInterval(messageProcessingKeepAliveTimer);
+	let unsubscribeBackgroundWork = null;
+	function ensureProcessingKeepAliveTimer() {
+		if (messageProcessingKeepAliveTimer) return;
 		messageProcessingKeepAliveTimer = setInterval(() => {
 			if (activeMessageProcessing) {
 				lastSocketAvailableTime = Date.now();
-				logger.debug(`📝 消息处理中，更新 socket 可用时间`);
+				logger.debug(`📝 消息处理中，更新 socket 可用时间 (ws=${wsCallbackActive} bg=${getActiveBackgroundWorkCount()})`);
 			}
-		}, 30 * 1e3);
-		logger.debug(`📝 消息处理开始，启动活跃标记定时器`);
+		}, MESSAGE_PROCESSING_KEEPALIVE_MS);
 	}
-	/**
-	* 标记消息处理结束，停止定期更新机制
-	*/
-	function markMessageProcessingEnd() {
-		activeMessageProcessing = false;
+	function clearProcessingKeepAliveTimer() {
 		if (messageProcessingKeepAliveTimer) {
 			clearInterval(messageProcessingKeepAliveTimer);
 			messageProcessingKeepAliveTimer = null;
 		}
+	}
+	/** 根据 WS 入队中 / 后台任务数 合成 activeMessageProcessing */
+	function refreshProcessingActive(reason) {
+		const bg = getActiveBackgroundWorkCount();
+		const next = wsCallbackActive || bg > 0;
+		activeMessageProcessing = next;
 		lastSocketAvailableTime = Date.now();
-		logger.debug(`✅ 消息处理结束，清理活跃标记定时器`);
+		if (next) {
+			ensureProcessingKeepAliveTimer();
+			logger.debug(`📝 处理活跃 reason=${reason} ws=${wsCallbackActive} bg=${bg}`);
+		} else {
+			clearProcessingKeepAliveTimer();
+			logger.debug(`✅ 处理空闲 reason=${reason}`);
+		}
+	}
+	function markMessageProcessingStart() {
+		wsCallbackActive = true;
+		refreshProcessingActive("ws-start");
 	}
+	function markMessageProcessingEnd() {
+		wsCallbackActive = false;
+		refreshProcessingActive("ws-end");
+	}
+	unsubscribeBackgroundWork = onBackgroundWorkCountChange(() => {
+		refreshProcessingActive("bg-count");
+	});
 	/** 计算指数退避延迟（带抖动） */
 	function calculateBackoffDelay(attempt) {
 		const exponentialDelay = BASE_BACKOFF_DELAY * Math.pow(2, attempt);
 		const jitter = Math.random() * 1e3;
 		return Math.min(exponentialDelay + jitter, MAX_BACKOFF_DELAY);
 	}
+	/**
+	* 等待钉钉 Stream 真正可收消息。
+	*
+	* dingtalk-stream 的 client.connect() 在创建 WebSocket 后立刻 resolve，
+	* **不等** socket open，更不等服务端 SYSTEM/REGISTERED。
+	*
+	* 顺序：socket OPEN → SYSTEM topic=REGISTERED（client.registered=true）
+	* 任一步失败均 throw，禁止 OPEN-only 假 ready。
+	*/
+	async function waitForStreamReady(timeoutMs = STREAM_READY_TIMEOUT_MS) {
+		const started = Date.now();
+		if (client.socket?.readyState !== 1) {
+			if (!await new Promise((resolve) => {
+				const socket = client.socket;
+				if (!socket) {
+					resolve(false);
+					return;
+				}
+				if (socket.readyState === 1) {
+					resolve(true);
+					return;
+				}
+				const remain = Math.max(1e3, timeoutMs - (Date.now() - started));
+				let settled = false;
+				const finish = (ok) => {
+					if (settled) return;
+					settled = true;
+					clearTimeout(timer);
+					socket.removeListener?.("open", onOpen);
+					socket.removeListener?.("error", onError);
+					resolve(ok);
+				};
+				const timer = setTimeout(() => finish(false), remain);
+				const onOpen = () => finish(true);
+				const onError = () => finish(false);
+				socket.once("open", onOpen);
+				socket.once("error", onError);
+			})) throw new Error(`WebSocket OPEN 超时（${timeoutMs}ms）`);
+		}
+		if (client.registered === true) {
+			logger.info(`✅ Stream 已就绪（OPEN + REGISTERED），耗时 ${Date.now() - started}ms`);
+			return;
+		}
+		if (await new Promise((resolve) => {
+			const socket = client.socket;
+			if (!socket) {
+				resolve(false);
+				return;
+			}
+			const remain = Math.max(1e3, timeoutMs - (Date.now() - started));
+			let settled = false;
+			const finish = (ok) => {
+				if (settled) return;
+				settled = true;
+				clearTimeout(timer);
+				clearInterval(poll);
+				socket.removeListener?.("message", onMessage);
+				resolve(ok);
+			};
+			const timer = setTimeout(() => finish(false), remain);
+			const onMessage = (data) => {
+				try {
+					const raw = typeof data === "string" ? data : data?.toString?.() ?? String(data);
+					const msg = JSON.parse(raw);
+					if (msg?.type === "SYSTEM" && msg?.headers?.topic === "REGISTERED") {
+						finish(true);
+						return;
+					}
+				} catch {}
+				if (client.registered === true) finish(true);
+			};
+			const poll = setInterval(() => {
+				if (client.registered === true) finish(true);
+			}, 100);
+			socket.on("message", onMessage);
+		}) || client.registered === true) {
+			logger.info(`✅ Stream 已就绪（OPEN + REGISTERED），耗时 ${Date.now() - started}ms`);
+			return;
+		}
+		throw new Error(`SYSTEM/REGISTERED 超时（${timeoutMs}ms）：socket 已 OPEN 但订阅未生效，禁止报 connected`);
+	}
+	/**
+	* connect 之后、wait ready 之前挂上 pong/message/close。
+	* 官方 #566：若在 connect 前 setup，socket 为 undefined，listener 静默 no-op →
+	* pong 无人接 → lastSocketAvailableTime 不刷新 → TIMEOUT 幽灵重连。
+	* 必须在 wait OPEN 之前挂好，否则等待窗内的 pong 也会丢。
+	*/
+	function attachSocketLifecycleListeners() {
+		setupPongListener();
+		setupMessageListener();
+		setupCloseListener();
+	}
+	/**
+	* 单次：connect + 挂 listener + 等 OPEN/REGISTERED。
+	* 失败 throw，不报 connected。
+	*/
+	async function connectAndWaitRegistered() {
+		await client.connect();
+		attachSocketLifecycleListeners();
+		await waitForStreamReady(STREAM_READY_TIMEOUT_MS);
+		if (client.registered !== true) throw new Error("connect 后 client.registered 仍为 false");
+	}
+	/**
+	* 直到 REGISTERED 成功或次数用尽。
+	* 用于初次启动与硬重连：绝不在未订阅时对外 connected=true。
+	*/
+	async function ensureRegisteredConnection(maxAttempts = REGISTERED_CONNECT_MAX_ATTEMPTS) {
+		let lastError;
+		for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+			if (isStopped) throw new Error("连接已停止，中止 REGISTERED 等待");
+			try {
+				if (attempt > 1) {
+					logger.warn(`🔄 REGISTERED 未就绪，强制重连 ${attempt}/${maxAttempts}…`);
+					try {
+						if (client.socket) await client.disconnect();
+					} catch (discErr) {
+						logger.debug(`断开旧连接: ${discErr?.message || discErr}`);
+					}
+					const delay = Math.min(1e3 * attempt, 5e3);
+					await new Promise((r) => setTimeout(r, delay));
+				} else logger.info(`⏳ 建立 Stream 并等待 REGISTERED（单次超时 ${STREAM_READY_TIMEOUT_MS}ms，最多 ${maxAttempts} 次）…`);
+				await connectAndWaitRegistered();
+				noteSocketAlive("registered-ok");
+				connectionEstablishedTime = Date.now();
+				logger.info(`✅ 订阅已生效 registered=true（attempt ${attempt}/${maxAttempts}, socket=${client.socket?.readyState}）`);
+				return;
+			} catch (err) {
+				lastError = err instanceof Error ? err : new Error(String(err));
+				logger.warn(`⚠️ Stream 就绪失败 attempt=${attempt}/${maxAttempts}: ${lastError.message}`);
+			}
+		}
+		throw new Error(`钉钉 Stream 在 ${maxAttempts} 次尝试后仍未 REGISTERED，拒绝假 connected。 最后错误: ${lastError?.message || "unknown"}`);
+	}
 	/** 统一重连函数，带指数退避（无限重连） */
 	async function doReconnect(immediate = false) {
 		if (isReconnecting || isStopped) {
@@ -125,45 +318,19 @@ async function monitorSingleAccount(opts) {
 				await client.disconnect();
 				logger.info(`已断开旧连接`);
 			}
-			await client.connect();
-			if (!await new Promise((resolve) => {
-				const timeout = setTimeout(() => {
-					resolve(false);
-				}, 1e4);
-				if (client.socket?.readyState === 1) {
-					clearTimeout(timeout);
-					resolve(true);
-					return;
-				}
-				const onOpen = () => {
-					clearTimeout(timeout);
-					client.socket?.removeListener("open", onOpen);
-					client.socket?.removeListener("error", onError);
-					resolve(true);
-				};
-				const onError = (err) => {
-					clearTimeout(timeout);
-					client.socket?.removeListener("open", onOpen);
-					client.socket?.removeListener("error", onError);
-					logger.warn(`连接建立失败: ${err.message}`);
-					resolve(false);
-				};
-				client.socket?.once("open", onOpen);
-				client.socket?.once("error", onError);
-			})) throw new Error(`连接建立超时或失败`);
-			lastSocketAvailableTime = Date.now();
+			await ensureRegisteredConnection(REGISTERED_CONNECT_MAX_ATTEMPTS);
+			noteSocketAlive("reconnect-ok");
 			connectionEstablishedTime = Date.now();
 			reconnectAttempts = 0;
+			lastHardReconnectAt = Date.now();
 			onStatusChange?.({
 				connected: true,
 				lastConnectedAt: Date.now()
 			});
-			setupPongListener();
-			setupMessageListener();
-			setupCloseListener();
-			logger.info(`✅ 重连成功 (socket 状态=${client.socket?.readyState})`);
+			logger.info(`✅ 重连成功 (socket=${client.socket?.readyState}, registered=${Boolean(client.registered)})`);
 		} catch (err) {
 			reconnectAttempts++;
+			onStatusChange?.({ connected: false });
 			logger.error(`重连失败：${err.message} (尝试 ${reconnectAttempts})`);
 			throw err;
 		} finally {
@@ -174,9 +341,15 @@ async function monitorSingleAccount(opts) {
 	function setupPongListener() {
 		client.socket?.on("pong", () => {
 			lastSocketAvailableTime = Date.now();
+			consecutiveStaleMisses = 0;
 			logger.debug(`收到 PONG 响应`);
 		});
 	}
+	function noteSocketAlive(reason) {
+		lastSocketAvailableTime = Date.now();
+		consecutiveStaleMisses = 0;
+		logger.debug(`socket alive reason=${reason}`);
+	}
 	/** 监听 WebSocket message 事件，收到 disconnect 消息时立即触发重连 */
 	function setupMessageListener() {
 		client.socket?.on("message", (data) => {
@@ -204,12 +377,41 @@ async function monitorSingleAccount(opts) {
 		});
 	}
 	/**
-	* 启动 keepAlive 机制（单定时器 + 指数退避）
-	*
-	* 业界最佳实践：
-	* - 单定时器：每 10 秒检查一次，同时完成心跳和超时检测
-	* - 使用 WebSocket 原生 Ping
-	* - 指数退避重连：避免雪崩效应
+	* 请求硬重连（拆 socket）。
+	* - socket 仍 OPEN：先补 PING，连续 misses 未达阈值则绝不拆连接（防空窗吞消息）
+	* - socket 已死：立即重连
+	* - 冷却：非死连接时距上次硬重连 < MIN_RECONNECT_GAP_MS 则跳过
+	*/
+	async function requestHardReconnect(reason, socketDead = false) {
+		if (isReconnecting || isStopped) return;
+		const socketState = client.socket?.readyState;
+		if (!socketDead && socketState === 1) {
+			try {
+				client.socket?.ping();
+				logger.warn(`⚠️ 软超时但 socket 仍 OPEN (reason=${reason}, misses=${consecutiveStaleMisses}/${HARD_RECONNECT_AFTER_MISSES})，仅补 PING`);
+			} catch (err) {
+				logger.warn(`补 PING 失败: ${err.message}`);
+				consecutiveStaleMisses += 1;
+			}
+			if (consecutiveStaleMisses < HARD_RECONNECT_AFTER_MISSES) return;
+		}
+		if (!socketDead) {
+			const gap = Date.now() - lastHardReconnectAt;
+			if (lastHardReconnectAt > 0 && gap < MIN_RECONNECT_GAP_MS) {
+				logger.warn(`⚠️ 跳过硬重连：距上次仅 ${Math.round(gap / 1e3)}s < ${MIN_RECONNECT_GAP_MS / 1e3}s 冷却 (reason=${reason})`);
+				return;
+			}
+		}
+		lastHardReconnectAt = Date.now();
+		consecutiveStaleMisses = 0;
+		logger.info(`🔄 硬重连 reason=${reason} socket=${socketState}`);
+		await doReconnect(socketDead);
+	}
+	/**
+	* 启动 keepAlive：
+	* - 10s 发 ping；pong 刷新 lastSocketAvailableTime
+	* - 软超时只计数 + 补 ping，达到 HARD_RECONNECT_AFTER_MISSES 且 socket 异常才拆连接
+	* - 处理中任务期间绝不硬重连
 	*/
 	function startKeepAlive() {
 		logger.debug(`🚀 启动 keepAlive 定时器，间隔=${HEARTBEAT_INTERVAL / 1e3}秒`);
@@ -220,28 +422,40 @@ async function monitorSingleAccount(opts) {
 			}
 			try {
 				const elapsed = Date.now() - lastSocketAvailableTime;
-				if (elapsed > TIMEOUT_THRESHOLD) {
-					logger.info(`⚠️ 超时检测：已 ${Math.round(elapsed / 1e3)} 秒未确认 socket 可用，触发重连...`);
-					await doReconnect();
-					return;
-				}
 				const socketState = client.socket?.readyState;
 				const timeSinceConnection = Date.now() - connectionEstablishedTime;
-				logger.debug(`心跳检测：socket 状态=${socketState}, elapsed=${Math.round(elapsed / 1e3)}s, 连接已建立=${Math.round(timeSinceConnection / 1e3)}s`);
+				logger.debug(`心跳检测：socket=${socketState}, elapsed=${Math.round(elapsed / 1e3)}s, misses=${consecutiveStaleMisses}, processing=${activeMessageProcessing}, connectedFor=${Math.round(timeSinceConnection / 1e3)}s`);
 				if (socketState !== 1) {
 					if (timeSinceConnection < 15e3) {
 						logger.debug(`⏳ 连接建立中（已 ${Math.round(timeSinceConnection / 1e3)}s），跳过状态检查`);
 						return;
 					}
-					logger.info(`⚠️ 心跳检测：socket 状态=${socketState}，触发重连...`);
-					await doReconnect(true);
+					if (activeMessageProcessing) {
+						logger.warn(`⚠️ socket 非 OPEN 但消息处理中，暂缓硬重连 state=${socketState}`);
+						return;
+					}
+					await requestHardReconnect(`socket-dead state=${socketState}`, true);
 					return;
 				}
+				if (elapsed > SOFT_STALE_MS) {
+					consecutiveStaleMisses += 1;
+					if (activeMessageProcessing) {
+						noteSocketAlive("processing-hold");
+						logger.warn(`⚠️ 软超时但处理中，刷新活跃时间不重连 (elapsed=${Math.round(elapsed / 1e3)}s)`);
+						return;
+					}
+					logger.warn(`⚠️ 软超时 misses=${consecutiveStaleMisses}/${HARD_RECONNECT_AFTER_MISSES} elapsed=${Math.round(elapsed / 1e3)}s socket=OPEN`);
+					await requestHardReconnect("stale-pong", false);
+					return;
+				}
+				consecutiveStaleMisses = 0;
 				try {
 					client.socket?.ping();
 					logger.debug(`💓 发送 PING 心跳成功`);
 				} catch (err) {
 					logger.warn(`发送 PING 失败：${err.message}`);
+					consecutiveStaleMisses += 1;
+					if (consecutiveStaleMisses >= HARD_RECONNECT_AFTER_MISSES) await requestHardReconnect("ping-failed", true);
 				}
 			} catch (err) {
 				logger.error(`keepAlive 检测失败：${err.message}`);
@@ -259,10 +473,11 @@ async function monitorSingleAccount(opts) {
 		isStopped = true;
 		if (keepAliveTimer) clearInterval(keepAliveTimer);
 		keepAliveTimer = null;
-		if (messageProcessingKeepAliveTimer) {
-			clearInterval(messageProcessingKeepAliveTimer);
-			messageProcessingKeepAliveTimer = null;
-		}
+		clearProcessingKeepAliveTimer();
+		wsCallbackActive = false;
+		activeMessageProcessing = false;
+		unsubscribeBackgroundWork?.();
+		unsubscribeBackgroundWork = null;
 		if (client.socket) client.socket.removeAllListeners();
 		logger.debug(`Connection 已停止`);
 	}
@@ -290,6 +505,7 @@ async function monitorSingleAccount(opts) {
 		client.registerCallbackListener(TOPIC_ROBOT, async (res) => {
 			receivedCount++;
 			lastMessageTime = Date.now();
+			noteSocketAlive("inbound-callback");
 			onStatusChange?.({ lastInboundAt: Date.now() });
 			const messageId = res.headers?.messageId;
 			const timestamp = (/* @__PURE__ */ new Date()).toISOString();
@@ -298,16 +514,17 @@ async function monitorSingleAccount(opts) {
 			logger.info(`MessageId: ${messageId || "N/A"}`);
 			logger.info(`Headers: ${JSON.stringify(res.headers || {})}`);
 			logger.info(`Data 长度：${res.data?.length || 0} 字符`);
-			if (messageId) {
-				client.socketCallBackResponse(messageId, { success: true });
-				logger.info(`✅ 已立即确认回调：messageId=${messageId}`);
-			} else logger.warn(`⚠️ 警告：消息没有 messageId`);
-			if (messageId && checkAndMarkDingtalkMessage(accountId, messageId, void 0)) {
-				processedCount++;
-				logger.warn(`⚠️ 检测到重复消息（协议层），跳过处理：messageId=${messageId} (${processedCount}/${receivedCount})`);
-				logger.info(`========== 消息处理结束（重复） ==========\n`);
-				return;
-			}
+			let acked = false;
+			const ackMessage = (why) => {
+				if (acked || !messageId) return;
+				try {
+					client.socketCallBackResponse(messageId, { success: true });
+					acked = true;
+					logger.info(`✅ 已确认回调 messageId=${messageId} (${why})`);
+				} catch (ackErr) {
+					logger.warn(`确认回调失败: ${ackErr?.message || ackErr}`);
+				}
+			};
 			markMessageProcessingStart();
 			try {
 				let data;
@@ -330,7 +547,14 @@ async function monitorSingleAccount(opts) {
 				logger.info(`SessionWebhook: ${data.sessionWebhook ? "已提供" : "未提供"}`);
 				logger.info(`RobotCode: ${data.robotCode || account.config?.clientId || "N/A"}`);
 				if (data.chatbotUserId || data.chatbotCorpId) console.log(`[DingTalk:${accountId}] [BotIdentity] accountId=${accountId} chatbotUserId=${data.chatbotUserId || "N/A"} chatbotCorpId=${data.chatbotCorpId || "N/A"}`);
-				data.msgId;
+				const businessMsgId = data.msgId;
+				if (checkAndMarkDingtalkMessage(accountId, messageId, businessMsgId)) {
+					processedCount++;
+					ackMessage("duplicate");
+					logger.warn(`⚠️ 检测到重复消息，跳过：protocol=${messageId || "-"} business=${businessMsgId || "-"} (${processedCount}/${receivedCount})`);
+					logger.info(`========== 消息处理结束（重复） ==========\n`);
+					return;
+				}
 				let contentPreview = "N/A";
 				if (data.text?.content) contentPreview = data.text.content.length > 100 ? data.text.content.substring(0, 100) + "..." : data.text.content;
 				else if (data.content) contentPreview = JSON.stringify(data.content).substring(0, 100) + "...";
@@ -347,6 +571,8 @@ async function monitorSingleAccount(opts) {
 					log,
 					cfg: clawdbotConfig
 				});
+				ackMessage("enqueued");
+				noteSocketAlive("after-enqueue");
 				processedCount++;
 				logger.info(`✅ 消息处理完成 (${processedCount}/${receivedCount})`);
 				logger.info(`========== 消息处理结束（成功） ==========\n`);
@@ -356,6 +582,7 @@ async function monitorSingleAccount(opts) {
 				const errorStack = error?.stack || "无堆栈信息";
 				logger.error(errorMsg);
 				logger.error(`错误堆栈:\n${errorStack}`);
+				if (!acked) logger.warn(`⚠️ 未 ACK messageId=${messageId || "N/A"}，等待钉钉重投（避免网关永久丢消息）`);
 				logger.info(`========== 消息处理结束（失败） ==========\n`);
 			} finally {
 				markMessageProcessingEnd();
@@ -366,13 +593,13 @@ async function monitorSingleAccount(opts) {
 			stop();
 		};
 		try {
-			await client.connect();
-			setupPongListener();
-			setupMessageListener();
-			setupCloseListener();
+			await ensureRegisteredConnection(REGISTERED_CONNECT_MAX_ATTEMPTS);
+			noteSocketAlive("initial-ready");
+			connectionEstablishedTime = Date.now();
 			logger.info(`Connected to DingTalk Stream successfully`);
 			logger.info(`PID: ${process.pid}`);
-			logger.info(`✅ 自定义 keepAlive: true (10 秒心跳，90 秒超时), 指数退避重连`);
+			logger.info(`✅ keepAlive: 心跳 ${HEARTBEAT_INTERVAL / 1e3}s / 软超时 ${SOFT_STALE_MS / 1e3}s×${HARD_RECONNECT_AFTER_MISSES} / 处理中刷新 ${MESSAGE_PROCESSING_KEEPALIVE_MS / 1e3}s / 重连冷却 ${MIN_RECONNECT_GAP_MS / 1e3}s, registered=${Boolean(client.registered)}`);
+			printConnectionNoticeOnce();
 			onStatusChange?.({
 				connected: true,
 				lastConnectedAt: Date.now()

package/dist/entry-bundled.mjs

@@ -23,7 +23,7 @@ var entry_bundled_default = defineBundledChannelEntry({
 		exportName: "setDingtalkRuntime"
 	},
 	async registerFull(api) {
-		const { registerGatewayMethods } = await import("./gateway-methods-BQd4E0Sk.mjs");
+		const { registerGatewayMethods } = await import("./gateway-methods-BkI1gKaC.mjs");
 		registerGatewayMethods(api);
 	}
 });

package/dist/gateway-methods-BkI1gKaC.mjs

@@ -0,0 +1,2 @@
+import { t as registerGatewayMethods } from "./gateway-methods-kNX3qvqw.mjs";
+export { registerGatewayMethods };

package/dist/{gateway-methods--aKsyMs-.mjs → gateway-methods-kNX3qvqw.mjs}

@@ -1,7 +1,7 @@
 import { a as resolveDingtalkAccount, t as listDingtalkAccountIds } from "./accounts-BAzdqkAV.mjs";
 import { t as dingtalkHttp } from "./http-client-DFWZgO1n.mjs";
 import { r as getAccessToken, t as DINGTALK_API } from "./utils-CIfI_3Jh.mjs";
-import { c as prepareMultiBotMentions, d as finishAICard, i as sendProactive, s as buildBotMentionTable } from "./messaging-WleKf54h.mjs";
+import { c as prepareMultiBotMentions, d as finishAICard, i as sendProactive, s as buildBotMentionTable } from "./messaging-DVS3UKOp.mjs";
 import { d as getUnionId, h as recallEmotionReply } from "./utils-legacy-DQ3HeGHh.mjs";
 //#region src/docs.ts
 var DingtalkDocsClient = class {

package/dist/index.mjs

@@ -1,5 +1,5 @@
-import { a as initDingtalkPluginConfigSchema, i as dingtalkPlugin, n as setDingtalkRuntime } from "./runtime-DzZo6Gvk.mjs";
-import { t as registerGatewayMethods } from "./gateway-methods--aKsyMs-.mjs";
+import { a as initDingtalkPluginConfigSchema, i as dingtalkPlugin, n as setDingtalkRuntime } from "./runtime-A6G7WAWn.mjs";
+import { t as registerGatewayMethods } from "./gateway-methods-kNX3qvqw.mjs";
 //#region index.ts
 /**
 * 检测同一 plugin id 在多个路径被加载的情况。