@jeik/dingtalk-connector 0.8.28 → 0.8.30

package/README.md

@@ -4,7 +4,7 @@
   <p>基于官方最新 <strong>v0.8.24</strong> 的社区增强版：吸收官方长连接改进，并重点优化消息接收、排队反馈与模型错误展示。<br/>
   保留社区在图片、答案卡、首响体验上的增强，持续修官方暂未覆盖的实际使用问题。</p>
 
-  <p><strong>当前发布版：<a href="https://www.npmjs.com/package/@jeik/dingtalk-connector">@jeik/dingtalk-connector</a> v0.8.28</strong>（推荐生产；一键安装：`npx -y @jeik/dingtalk-connector@0.8.28 install --force`）</p>
+  <p><strong>当前正式版：<a href="https://www.npmjs.com/package/@jeik/dingtalk-connector">@jeik/dingtalk-connector</a> v0.8.30</strong></p>
 
   <p>
     <a href="https://www.npmjs.com/package/@jeik/dingtalk-connector"><img src="https://img.shields.io/npm/v/@jeik/dingtalk-connector.svg?style=flat&colorA=18181B&colorB=28CF8D" alt="npm version" /></a>
@@ -23,87 +23,89 @@
 
 ## 🔧 最近更新
 
-### 🚀 v0.8.28 · 2026-07-25（当前正式版）
+### 🚀 v0.8.30 · 2026-07-29（当前正式版）
 
-**主题：基于官方 0.8.24 · 长连接更稳 · 消息少丢 · 错误提示更清楚**
+**主题：正式加固 · 日志更干净 · 排障只开 debug**
 
-本版在社区增强能力之上，对齐官方 **0.8.24** 的连接改进，并重点打磨「发了消息却没反应」「错误卡卡住」「排队提示不出现」等真实使用体验。
+在 **0.8.28**（连接更稳 / 消息少丢 / 错误卡可定稿）基础上再打磨：
 
-#### 基于官方 0.8.24 吸收了什么
+| 体验 | 效果 |
+|------|------|
+| 🧹 **默认日志更轻** | 无图正常回复不再刷 LocalImage / MediaIdTrace / CardCache |
+| 🔍 **排障更简单** | 配置 `"debug": true` 即输出连接、图片、引用、队列详细日志（无需环境变量） |
+| 🔗 **连接 / 队列** | 继承 0.8.28：能收消息才算在线；连发、错误后再发更稳；排队反馈更及时 |
+| ⚠️ **模型故障** | 503 / 欠费 / 无通道等更容易定格中文错误，少卡「正在召唤大模型」 |
+| 🃏 **本仓库独有** | 答案卡、图片全路径、首响体验等继续保留 |
 
-- 更稳妥的长连接建立与保活方式，减少假死、误重连
-- 机器人处理长任务时连接不易被中途掐断
-- 控制台少刷无用日志，排障更清爽
+### 📦 v0.8.28 · 2026-07-25
 
-#### 社区本版额外优化（你会感受到的效果）
+基于官方 0.8.24 的长连接与消息体验加固（当前能力已并入 0.8.30）。
 
-| 体验 | 效果 |
-|------|------|
-| 🔗 **连接更靠谱** | 只有真正能收消息时才显示「已连接」；连不上会自动多试几轮，而不是假装在线 |
-| 📩 **消息更少丢** | 明显缓解：连发多条、错误回复后、任务刚结束时「发了没进网关」的情况 |
-| ⏳ **排队反馈更及时** | 上一条还在处理时再发，更容易马上看到「已排队 / 处理中」和思考中表情 |
-| ⚠️ **模型故障更好懂** | 欠费、无可用线路、503 等失败时，卡片更容易定格成中文说明，少卡在「正在召唤大模型」 |
-| 🃏 **答案卡 / 图片等** | 社区原有大段答案独立卡片、图片全路径修复等能力继续保留 |
+### 📦 v0.8.26 / 0.8.25 及更早
 
-```bash
-npx -y @jeik/dingtalk-connector@0.8.28 install --force && openclaw gateway restart
-```
+目标 ID 约束、发送人身份、答案卡、图片修复等——详见 [CHANGELOG.md](CHANGELOG.md)。
 
-### 📦 v0.8.26 · 2026-07-25
+---
 
-目标 ID 填写约束（保留 `==` 等后缀与大小写）。
+## 🚀 快速开始
 
-### 📦 v0.8.25 · 2026-07-24
+### 要求
 
-发送人岗位与身份信息；裸钉钉 ID 推导为单聊。
+- **OpenClaw** 已安装并正常运行（[官网](https://openclaw.ai/)）
+- **版本**：OpenClaw ≥ **2026.4.9**（`openclaw -v`）
+- 与官方插件同 channel id（`dingtalk-connector`），`--force` 可直接覆盖，**无需先卸载**
+- 安装/更新后**必须** `openclaw gateway restart`
 
-### 📦 v0.8.21-fix49 及更早
+包名：[`@jeik/dingtalk-connector`](https://www.npmjs.com/package/@jeik/dingtalk-connector)
 
-答案卡、图片全路径修复、流式定稿、中文错误映射等——详见 [CHANGELOG.md](CHANGELOG.md)。
+### A）npx 一键扫码安装（按顺序试）
 
-完整说明：[CHANGELOG.md](CHANGELOG.md) · [FIXES.md](FIXES.md)
+```bash
+# 1）装最新
+npx @jeik/dingtalk-connector install --force && openclaw gateway restart
 
----
+# 2）若装到的不是最新，指定版本号
+npx @jeik/dingtalk-connector@0.8.30 install --force && openclaw gateway restart
 
-## ✨ 增强功能
+# 3）若仍装不了，强制走 npm 官方源
+NPM_CONFIG_REGISTRY=https://registry.npmjs.org npx @jeik/dingtalk-connector@0.8.30 install --force && openclaw gateway restart
+```
 
-### 🖼️ 图片发送：全面修复与增强
+### B）只装插件（凭证已配好时，按顺序试）
 
-> 🔥 **毫无死角** · 混合发图 · 全面碾压官方薄弱的图片机制  
-> ✅ 对话发图 · ✅ message 直发 · ✅ markdown 嵌图 · ✅ 文图可分可合
+```bash
+# 1）装最新
+openclaw plugins install @jeik/dingtalk-connector --force && openclaw gateway restart
 
-对官方图片发送做了**全路径修复增强**，多通道混合发图，全部显示正常：
+# 2）若装到的不是最新，指定版本号
+openclaw plugins install @jeik/dingtalk-connector@0.8.30 --force && openclaw gateway restart
 
-| | 发送方式 | 能力 |
-|--|----------|------|
-| 💬 | **普通对话回复** | Agent 用 `![注释](…)` 嵌图，定稿前自动上传 mediaId |
-| 📤 | **message · mediaUrl** | 机器人主动触发直发（本地 / 内网 / 公网） |
-| 📝 | **message · markdown 正文** | 正文嵌 `![](…)`（本地 / `file://` / 直链）与文字同条 |
-| ⚙️ | **文图策略可配** | 默认 📎 **分开**；`messageImageMd: true` → 🧩 **合并**一条 markdown |
+# 3）若仍装不了，强制走 npm 官方源
+NPM_CONFIG_REGISTRY=https://registry.npmjs.org openclaw plugins install @jeik/dingtalk-connector@0.8.30 --force && openclaw gateway restart
+```
 
-#### 🌐 路径与协议全覆盖
+### 本地 tgz / 源码（开发、离线）
 
-| | 类型 | 示例 |
-|--|------|------|
-| 🌍 | 公网直链 | `https://…` |
-| 🏠 | 内网直链 | `http://内网主机/…` |
-| 📁 | 本地绝对路径 | `/tmp/…` · `/root/…` |
-| 💾 | **`/mnt` 挂载盘** | 中文目录 · 共享盘 · SMB |
-| 🔗 | `file://` URI | `file:///mnt/…` · `file:///tmp/…` |
-| 🆔 | 已有 mediaId | `@lADP…` |
+```bash
+git clone https://github.com/jeikl/dingtalk-openclaw-connector-fix-Community.git
+cd dingtalk-openclaw-connector-fix-Community
+npm install && npm run build && npm pack
+openclaw plugins install ./jeik-dingtalk-connector-0.8.30.tgz --force && openclaw gateway restart
+```
 
-#### 🛡️ 细节兜底
+### 安装后自检
 
-- 📦 代码块 / 行内 code 路径 **不会误上传**（参数说明原文保留）
-- ⬇️ 远程图 **先下载再上传**；本地失败会 **`/tmp` 重试**
-- 🫧 图 + 下载链接 **同泡共存**：`![]` → mediaId，下载 URL 仍是原链
+```bash
+openclaw -v                    # ≥ 2026.4.9
+openclaw plugins list          # 应看到 dingtalk-connector / @jeik/dingtalk-connector
+# 发一条钉钉消息：应先「正在召唤大模型…」，再流式/答案卡
+```
 
-### 🎨 AI Card 模板
+---
 
-- ✨ 支持自定义流式卡；**不填 `cardTemplateId` 默认**  
-  `0d2c84b3-12c1-473b-b14a-f329a7a102cd.schema`（含 📋 复制按钮等）
+## ⚙️ 配置
 
-### ⚙️ 最小配置（够跑）
+### 最小配置（够跑）
 
 ```json
 "channels": {
@@ -121,8 +123,6 @@ npx -y @jeik/dingtalk-connector@0.8.28 install --force && openclaw gateway resta
 
 ### 最大化配置（展示用，默认值写全）
 
-按单 Agent / 多 Agent 两种写法（值均为默认，**不等于额外能力**）。
-
 **单 Agent（顶层凭证）：**
 
 ```json
@@ -197,12 +197,64 @@ npx -y @jeik/dingtalk-connector@0.8.28 install --force && openclaw gateway resta
 | `answerCardTemplateId` | string | `d246b7f5-1783-4e9b-bb46-bef52d63050e.schema` | 答案静态卡模板 |
 | `messageAnswerCard` | boolean | **true** | message 工具正文走答案静态卡；`false`=普通消息 |
 | `messageImageMd` | boolean | **false** | message 图文：`false` 文图分开；`true` 可合并 markdown |
+| `debug` | boolean | **false** | 详细诊断日志（连接/图片 mediaId/引用回填/队列）。**日常关闭**；排障时顶层或某账号设 `true`，改完 `openclaw gateway restart` |
 
 > `answerCard` = 对话流式收尾；`messageAnswerCard` = message 工具外发。
 
+**临时开排障日志示例：**
+
+```json
+"channels": {
+  "dingtalk-connector": {
+    "enabled": true,
+    "clientId": "…",
+    "clientSecret": "…",
+    "debug": true
+  }
+}
+```
+
 ---
 
-## 🎯 回复标记 + 答案卡 + 工具进度（核心增强）
+## ✨ 增强功能
+
+### 🖼️ 图片发送：全面修复与增强
+
+> 🔥 **毫无死角** · 混合发图 · 全面碾压官方薄弱的图片机制  
+> ✅ 对话发图 · ✅ message 直发 · ✅ markdown 嵌图 · ✅ 文图可分可合
+
+对官方图片发送做了**全路径修复增强**，多通道混合发图，全部显示正常：
+
+| | 发送方式 | 能力 |
+|--|----------|------|
+| 💬 | **普通对话回复** | Agent 用 `![注释](…)` 嵌图，定稿前自动上传 mediaId |
+| 📤 | **message · mediaUrl** | 机器人主动触发直发（本地 / 内网 / 公网） |
+| 📝 | **message · markdown 正文** | 正文嵌 `![](…)`（本地 / `file://` / 直链）与文字同条 |
+| ⚙️ | **文图策略可配** | 默认 📎 **分开**；`messageImageMd: true` → 🧩 **合并**一条 markdown |
+
+#### 🌐 路径与协议全覆盖
+
+| | 类型 | 示例 |
+|--|------|------|
+| 🌍 | 公网直链 | `https://…` |
+| 🏠 | 内网直链 | `http://内网主机/…` |
+| 📁 | 本地绝对路径 | `/tmp/…` · `/root/…` |
+| 💾 | **`/mnt` 挂载盘** | 中文目录 · 共享盘 · SMB |
+| 🔗 | `file://` URI | `file:///mnt/…` · `file:///tmp/…` |
+| 🆔 | 已有 mediaId | `@lADP…` |
+
+#### 🛡️ 细节兜底
+
+- 📦 代码块 / 行内 code 路径 **不会误上传**（参数说明原文保留）
+- ⬇️ 远程图 **先下载再上传**；本地失败会 **`/tmp` 重试**
+- 🫧 图 + 下载链接 **同泡共存**：`![]` → mediaId，下载 URL 仍是原链
+
+### 🎨 AI Card 模板
+
+- ✨ 支持自定义流式卡；**不填 `cardTemplateId` 默认**  
+  `0d2c84b3-12c1-473b-b14a-f329a7a102cd.schema`（含 📋 复制按钮等）
+
+### 🎯 回复标记 + 答案卡 + 工具进度
 
 这套机制让钉钉侧的「过程 → 最终答案」渲染更干净、更稳定，规避钉钉流式 AI Card 的官方渲染 bug：
 
@@ -236,83 +288,12 @@ npx -y @jeik/dingtalk-connector@0.8.28 install --force && openclaw gateway resta
 
 | 项目 | 说明 |
 |------|------|
-| 基础版本 | 官方 v0.8.20，功能完全一致 |
-| 修复内容 | 官方一直不修的 Bug（见上方最近修复） |
+| 基础版本 | 对齐官方 **v0.8.24** 长连接能力，并叠加本仓库独有优化 |
+| 修复内容 | 连接假死、消息丢失、错误卡卡住、图片灰图等实际使用问题 |
 | 维护方式 | 社区维护，持续跟进官方更新 |
 
 ---
 
-## 安装与要求
-
-开始之前，请确保：
-
-- **OpenClaw**：已安装并正常运行。详情请访问 [OpenClaw 官网](https://openclaw.ai/)
-- **版本要求**：OpenClaw ≥ **2026.4.9**，通过 `openclaw -v` 查看
-
-> 如低于此版本，执行 `npm install -g openclaw` 升级。
-
----
-
-## 安装
-
-> 与官方插件同 channel id（`dingtalk-connector`），`--force` 直接覆盖更新，**无需先卸载**官方版或旧版。  
-> **当前稳定版：`0.8.21-fix31`**（npm `latest` 已指向本版）。安装/更新后**必须** `openclaw gateway restart`。
-
-### 方式一：npm（推荐）
-
-包名：[`@jeik/dingtalk-connector`](https://www.npmjs.com/package/@jeik/dingtalk-connector)
-
-**1）一键扫码安装**（推荐：创建机器人 → 取凭证 → 装插件 → 写配置）：
-
-```bash
-npx -y @jeik/dingtalk-connector install
-
-# 已有 dingtalk-connector / 装不上时强制覆盖
-npx -y @jeik/dingtalk-connector install --force
-```
-
-**2）只装插件**（凭证已配好，或走手动配置文档）：
-
-```bash
-openclaw plugins install @jeik/dingtalk-connector --force
-openclaw gateway restart
-```
-
-**3）升级到最新版：**
-
-```bash
-openclaw plugins install @jeik/dingtalk-connector --force
-openclaw gateway restart
-```
-
-### 方式二：本地 tgz / 源码构建（开发、离线、预发验证）
-
-```bash
-git clone https://github.com/jeikl/dingtalk-openclaw-connector-fix-Community.git
-cd dingtalk-openclaw-connector-fix-Community
-# 可选：钉到某次发布（这是 git tag，不是分支；clone 后可直接 checkout）
-# git fetch --tags && git checkout v0.8.21-fix31
-
-npm install && npm run build && npm pack
-# → jeik-dingtalk-connector-0.8.21-fix31.tgz
-
-openclaw plugins install ./jeik-dingtalk-connector-0.8.21-fix31.tgz --force
-openclaw gateway restart
-```
-
-> 国内若 clone 慢，可用镜像前缀，例如：  
-> `git clone https://ghfast.top/https://github.com/jeikl/dingtalk-openclaw-connector-fix-Community.git`
-
-### 安装后自检
-
-```bash
-openclaw -v                    # OpenClaw ≥ 2026.4.9
-openclaw plugins list          # 应看到 dingtalk-connector / @jeik/dingtalk-connector
-# 发一条钉钉消息：应先出现「🦸 正在召唤大模型…」，再进入流式回复
-```
-
----
-
 ## 使用指南
 
 [OpenClaw 钉钉官方插件使用指南](https://alidocs.dingtalk.com/i/nodes/2Amq4vjg89GEno0zfPqoPGqdV3kdP0wQ?utm_scene=team_space)

package/dist/{background-work-Cxb4b-91.mjs → background-work-DkaSDqWk.mjs}

@@ -1,4 +1,15 @@
+import { r as isDingtalkDebug } from "./logger-CnBTcwyq.mjs";
 //#region src/utils/background-work.ts
+/**
+* 后台任务引用计数。
+*
+* 钉钉 WS 回调只「入队」后就返回，真正的 AI 跑在 sessionQueues 后台 Promise 里。
+* 若只在 WS 回调里 markMessageProcessingStart/End，会在入队后立刻 End，
+* 长任务（尤其 503 重试）期间心跳超时会触发幽灵重连 → 后续消息「网关没反应」。
+*
+* 用法：session 队列任务创建后 trackBackgroundWork(taskPromise)。
+* connection 层订阅计数变化，在 count>0 时保持处理中 keepAlive。
+*/
 let activeCount = 0;
 const listeners = /* @__PURE__ */ new Set();
 function getActiveBackgroundWorkCount() {
@@ -31,7 +42,7 @@ function trackBackgroundWork(work, label) {
 		notify();
 	};
 	work.then(done, done);
-	if (label && typeof process !== "undefined" && process.env?.DINGTALK_DEBUG_QUEUE === "1") {
+	if (label && typeof process !== "undefined" && isDingtalkDebug()) {
 		console.log(`[DingTalk][bgWork] +1 label=${label} count=${activeCount}`);
 		work.finally(() => {
 			console.log(`[DingTalk][bgWork] -1 label=${label} count=${activeCount}`);

package/dist/card-content-cache-C7-XHhHw.mjs

@@ -0,0 +1,2 @@
+import { r as rememberCardContent } from "./card-content-cache-DT_OYThh.mjs";
+export { rememberCardContent };

package/dist/{card-content-cache-bDQFz2u8.mjs → card-content-cache-DT_OYThh.mjs}

@@ -1,4 +1,18 @@
+import { r as isDingtalkDebug } from "./logger-CnBTcwyq.mjs";
 //#region src/services/messaging/card-content-cache.ts
+/**
+* AI / 交互卡片正文缓存
+*
+* 钉钉「引用 AI 卡片」时，回调里的 repliedMsg 经常是：
+*   { msgType: "interactiveCard", content: {} 或仅有 templateId }
+* 不带可读正文 → 模型侧只看到 `[引用] [interactiveCard消息]`。
+*
+* 对策：我们在 finishAICard / 定稿时把 outTrackId → 正文 记下来；
+* 引用时仅用载荷里的 outTrackId / msgId 等精确回填。
+* 默认不做「会话最近一条」兜底（会把错误卡片正文当成用户引用的内容）。
+*
+* 内存 LRU + TTL，进程重启后清空（可接受）。
+*/
 const MAX_ENTRIES = 300;
 /** 默认保留 7 天（引用历史卡片） */
 const DEFAULT_TTL_MS = 10080 * 60 * 1e3;
@@ -39,7 +53,7 @@ function rememberCardContent(params) {
 		byConversation.set(cid, next);
 		byKey.set(normalizeKey("convRef", `${cid}|${ref}`), entry);
 	}
-	try {
+	if (isDingtalkDebug()) try {
 		console.log(`[DingTalk][CardCache] 已缓存 | outTrack=${params.outTrackId || "-"} conv=${params.conversationId || "-"} len=${text.length}`);
 	} catch {}
 }

package/dist/chunk-upload-BKM1y4Ba.mjs

@@ -0,0 +1,2 @@
+import { a as uploadLargeFileByChunks } from "./chunk-upload-CIU5G_ay.mjs";
+export { uploadLargeFileByChunks };

package/dist/{chunk-upload-BE71drPg.mjs → chunk-upload-CIU5G_ay.mjs}

@@ -1,4 +1,4 @@
-import { t as createLogger } from "./logger-mZ9OSbmD.mjs";
+import { t as createLogger } from "./logger-CnBTcwyq.mjs";
 import { n as dingtalkOapiHttp } from "./http-client-DFWZgO1n.mjs";
 import * as fs from "fs";
 import * as path from "path";

package/dist/{common-BZiVgd3A.mjs → common-BfIYs1yC.mjs}

@@ -1,6 +1,6 @@
-import { t as createLogger } from "./logger-mZ9OSbmD.mjs";
+import { t as createLogger } from "./logger-CnBTcwyq.mjs";
 import { r as dingtalkUploadHttp } from "./http-client-DFWZgO1n.mjs";
-import { t as CHUNK_CONFIG } from "./chunk-upload-BE71drPg.mjs";
+import { t as CHUNK_CONFIG } from "./chunk-upload-CIU5G_ay.mjs";
 import * as fs from "fs";
 import * as path from "path";
 import FormData from "form-data";
@@ -48,7 +48,7 @@ async function uploadMediaToDingTalk(filePath, mediaType, oapiToken, maxSize = 2
 		if ((mediaType === "video" || mediaType === "file") && fileSize > CHUNK_CONFIG.SIZE_THRESHOLD) {
 			log?.info?.(`文件超过 20MB，使用分块上传：${absPath} (${fileSizeMB}MB)`);
 			try {
-				const { uploadLargeFileByChunks } = await import("./chunk-upload-PwhogwfE.mjs");
+				const { uploadLargeFileByChunks } = await import("./chunk-upload-BKM1y4Ba.mjs");
 				const downloadCode = await uploadLargeFileByChunks(absPath, mediaType, oapiToken, debugEnabled);
 				if (downloadCode) {
 					log?.info?.(`分块上传成功：${absPath}, download_code: ${downloadCode}`);

package/dist/{common-DgL28gCZ.mjs → common-C0Oaf0z-.mjs}

@@ -1,2 +1,2 @@
-import { i as VIDEO_MARKER_PATTERN, r as FILE_MARKER_PATTERN, t as AUDIO_MARKER_PATTERN } from "./common-BZiVgd3A.mjs";
+import { i as VIDEO_MARKER_PATTERN, r as FILE_MARKER_PATTERN, t as AUDIO_MARKER_PATTERN } from "./common-BfIYs1yC.mjs";
 export { AUDIO_MARKER_PATTERN, FILE_MARKER_PATTERN, VIDEO_MARKER_PATTERN };

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

@@ -1,5 +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 { n as onBackgroundWorkCountChange, t as getActiveBackgroundWorkCount } from "./background-work-DkaSDqWk.mjs";
 import * as fs from "fs";
 //#region src/core/connection.ts
 /**
@@ -64,7 +64,7 @@ let _connectionNoticePrinted = false;
 function printConnectionNoticeOnce() {
 	if (_connectionNoticePrinted) return;
 	_connectionNoticePrinted = true;
-	console.log("[dingtalk-connector] ℹ️  上游 dingtalk-stream 噪音已过滤；须 OPEN+REGISTERED 才报 ready，REGISTERED 超时会强制重连（禁止假 online）。正常运行不应出现 ≤30s 周期性硬重连。");
+	console.log("[dingtalk-connector] ℹ️  上游 dingtalk-stream 噪音已过滤；OPEN 成功即可上线，REGISTERED 尽量等待；若环境不推 REGISTERED，首条消息会确认订阅。正常运行不应出现 ≤30s 周期性硬重连。");
 }
 async function monitorSingleAccount(opts) {
 	const { cfg, account, runtime, abortSignal, messageHandler, onStatusChange } = opts;
@@ -72,7 +72,8 @@ async function monitorSingleAccount(opts) {
 	silenceDingtalkStreamConsoleNoise();
 	const clawdbotConfig = cfg;
 	const log = runtime?.log;
-	const { createLoggerFromConfig } = await import("./logger-BmJkQkm1.mjs");
+	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);
@@ -169,13 +170,14 @@ async function monitorSingleAccount(opts) {
 		return Math.min(exponentialDelay + jitter, MAX_BACKOFF_DELAY);
 	}
 	/**
-	* 等待钉钉 Stream 真正可收消息。
+	* 等待钉钉 Stream 可服务。
 	*
-	* dingtalk-stream 的 client.connect() 在创建 WebSocket 后立刻 resolve，
-	* **不等** socket open，更不等服务端 SYSTEM/REGISTERED。
+	* - OPEN：必须成功，否则 throw
+	* - REGISTERED：尽量等待；超时则 **降级 OPEN 上线**（不 throw）
 	*
-	* 顺序：socket OPEN → SYSTEM topic=REGISTERED（client.registered=true）
-	* 任一步失败均 throw，禁止 OPEN-only 假 ready。
+	* 原因（生产日志）：部分环境 socket 已 OPEN 且 CALLBACK 能收消息，
+	* 但长期收不到 SYSTEM/REGISTERED 或 client.registered 不被置 true。
+	* 若硬性失败会触发网关 auto-restart 风暴，而旧连接/半连接其实仍在处理消息。
 	*/
 	async function waitForStreamReady(timeoutMs = STREAM_READY_TIMEOUT_MS) {
 		const started = Date.now();
@@ -209,7 +211,7 @@ async function monitorSingleAccount(opts) {
 		}
 		if (client.registered === true) {
 			logger.info(`✅ Stream 已就绪（OPEN + REGISTERED），耗时 ${Date.now() - started}ms`);
-			return;
+			return { registered: true };
 		}
 		if (await new Promise((resolve) => {
 			const socket = client.socket;
@@ -245,9 +247,10 @@ async function monitorSingleAccount(opts) {
 			socket.on("message", onMessage);
 		}) || client.registered === true) {
 			logger.info(`✅ Stream 已就绪（OPEN + REGISTERED），耗时 ${Date.now() - started}ms`);
-			return;
+			return { registered: true };
 		}
-		throw new Error(`SYSTEM/REGISTERED 超时（${timeoutMs}ms）：socket 已 OPEN 但订阅未生效，禁止报 connected`);
+		logger.warn(`⚠️ 未观察到 SYSTEM/REGISTERED（${timeoutMs}ms），socket 已 OPEN → 降级上线。 收到首条机器人消息后会记为「订阅 empirically 生效」。`);
+		return { registered: false };
 	}
 	/**
 	* connect 之后、wait ready 之前挂上 pong/message/close。
@@ -261,26 +264,27 @@ async function monitorSingleAccount(opts) {
 		setupCloseListener();
 	}
 	/**
-	* 单次：connect + 挂 listener + 等 OPEN/REGISTERED。
-	* 失败 throw，不报 connected。
+	* 单次：connect + 挂 listener + 等 OPEN（REGISTERED 可选）。
+	* 仅 OPEN 失败 throw；REGISTERED 超时则降级成功。
 	*/
-	async function connectAndWaitRegistered() {
+	async function connectAndWaitReady() {
 		await client.connect();
 		attachSocketLifecycleListeners();
-		await waitForStreamReady(STREAM_READY_TIMEOUT_MS);
-		if (client.registered !== true) throw new Error("connect 后 client.registered 仍为 false");
+		return await waitForStreamReady(STREAM_READY_TIMEOUT_MS);
 	}
 	/**
-	* 直到 REGISTERED 成功或次数用尽。
-	* 用于初次启动与硬重连：绝不在未订阅时对外 connected=true。
+	* 建立可服务连接。
+	* - 优先拿到 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("连接已停止，中止 REGISTERED 等待");
+			if (isStopped) throw new Error("连接已停止，中止 Stream 建立");
 			try {
 				if (attempt > 1) {
-					logger.warn(`🔄 REGISTERED 未就绪，强制重连 ${attempt}/${maxAttempts}…`);
+					logger.warn(`🔄 Stream 建立重试 ${attempt}/${maxAttempts}…`);
 					try {
 						if (client.socket) await client.disconnect();
 					} catch (discErr) {
@@ -288,18 +292,18 @@ async function monitorSingleAccount(opts) {
 					}
 					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");
+				} 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(`✅ 订阅已生效 registered=true（attempt ${attempt}/${maxAttempts}, socket=${client.socket?.readyState}）`);
+				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}`);
+				logger.warn(`⚠️ Stream 建立失败 attempt=${attempt}/${maxAttempts}: ${lastError.message}`);
 			}
 		}
-		throw new Error(`钉钉 Stream 在 ${maxAttempts} 次尝试后仍未 REGISTERED，拒绝假 connected。 最后错误: ${lastError?.message || "unknown"}`);
+		throw new Error(`钉钉 Stream 在 ${maxAttempts} 次尝试后仍无法 OPEN。 最后错误: ${lastError?.message || "unknown"}`);
 	}
 	/** 统一重连函数，带指数退避（无限重连） */
 	async function doReconnect(immediate = false) {
@@ -506,21 +510,19 @@ async function monitorSingleAccount(opts) {
 			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;
-			const timestamp = (/* @__PURE__ */ new Date()).toISOString();
-			logger.info(`\n========== 收到新消息 ==========`);
-			logger.info(`时间：${timestamp}`);
-			logger.info(`MessageId: ${messageId || "N/A"}`);
-			logger.info(`Headers: ${JSON.stringify(res.headers || {})}`);
-			logger.info(`Data 长度：${res.data?.length || 0} 字符`);
 			let acked = false;
 			const ackMessage = (why) => {
 				if (acked || !messageId) return;
 				try {
 					client.socketCallBackResponse(messageId, { success: true });
 					acked = true;
-					logger.info(`✅ 已确认回调 messageId=${messageId} (${why})`);
+					logger.debug(`ACK messageId=${messageId} (${why})`);
 				} catch (ackErr) {
 					logger.warn(`确认回调失败: ${ackErr?.message || ackErr}`);
 				}
@@ -531,37 +533,30 @@ async function monitorSingleAccount(opts) {
 				try {
 					data = JSON.parse(res.data);
 				} catch (parseError) {
-					logger.error("Failed to parse response data as JSON:", {
-						error: parseError instanceof Error ? parseError.message : String(parseError),
-						rawData: typeof res.data === "string" ? res.data.substring(0, 500) : res.data,
-						dataType: typeof res.data
-					});
-					throw new Error(`Invalid JSON response from DingTalk API. Error: ${parseError instanceof Error ? parseError.message : String(parseError)}. Raw data (first 100 chars): ${String(res.data).substring(0, 100)}`);
+					logger.error(`JSON 解析失败: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
+					throw new Error(`Invalid JSON from DingTalk: ${parseError instanceof Error ? parseError.message : String(parseError)}`);
 				}
-				logger.info(`\n----- 消息详情 -----`);
-				logger.info(`消息类型：${data.msgtype || "unknown"}`);
-				logger.info(`会话类型：${data.conversationType === "1" ? "DM (单聊)" : data.conversationType === "2" ? "Group (群聊)" : data.conversationType}`);
-				logger.info(`发送者：${data.senderNick || "unknown"} (${data.senderStaffId || data.senderId || "unknown"})`);
-				logger.info(`会话 ID: ${data.conversationId || "N/A"}`);
-				logger.info(`消息 ID: ${data.msgId || "N/A"}`);
-				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"}`);
 				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 || "-"} (${processedCount}/${receivedCount})`);
-					logger.info(`========== 消息处理结束（重复） ==========\n`);
+					logger.warn(`⚠️ 重复消息已跳过 protocol=${messageId || "-"} business=${businessMsgId || "-"}`);
 					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) + "...";
-				logger.info(`消息内容预览：${contentPreview}`);
-				logger.info(`完整数据字段：${Object.keys(data).join(", ")}`);
-				logger.info(`----- 消息详情结束 -----\n`);
-				logger.info(`🚀 开始处理消息...`);
 				await messageHandler({
 					accountId,
 					config: account.config,
@@ -574,16 +569,12 @@ async function monitorSingleAccount(opts) {
 				ackMessage("enqueued");
 				noteSocketAlive("after-enqueue");
 				processedCount++;
-				logger.info(`✅ 消息处理完成 (${processedCount}/${receivedCount})`);
-				logger.info(`========== 消息处理结束（成功） ==========\n`);
+				logger.info(`✅ 入队完成 (${processedCount}/${receivedCount})`);
 			} catch (error) {
 				processedCount++;
-				const errorMsg = `❌ 处理消息异常 (${processedCount}/${receivedCount}): ${error?.message || "未知错误"}`;
-				const errorStack = error?.stack || "无堆栈信息";
-				logger.error(errorMsg);
-				logger.error(`错误堆栈:\n${errorStack}`);
-				if (!acked) logger.warn(`⚠️ 未 ACK messageId=${messageId || "N/A"}，等待钉钉重投（避免网关永久丢消息）`);
-				logger.info(`========== 消息处理结束（失败） ==========\n`);
+				logger.error(`❌ 入站处理失败 (${processedCount}/${receivedCount}): ${error?.message || "未知错误"}`);
+				if (error?.stack) logger.debug(error.stack);
+				if (!acked) logger.warn(`⚠️ 未 ACK messageId=${messageId || "N/A"}，等待钉钉重投`);
 			} finally {
 				markMessageProcessingEnd();
 			}

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-BkI1gKaC.mjs");
+		const { registerGatewayMethods } = await import("./gateway-methods-DQ6TwOAr.mjs");
 		registerGatewayMethods(api);
 	}
 });