@jeik/dingtalk-connector 0.8.27 → 0.8.29

package/dist/connection-obtrPkj4.mjs

@@ -0,0 +1,641 @@
+import { i as checkAndMarkDingtalkMessage } from "./utils-legacy-DQ3HeGHh.mjs";
+import { n as onBackgroundWorkCountChange, t as getActiveBackgroundWorkCount } from "./background-work-DkaSDqWk.mjs";
+import * as fs from "fs";
+//#region src/core/connection.ts
+/**
+* 钉钉 WebSocket 连接层
+*
+* 职责：
+* - 管理单个钉钉账号的 WebSocket 连接
+* - 实现应用层心跳检测（10 秒间隔，20 秒无 pong 超时）
+* - 处理连接重连逻辑，带指数退避
+* - 消息去重（内置 Map，5 分钟 TTL）
+*
+* 核心特性：
+* - 关闭 SDK 内置 keepAlive，使用自定义心跳
+* - connect 后等 OPEN + SYSTEM/REGISTERED 再报 ready（防首条消息丢失）
+* - 重连后先挂 pong/message/close listener 再等就绪（防幽灵重连）
+* - 详细的消息接收日志（三阶段：接收、解析、处理）
+* - 连接统计和监控（每分钟输出）
+*/
+/** 心跳间隔（毫秒） */
+const HEARTBEAT_INTERVAL = 10 * 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 尽量等待；若环境不推 REGISTERED，首条消息会确认订阅。正常运行不应出现 ≤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, setDingtalkDebug } = await import("./logger-D8H2IcYz.mjs");
+	if (account.config?.debug) setDingtalkDebug(true);
+	const logger = createLoggerFromConfig(account.config, `DingTalk:${accountId}`);
+	if (!account.clientId || !account.clientSecret) throw new Error(`[DingTalk][${accountId}] Missing credentials: clientId=${account.clientId ? "present" : "MISSING"}, clientSecret=${account.clientSecret ? "present" : "MISSING"}. Please check your configuration in channels.dingtalk-connector.`);
+	const clientIdStr = String(account.clientId);
+	const clientSecretStr = String(account.clientSecret);
+	if (clientIdStr.length < 10 || clientSecretStr.length < 10) throw new Error(`[DingTalk][${accountId}] Invalid credentials format: clientId length=${clientIdStr.length}, clientSecret length=${clientSecretStr.length}. Credentials appear to be too short or invalid.`);
+	if (process.platform === "darwin") for (const stdioFd of [
+		0,
+		1,
+		2
+	]) try {
+		fs.fstatSync(stdioFd);
+	} catch (fdError) {
+		if (fdError.code === "EBADF") {
+			logger.warn(`[LaunchAgent] 检测到 fd ${stdioFd} 无效（EBADF），重定向到 /dev/null 以防止 TCP socket 创建失败`);
+			try {
+				fs.openSync("/dev/null", stdioFd === 0 ? "r" : "w");
+			} catch (openError) {
+				logger.warn(`[LaunchAgent] 无法修复 fd ${stdioFd}: ${openError.message}`);
+			}
+		}
+	}
+	logger.info(`Starting DingTalk Stream client...`);
+	logger.info(`Initializing with clientId: ${clientIdStr.substring(0, 8)}...`);
+	logger.info(`WebSocket keepAlive: false (using application-layer heartbeat)`);
+	const dingtalkStreamModule = await import("dingtalk-stream");
+	const DWClient = dingtalkStreamModule.DWClient;
+	const { TOPIC_ROBOT } = dingtalkStreamModule;
+	if (!DWClient) throw new Error("Failed to import DWClient from dingtalk-stream module");
+	const client = new DWClient({
+		clientId: account.clientId,
+		clientSecret: account.clientSecret,
+		debug: account.config.debug,
+		endpoint: account.config.endpoint || "https://api.dingtalk.com",
+		autoReconnect: false,
+		keepAlive: false
+	});
+	let lastSocketAvailableTime = Date.now();
+	let connectionEstablishedTime = Date.now();
+	let isReconnecting = false;
+	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;
+	let unsubscribeBackgroundWork = null;
+	function ensureProcessingKeepAliveTimer() {
+		if (messageProcessingKeepAliveTimer) return;
+		messageProcessingKeepAliveTimer = setInterval(() => {
+			if (activeMessageProcessing) {
+				lastSocketAvailableTime = Date.now();
+				logger.debug(`📝 消息处理中，更新 socket 可用时间 (ws=${wsCallbackActive} bg=${getActiveBackgroundWorkCount()})`);
+			}
+		}, MESSAGE_PROCESSING_KEEPALIVE_MS);
+	}
+	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();
+		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 可服务。
+	*
+	* - OPEN：必须成功，否则 throw
+	* - REGISTERED：尽量等待；超时则 **降级 OPEN 上线**（不 throw）
+	*
+	* 原因（生产日志）：部分环境 socket 已 OPEN 且 CALLBACK 能收消息，
+	* 但长期收不到 SYSTEM/REGISTERED 或 client.registered 不被置 true。
+	* 若硬性失败会触发网关 auto-restart 风暴，而旧连接/半连接其实仍在处理消息。
+	*/
+	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 { registered: true };
+		}
+		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 { registered: true };
+		}
+		logger.warn(`⚠️ 未观察到 SYSTEM/REGISTERED（${timeoutMs}ms），socket 已 OPEN → 降级上线。 收到首条机器人消息后会记为「订阅 empirically 生效」。`);
+		return { registered: false };
+	}
+	/**
+	* 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 可选）。
+	* 仅 OPEN 失败 throw；REGISTERED 超时则降级成功。
+	*/
+	async function connectAndWaitReady() {
+		await client.connect();
+		attachSocketLifecycleListeners();
+		return await waitForStreamReady(STREAM_READY_TIMEOUT_MS);
+	}
+	/**
+	* 建立可服务连接。
+	* - 优先拿到 REGISTERED
+	* - OPEN 成功即可上线（避免环境不推 REGISTERED 时 restart 风暴）
+	* - 仅在 OPEN 都失败时多轮重试
+	*/
+	async function ensureRegisteredConnection(maxAttempts = REGISTERED_CONNECT_MAX_ATTEMPTS) {
+		let lastError;
+		for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+			if (isStopped) throw new Error("连接已停止，中止 Stream 建立");
+			try {
+				if (attempt > 1) {
+					logger.warn(`🔄 Stream 建立重试 ${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（OPEN 必须；REGISTERED 尽量等待 ${STREAM_READY_TIMEOUT_MS}ms）…`);
+				const ready = await connectAndWaitReady();
+				noteSocketAlive(ready.registered ? "registered-ok" : "open-degraded");
+				connectionEstablishedTime = Date.now();
+				logger.info(`✅ Stream 可服务（attempt ${attempt}/${maxAttempts}, registered=${ready.registered || Boolean(client.registered)}, 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} 次尝试后仍无法 OPEN。 最后错误: ${lastError?.message || "unknown"}`);
+	}
+	/** 统一重连函数，带指数退避（无限重连） */
+	async function doReconnect(immediate = false) {
+		if (isReconnecting || isStopped) {
+			logger.debug(`正在重连中或已停止，跳过`);
+			return;
+		}
+		isReconnecting = true;
+		if (!immediate && reconnectAttempts > 0) {
+			const delay = calculateBackoffDelay(reconnectAttempts);
+			logger.info(`⏳ 等待 ${Math.round(delay / 1e3)} 秒后重连 (尝试 ${reconnectAttempts + 1})`);
+			await new Promise((resolve) => setTimeout(resolve, delay));
+		}
+		try {
+			if (client.socket?.readyState === 1 || client.socket?.readyState === 3) {
+				await client.disconnect();
+				logger.info(`已断开旧连接`);
+			}
+			await ensureRegisteredConnection(REGISTERED_CONNECT_MAX_ATTEMPTS);
+			noteSocketAlive("reconnect-ok");
+			connectionEstablishedTime = Date.now();
+			reconnectAttempts = 0;
+			lastHardReconnectAt = Date.now();
+			onStatusChange?.({
+				connected: true,
+				lastConnectedAt: Date.now()
+			});
+			logger.info(`✅ 重连成功 (socket=${client.socket?.readyState}, registered=${Boolean(client.registered)})`);
+		} catch (err) {
+			reconnectAttempts++;
+			onStatusChange?.({ connected: false });
+			logger.error(`重连失败：${err.message} (尝试 ${reconnectAttempts})`);
+			throw err;
+		} finally {
+			isReconnecting = false;
+		}
+	}
+	/** 监听 pong 响应（更新 socket 可用时间） */
+	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) => {
+			try {
+				const msg = JSON.parse(data);
+				if (msg.type === "SYSTEM" && msg.headers?.topic === "disconnect") {
+					if (!isStopped && !isReconnecting) doReconnect(true).catch((err) => {
+						logger.error(`[${accountId}] 重连失败：${err.message}`);
+					});
+				}
+			} catch (e) {}
+		});
+	}
+	/** 监听 WebSocket close 事件，服务端主动断开时立即触发重连 */
+	function setupCloseListener() {
+		client.socket?.on("close", (code, reason) => {
+			logger.info(`WebSocket close: code=${code}, reason=${reason || "未知"}, isStopped=${isStopped}`);
+			onStatusChange?.({ connected: false });
+			if (isStopped) return;
+			setTimeout(() => {
+				doReconnect(true).catch((err) => {
+					logger.error(`重连失败：${err.message}`);
+				});
+			}, 0);
+		});
+	}
+	/**
+	* 请求硬重连（拆 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}秒`);
+		keepAliveTimer = setInterval(async () => {
+			if (isStopped) {
+				if (keepAliveTimer) clearInterval(keepAliveTimer);
+				return;
+			}
+			try {
+				const elapsed = Date.now() - lastSocketAvailableTime;
+				const socketState = client.socket?.readyState;
+				const timeSinceConnection = Date.now() - connectionEstablishedTime;
+				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;
+					}
+					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}`);
+			}
+		}, HEARTBEAT_INTERVAL);
+		logger.debug(`✅ keepAlive 定时器已启动`);
+		return () => {
+			if (keepAliveTimer) clearInterval(keepAliveTimer);
+			keepAliveTimer = null;
+			logger.debug(`keepAlive 定时器已清理`);
+		};
+	}
+	/** 停止并清理所有资源 */
+	function stop() {
+		isStopped = true;
+		if (keepAliveTimer) clearInterval(keepAliveTimer);
+		keepAliveTimer = null;
+		clearProcessingKeepAliveTimer();
+		wsCallbackActive = false;
+		activeMessageProcessing = false;
+		unsubscribeBackgroundWork?.();
+		unsubscribeBackgroundWork = null;
+		if (client.socket) client.socket.removeAllListeners();
+		logger.debug(`Connection 已停止`);
+	}
+	return new Promise(async (resolve, reject) => {
+		if (abortSignal) {
+			const onAbort = async () => {
+				logger.info(`Abort signal received, stopping...`);
+				stop();
+				try {
+					if (client.socket && client.socket.readyState === 1) await client.disconnect();
+				} catch (err) {
+					logger.warn(`断开连接时出错：${err.message}`);
+				}
+				resolve();
+			};
+			abortSignal.addEventListener("abort", onAbort, { once: true });
+		}
+		let receivedCount = 0;
+		let processedCount = 0;
+		let lastMessageTime = Date.now();
+		const statsInterval = setInterval(() => {
+			const timeSinceLastMessage = Math.round((Date.now() - lastMessageTime) / 1e3);
+			logger.info(`统计：收到=${receivedCount}, 处理=${processedCount}, 丢失=${receivedCount - processedCount}, 距上次消息=${timeSinceLastMessage}s`);
+		}, 6e4);
+		client.registerCallbackListener(TOPIC_ROBOT, async (res) => {
+			receivedCount++;
+			lastMessageTime = Date.now();
+			noteSocketAlive("inbound-callback");
+			if (client.registered !== true) {
+				client.registered = true;
+				logger.info(`✅ 收到机器人 CALLBACK，视为订阅已生效（此前可能未观察到 SYSTEM/REGISTERED）`);
+			}
+			onStatusChange?.({ lastInboundAt: Date.now() });
+			const messageId = res.headers?.messageId;
+			let acked = false;
+			const ackMessage = (why) => {
+				if (acked || !messageId) return;
+				try {
+					client.socketCallBackResponse(messageId, { success: true });
+					acked = true;
+					logger.debug(`ACK messageId=${messageId} (${why})`);
+				} catch (ackErr) {
+					logger.warn(`确认回调失败: ${ackErr?.message || ackErr}`);
+				}
+			};
+			markMessageProcessingStart();
+			try {
+				let data;
+				try {
+					data = JSON.parse(res.data);
+				} catch (parseError) {
+					logger.error(`JSON 解析失败: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
+					throw new Error(`Invalid JSON from DingTalk: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
+				}
+				const businessMsgId = data.msgId;
+				const convType = data.conversationType === "1" ? "DM" : data.conversationType === "2" ? "Group" : String(data.conversationType ?? "?");
+				const preview = (data.text?.content || "").trim().slice(0, 80) || data.msgtype || "(no text)";
+				logger.info(`📩 入站 ${convType} from=${data.senderNick || data.senderStaffId || data.senderId || "?"} msg=${businessMsgId || messageId || "-"} preview=${JSON.stringify(preview)}`);
+				logger.debug(`Headers: ${JSON.stringify(res.headers || {})}`);
+				logger.debug(`字段: ${Object.keys(data).join(",")}`);
+				if (data.chatbotUserId || data.chatbotCorpId) {
+					const key = `${accountId}:${data.chatbotUserId || ""}:${data.chatbotCorpId || ""}`;
+					if (!globalThis.__dingtalkBotIdentityLogged) globalThis.__dingtalkBotIdentityLogged = /* @__PURE__ */ new Set();
+					const seen = globalThis.__dingtalkBotIdentityLogged;
+					if (!seen.has(key)) {
+						seen.add(key);
+						console.log(`[DingTalk:${accountId}] [BotIdentity] chatbotUserId=${data.chatbotUserId || "N/A"} chatbotCorpId=${data.chatbotCorpId || "N/A"}`);
+					}
+				}
+				if (checkAndMarkDingtalkMessage(accountId, messageId, businessMsgId)) {
+					processedCount++;
+					ackMessage("duplicate");
+					logger.warn(`⚠️ 重复消息已跳过 protocol=${messageId || "-"} business=${businessMsgId || "-"}`);
+					return;
+				}
+				await messageHandler({
+					accountId,
+					config: account.config,
+					data,
+					sessionWebhook: data.sessionWebhook,
+					runtime,
+					log,
+					cfg: clawdbotConfig
+				});
+				ackMessage("enqueued");
+				noteSocketAlive("after-enqueue");
+				processedCount++;
+				logger.info(`✅ 入队完成 (${processedCount}/${receivedCount})`);
+			} catch (error) {
+				processedCount++;
+				logger.error(`❌ 入站处理失败 (${processedCount}/${receivedCount}): ${error?.message || "未知错误"}`);
+				if (error?.stack) logger.debug(error.stack);
+				if (!acked) logger.warn(`⚠️ 未 ACK messageId=${messageId || "N/A"}，等待钉钉重投`);
+			} finally {
+				markMessageProcessingEnd();
+			}
+		});
+		const cleanup = () => {
+			clearInterval(statsInterval);
+			stop();
+		};
+		try {
+			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: 心跳 ${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()
+			});
+			const cleanupKeepAlive = startKeepAlive();
+			const enhancedCleanup = () => {
+				cleanupKeepAlive();
+				clearInterval(statsInterval);
+				stop();
+			};
+			process.once("exit", enhancedCleanup);
+			process.once("SIGINT", enhancedCleanup);
+			process.once("SIGTERM", enhancedCleanup);
+		} catch (error) {
+			cleanup();
+			logger.info(`连接失败，错误详情：`);
+			logger.info(`  - error.message: ${error.message}`);
+			logger.info(`  - error.response?.status: ${error.response?.status}`);
+			logger.info(`  - error.response?.data: ${JSON.stringify(error.response?.data || {})}`);
+			logger.info(`  - error.code: ${error.code}`);
+			logger.info(`  - error.stack: ${error.stack?.split("\n").slice(0, 3).join("\n")}`);
+			if (error.response?.status === 400 || error.message?.includes("status code 400") || error.message?.includes("400")) {
+				reject(/* @__PURE__ */ new Error(`[DingTalk][${accountId}] Bad Request (400):\n  - clientId or clientSecret format is invalid\n  - clientId: ${clientIdStr} (type: ${typeof account.clientId}, length: ${clientIdStr.length})\n  - clientSecret: ****** (type: ${typeof account.clientSecret}, length: ${clientSecretStr.length})\n  - Common issues:\n    1. clientId/clientSecret must be strings, not numbers\n    2. Remove any quotes or special characters\n    3. Ensure credentials are from the correct DingTalk app\n    4. Check if clientId starts with 'ding' prefix\n  - Error details: ${error.message}\n  - Response data: ${JSON.stringify(error.response?.data || {})}`));
+				return;
+			}
+			if (error.response?.status === 401 || error.message?.includes("401")) {
+				reject(/* @__PURE__ */ new Error(`[DingTalk][${accountId}] Authentication failed (401 Unauthorized):\n  - Your clientId or clientSecret is invalid, expired, or revoked\n  - clientId: ${clientIdStr.substring(0, 8)}...\n  - Please verify your credentials at DingTalk Developer Console\n  - Error details: ${error.message}`));
+				return;
+			}
+			reject(/* @__PURE__ */ new Error(`[DingTalk][${accountId}] Failed to connect to DingTalk Stream: ${error.message}`));
+			return;
+		}
+		client.on("error", (err) => {
+			logger.error(`Connection error: ${err.message}`);
+		});
+		client.on("reconnect", () => {
+			logger.info(`SDK reconnecting...`);
+		});
+		client.on("reconnected", () => {
+			logger.info(`✅ SDK reconnected successfully`);
+		});
+	});
+}
+function resolveReactionSyntheticEvent(event) {
+	return null;
+}
+//#endregion
+export { monitorSingleAccount, resolveReactionSyntheticEvent };

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-DQ6TwOAr.mjs");
 		registerGatewayMethods(api);
 	}
 });

package/dist/{gateway-methods--aKsyMs-.mjs → gateway-methods-BdcpfxEZ.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-CK0Wz3Ze.mjs";
 import { d as getUnionId, h as recallEmotionReply } from "./utils-legacy-DQ3HeGHh.mjs";
 //#region src/docs.ts
 var DingtalkDocsClient = class {

package/dist/gateway-methods-DQ6TwOAr.mjs

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

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-DbqGRyhI.mjs";
+import { t as registerGatewayMethods } from "./gateway-methods-BdcpfxEZ.mjs";
 //#region index.ts
 /**
 * 检测同一 plugin id 在多个路径被加载的情况。