@dingtalk-real-ai/dingtalk-connector 0.8.0 → 0.8.2

package/CHANGELOG.md

@@ -5,6 +5,32 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.8.2] - 2026-03-22
+
+### 修复 / Fixes
+- 🐛 **多账号重复启动问题** - 修复 `enabled: false` 的账号仍会建立 WebSocket 连接的问题，禁用账号现在正确保持 pending 状态直到 Gateway 停止  
+  **Multi-account duplicate startup** - Fixed accounts with `enabled: false` still establishing WebSocket connections; disabled accounts now correctly remain in a pending state until the Gateway stops
+
+- 🐛 **相同 clientId 账号去重** - 修复多个账号配置相同 `clientId` 时建立重复连接的问题，通过静态配置分析确保同一 `clientId` 只有列表中第一个启用账号建立连接  
+  **Duplicate clientId deduplication** - Fixed duplicate connections when multiple accounts share the same `clientId`; static config analysis now ensures only the first enabled account per `clientId` establishes a connection
+
+
+### 改进 / Improvements
+- ✅ **Onboarding 配置向导优化** - 改进钉钉连接器配置引导逻辑，调整凭据输入顺序（先 Client ID 后 Client Secret），优化引导文案  
+  **Onboarding wizard improvement** - Improved DingTalk connector onboarding flow, adjusted credential input order (Client ID first, then Client Secret), and refined guidance text
+
+- ✅ **会话 Key 遵循 OpenClaw 规范** - 会话上下文按 OpenClaw 标准规则构建，通过 `channel`、`accountId`、`chatType`、`peerId` 唯一标识会话，支持 `sharedMemoryAcrossConversations` 跨会话记忆共享  
+  **Session key follows OpenClaw convention** - Session context now built per OpenClaw standard rules, uniquely identified via `channel`, `accountId`, `chatType`, `peerId`; supports `sharedMemoryAcrossConversations` for cross-conversation memory sharing
+
+- ✅ **消息处理逻辑优化** - 重构消息处理流程，提升消息响应速度和处理可靠性，确保消息按序正确处理  
+  **Message processing logic optimization** - Refactored message processing flow to improve response speed and reliability, ensuring messages are processed correctly in order
+
+## [0.8.1] - 2026-03-20
+
+### 修复 / Fixes
+- 🐛 **文件和图片下载 OSS 签名验证失败** - 修复默认 `Content-Type` 请求头导致 OSS 签名验证失败的问题，确保文件和图片能够正常下载  
+  **File and image download OSS signature verification failure** - Fixed OSS signature verification failure caused by default `Content-Type` header, ensuring files and images download correctly
+
 ## [0.8.0] - 2026-03-20
 
 ### 重构 / Refactoring

package/README.en.md

@@ -268,20 +268,26 @@ Configure multiple bots connected to different agents:
   "agents": {
     "list": [
       {
-        "agentId": "ding-bot1",
+        "id": "ding-bot1",
+        "name": "Customer Service Bot",
         "model": "your-model-config",
-        "persona": {
-          "name": "Customer Service Bot",
-          "systemPrompt": "You are a professional customer service assistant..."
+        "workspace": "~/.openclaw/workspace-bot1",
+        "identity": {
+          "name": "Service Assistant",
+          "theme": "customer service",
+          "emoji": "🤝"
         }
         // Other agent configurations...
       },
       {
-        "agentId": "ding-bot2",
+        "id": "ding-bot2",
+        "name": "Technical Support Bot",
         "model": "your-model-config",
-        "persona": {
-          "name": "Technical Support Bot",
-          "systemPrompt": "You are a technical support expert..."
+        "workspace": "~/.openclaw/workspace-bot2",
+        "identity": {
+          "name": "Tech Expert",
+          "theme": "technical support",
+          "emoji": "🔧"
         }
         // Other agent configurations...
       }

package/README.md

@@ -279,20 +279,26 @@ openclaw logs --follow
   "agents": {
     "list": [
       {
-        "agentId": "ding-bot1",
+        "id": "ding-bot1",
+        "name": "钉钉客服机器人",
         "model": "your-model-config",
-        "persona": {
-          "name": "钉钉客服机器人",
-          "systemPrompt": "你是一个专业的客服助手..."
+        "workspace": "~/.openclaw/workspace-bot1",
+        "identity": {
+          "name": "客服小助手",
+          "theme": "专业客服",
+          "emoji": "🤝"
         }
         // 其他 agent 配置...
       },
       {
-        "agentId": "ding-bot2",
+        "id": "ding-bot2",
+        "name": "钉钉技术支持机器人",
         "model": "your-model-config",
-        "persona": {
-          "name": "钉钉技术支持机器人",
-          "systemPrompt": "你是一个技术支持专家..."
+        "workspace": "~/.openclaw/workspace-bot2",
+        "identity": {
+          "name": "技术专家",
+          "theme": "技术支持",
+          "emoji": "🔧"
         }
         // 其他 agent 配置...
       }

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "dingtalk-connector",
   "name": "DingTalk Channel",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "description": "DingTalk (钉钉) messaging channel via Stream mode with AI Card streaming",
   "author": "DingTalk Real Team",
   "main": "index.ts",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dingtalk-real-ai/dingtalk-connector",
-  "version": "0.8.0",
+  "version": "0.8.2",
   "description": "DingTalk (钉钉) channel connector — Stream mode with AI Card streaming",
   "main": "index.ts",
   "type": "module",

package/src/channel.ts

@@ -495,64 +495,64 @@ export const dingtalkPlugin: ChannelPlugin<ResolvedDingtalkAccount> = {
   gateway: {
     startAccount: async (ctx) => {
       const account = resolveDingtalkAccount({ cfg: ctx.cfg, accountId: ctx.accountId });
-      const logger = createLogger(account.config?.debug ?? false, 'DingTalk:Gateway');
+
+      // 检查账号是否启用和配置
+      if (!account.enabled) {
+        ctx.log?.info?.(`dingtalk-connector[${ctx.accountId}] is disabled, skipping startup`);
+        // 返回一个永不 resolve 的 Promise，保持 pending 状态直到 abort
+        return new Promise<void>((resolve) => {
+          if (ctx.abortSignal?.aborted) {
+            resolve();
+            return;
+          }
+          ctx.abortSignal?.addEventListener('abort', () => resolve(), { once: true });
+        });
+      }
       
-      logger.info(`startAccount 被调用：accountId=${ctx.accountId}`);
-      try {
-        logger.info('='.repeat(60));
-        logger.info('开始加载 provider 模块...');
-        const monitorModule = await import("./core/provider.ts");
-        logger.info(`monitor module 加载完成`);
-        logger.info(`monitor module keys: ${Object.keys(monitorModule).join(', ')}`);
-        logger.info(`monitorModule 类型: ${typeof monitorModule}`);
-        logger.info(`monitorModule 是否为 null: ${monitorModule === null}`);
-        logger.info(`monitorModule 是否为 undefined: ${monitorModule === undefined}`);
-        
-        // 使用 Object.getOwnPropertyDescriptor 检查属性
-        const descriptor = Object.getOwnPropertyDescriptor(monitorModule, 'monitorSingleAccount');
-        logger.info(`monitorSingleAccount descriptor: ${JSON.stringify(descriptor)}`);
-        
-        // 尝试安全地访问 monitorSingleAccount
-        let monitorSingleAccountType = 'unknown';
-        try {
-          monitorSingleAccountType = typeof monitorModule.monitorSingleAccount;
-        } catch (e) {
-          monitorSingleAccountType = `error: ${e.message}`;
-        }
-        logger.info(`monitorModule.monitorSingleAccount: ${monitorSingleAccountType}`);
-        
-        logger.info(`monitorModule.monitorDingtalkProvider: ${typeof monitorModule.monitorDingtalkProvider}`);
-        
-        // 使用直接属性访问而不是解构
-        const monitorDingtalkProvider = monitorModule.monitorDingtalkProvider;
-        logger.info(`解构 monitorDingtalkProvider 完成: ${typeof monitorDingtalkProvider}`);
-        
-        if (!monitorDingtalkProvider) {
-          ctx.log?.error?.(`monitorDingtalkProvider 未找到！可用导出: ${Object.keys(monitorModule).join(', ')}`);
-          throw new Error("monitorDingtalkProvider not found in monitor module");
+      if (!account.configured) {
+        throw new Error(`DingTalk account "${ctx.accountId}" is not properly configured`);
+      }
+      
+      // 去重检查：如果列表中排在当前账号之前的账号已使用相同 clientId，则跳过当前账号
+      // 使用静态配置分析（而非运行时状态），避免并发竞态条件
+      // 规则：同一 clientId 只有列表中第一个启用且已配置的账号才会建立连接
+      if (account.clientId) {
+        const clientId = String(account.clientId);
+        const allAccountIds = listDingtalkAccountIds(ctx.cfg);
+        const currentIndex = allAccountIds.indexOf(ctx.accountId);
+        const priorAccountWithSameClientId = allAccountIds.slice(0, currentIndex).find((otherId) => {
+          const other = resolveDingtalkAccount({ cfg: ctx.cfg, accountId: otherId });
+          return other.enabled && other.configured && other.clientId && String(other.clientId) === clientId;
+        });
+        if (priorAccountWithSameClientId) {
+          ctx.log?.info?.(
+            `dingtalk-connector[${ctx.accountId}] skipped: clientId "${clientId.substring(0, 8)}..." is already used by account "${priorAccountWithSameClientId}"`
+          );
+          return new Promise<void>((resolve) => {
+            if (ctx.abortSignal?.aborted) {
+              resolve();
+              return;
+            }
+            ctx.abortSignal?.addEventListener('abort', () => resolve(), { once: true });
+          });
         }
-        logger.info(`monitorDingtalkProvider 找到`);
-        
-        logger.info(`account 解析完成: ${account.accountId}, enabled=${account.enabled}, configured=${account.configured}`);
-        
-        ctx.setStatus({ accountId: ctx.accountId, port: null });
-        ctx.log?.info(
-          `starting dingtalk-connector[${ctx.accountId}] (mode: stream)`,
-        );
-        logger.info(`准备调用 monitorDingtalkProvider`);
-        
-        const result = await monitorDingtalkProvider({
+      }
+
+      ctx.setStatus({ accountId: ctx.accountId, port: null });
+      ctx.log?.info(
+        `starting dingtalk-connector[${ctx.accountId}] (mode: stream)`,
+      );
+      try {
+        return await monitorDingtalkProvider({
           config: ctx.cfg,
           runtime: ctx.runtime,
           abortSignal: ctx.abortSignal,
           accountId: ctx.accountId,
         });
-        logger.info(`monitorDingtalkProvider 调用完成`);
-        return result;
-      } catch (error) {
-        ctx.log?.error?.(`startAccount 发生错误: ${error.message}`);
-        ctx.log?.error?.(`错误堆栈: ${error.stack}`);
-        throw error;
+      } catch (err: any) {
+        // 打印真实错误到 stderr，绕过框架 log 系统（框架的 runtime.log 可能未初始化）
+        ctx.log?.error(`[dingtalk-connector][${ctx.accountId}] startAccount error:`, err?.message ?? err, err?.stack);
+        throw err;
       }
     },
   },

package/src/config/accounts.ts

@@ -222,9 +222,21 @@ export function resolveDingtalkAccount(params: {
 
 /**
  * List all enabled and configured accounts.
+ * Deduplicates by clientId to avoid creating multiple connections with the same credentials.
  */
 export function listEnabledDingtalkAccounts(cfg: ClawdbotConfig): ResolvedDingtalkAccount[] {
-  return listDingtalkAccountIds(cfg)
+  const accounts = listDingtalkAccountIds(cfg)
     .map((accountId) => resolveDingtalkAccount({ cfg, accountId }))
     .filter((account) => account.enabled && account.configured);
+  
+  // Deduplicate by clientId to avoid multiple connections with same credentials
+  const seen = new Set<string>();
+  return accounts.filter((account) => {
+    if (!account.clientId) return true;
+    if (seen.has(account.clientId)) {
+      return false;
+    }
+    seen.add(account.clientId);
+    return true;
+  });
 }

package/src/core/connection.ts

@@ -13,7 +13,7 @@
  * - 连接统计和监控（每分钟输出）
  */
 import type { ClawdbotConfig, RuntimeEnv } from "openclaw/plugin-sdk";
-import type { MonitorDingtalkAccountOpts, ResolvedDingtalkAccount } from "../types/index.ts";
+import type { ResolvedDingtalkAccount } from "../types/index.ts";
 import {
   isMessageProcessed,
   markMessageProcessed,
@@ -30,14 +30,6 @@ export type DingtalkReactionCreatedEvent = {
   emoji: string;
 };
 
-export type MonitorDingtalkAccountOpts = {
-  cfg: ClawdbotConfig;
-  account: ResolvedDingtalkAccount;
-  runtime?: RuntimeEnv;
-  abortSignal?: AbortSignal;
-  messageHandler: MessageHandler; // 直接传入消息处理器
-};
-
 // 消息处理器函数类型
 export type MessageHandler = (params: {
   accountId: string;
@@ -49,6 +41,14 @@ export type MessageHandler = (params: {
   cfg: ClawdbotConfig;
 }) => Promise<void>;
 
+export type MonitorDingtalkAccountOpts = {
+  cfg: ClawdbotConfig;
+  account: ResolvedDingtalkAccount;
+  runtime?: RuntimeEnv;
+  abortSignal?: AbortSignal;
+  messageHandler: MessageHandler;
+};
+
 // ============ 连接配置 ============
 
 /** 心跳间隔（毫秒） */
@@ -138,6 +138,7 @@ export async function monitorSingleAccount(
   // ============ 连接状态管理 ============
 
   let lastSocketAvailableTime = Date.now();
+  let connectionEstablishedTime = Date.now(); // 记录连接建立时间
   let isReconnecting = false;
   let reconnectAttempts = 0;
   let keepAliveTimer: NodeJS.Timeout | null = null;
@@ -226,21 +227,52 @@ export async function monitorSingleAccount(
       // 2. 重新建立连接
       await client.connect();
 
-      // 3. 验证连接是否真正建立（必须检查 socket 状态）
-      const socketState = client.socket?.readyState;
-      if (socketState !== 1) {
-        // socket 状态不是 OPEN (1)，说明连接未真正建立
-        throw new Error(`连接未建立，socket 状态=${socketState} (期望=1)`);
+      // 3. 等待连接真正建立（监听 open 事件，最多等待 10 秒）
+      const connectionEstablished = await new Promise<boolean>((resolve) => {
+        const timeout = setTimeout(() => {
+          resolve(false);
+        }, 10_000); // 10 秒超时
+
+        // 如果已经是 OPEN 状态，直接返回
+        if (client.socket?.readyState === 1) {
+          clearTimeout(timeout);
+          resolve(true);
+          return;
+        }
+
+        // 否则监听 open 事件
+        const onOpen = () => {
+          clearTimeout(timeout);
+          client.socket?.removeListener('open', onOpen);
+          client.socket?.removeListener('error', onError);
+          resolve(true);
+        };
+
+        const onError = (err: any) => {
+          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);
+      });
+
+      if (!connectionEstablished) {
+        throw new Error(`连接建立超时或失败`);
       }
 
-      // 4. 重置 socket 可用时间和重连计数
+      // 4. 重置 socket 可用时间、连接建立时间和重连计数
       lastSocketAvailableTime = Date.now();
+      connectionEstablishedTime = Date.now(); // 重置连接建立时间
       reconnectAttempts = 0; // 重连成功，重置计数
 
-      logger.info(`✅ 重连成功 (socket 状态=${socketState})`);
+      logger.info(`✅ 重连成功 (socket 状态=${client.socket?.readyState})`);
     } catch (err: any) {
       reconnectAttempts++;
-      log?.error?.(
+      logger.error(
         `重连失败：${err.message} (尝试 ${reconnectAttempts})`,
       );
       throw err;
@@ -266,7 +298,7 @@ export async function monitorSingleAccount(
           if (!isStopped && !isReconnecting) {
             // 立即重连，不退避
             doReconnect(true).catch((err) => {
-              log?.error?.(`[${accountId}] 重连失败：${err.message}`);
+              logger.error(`[${accountId}] 重连失败：${err.message}`);
             });
           }
         }
@@ -290,7 +322,7 @@ export async function monitorSingleAccount(
       // 立即重连，不退避
       setTimeout(() => {
         doReconnect(true).catch((err) => {
-          log?.error?.(`重连失败：${err.message}`);
+          logger.error(`重连失败：${err.message}`);
         });
       }, 0);
     });
@@ -329,11 +361,20 @@ export async function monitorSingleAccount(
 
         // 【心跳检测】检查 socket 状态
         const socketState = client.socket?.readyState;
+        const timeSinceConnection = Date.now() - connectionEstablishedTime;
         logger.debug(
-          `🔍 心跳检测：socket 状态=${socketState}, elapsed=${Math.round(elapsed / 1000)}s`,
+          `🔍 心跳检测：socket 状态=${socketState}, elapsed=${Math.round(elapsed / 1000)}s, 连接已建立=${Math.round(timeSinceConnection / 1000)}s`,
         );
 
+        // 给新建立的连接 15 秒宽限期，避免在连接建立初期就触发重连
         if (socketState !== 1) {
+          if (timeSinceConnection < 15_000) {
+            logger.debug(
+              `⏳ 连接建立中（已 ${Math.round(timeSinceConnection / 1000)}s），跳过状态检查`,
+            );
+            return;
+          }
+          
           logger.info(
             `⚠️ 心跳检测：socket 状态=${socketState}，触发重连...`,
           );
@@ -347,11 +388,11 @@ export async function monitorSingleAccount(
           lastSocketAvailableTime = Date.now();
           logger.debug(`💓 发送 PING 心跳成功`);
         } catch (err: any) {
-          log?.warn?.(`发送 PING 失败：${err.message}`);
+          logger.warn(`发送 PING 失败：${err.message}`);
           // 发送失败也计入超时
         }
       } catch (err: any) {
-        log?.error?.(`keepAlive 检测失败：${err.message}`);
+        logger.error(`keepAlive 检测失败：${err.message}`);
       }
     }, HEARTBEAT_INTERVAL); // 每 10 秒检测一次
 
@@ -404,7 +445,7 @@ export async function monitorSingleAccount(
             await client.disconnect();
           }
         } catch (err: any) {
-          log?.warn?.(`断开连接时出错：${err.message}`);
+          logger.warn(`断开连接时出错：${err.message}`);
         }
         resolve();
       };
@@ -445,12 +486,13 @@ export async function monitorSingleAccount(
         client.socketCallBackResponse(messageId, { success: true });
         logger.info(`✅ 已立即确认回调：messageId=${messageId}`);
       } else {
-        log?.warn?.(`⚠️ 警告：消息没有 messageId`);
+        logger.warn(`⚠️ 警告：消息没有 messageId`);
       }
 
       // 消息去重
       if (messageId && isMessageProcessed(messageId)) {
-        log?.warn?.(`⚠️ 检测到重复消息，跳过处理：messageId=${messageId}`);
+        processedCount++;  // ✅ 修复：重复消息也要计入 processedCount
+        logger.warn(`⚠️ 检测到重复消息，跳过处理：messageId=${messageId} (${processedCount}/${receivedCount})`);
         logger.info(`========== 消息处理结束（重复） ==========\n`);
         return;
       }
@@ -519,8 +561,6 @@ export async function monitorSingleAccount(
 
         // ===== 第三步：开始处理消息 =====
         logger.info(`🚀 开始处理消息...`);
-        logger.info(`AccountId: ${accountId}`);
-        logger.info(`HasConfig: ${!!account.config}`);
 
         await messageHandler({
           accountId,
@@ -540,13 +580,9 @@ export async function monitorSingleAccount(
         const errorMsg = `❌ 处理消息异常 (${processedCount}/${receivedCount}): ${error?.message || "未知错误"}`;
         const errorStack = error?.stack || "无堆栈信息";
         
-        // 使用 logger 确保错误信息一定会被打印
-        logger.info(errorMsg);
-        logger.info(`错误堆栈:\n${errorStack}`);
-        
-        // 同时使用 log?.error 记录（如果可用）
-        log?.error?.(errorMsg);
-        log?.error?.(`错误堆栈:\n${errorStack}`);
+        // 使用 logger 记录错误信息
+        logger.error(errorMsg);
+        logger.error(`错误堆栈:\n${errorStack}`);
         
         logger.info(`========== 消息处理结束（失败） ==========\n`);
       } finally {
@@ -633,7 +669,7 @@ export async function monitorSingleAccount(
     // client.on('close', ...) - 已移除，使用 setupCloseListener
 
     client.on("error", (err: Error) => {
-      log?.error?.(`Connection error: ${err.message}`);
+      logger.error(`Connection error: ${err.message}`);
     });
 
     // 监听重连事件（仅用于日志，实际重连由自定义逻辑处理）