@largezhou/ddingtalk 1.3.1 → 1.4.0-beta.0

package/src/ffmpeg.ts

@@ -0,0 +1,206 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+import crypto from "node:crypto";
+import { logger } from "./logger.js";
+
+const execFileAsync = promisify(execFile);
+
+const FFPROBE_TIMEOUT_MS = 10_000;
+const FFMPEG_TIMEOUT_MS = 30_000;
+const MAX_BUFFER_BYTES = 10 * 1024 * 1024;
+
+// ======================= ffmpeg 检测 =======================
+
+let ffmpegAvailable: boolean | null = null;
+
+/**
+ * 检测系统是否安装了 ffmpeg 和 ffprobe
+ * 结果会被缓存，只检测一次
+ */
+export function hasFFmpeg(): boolean {
+  if (ffmpegAvailable !== null) {
+    return ffmpegAvailable;
+  }
+
+  const pathEnv = process.env.PATH ?? "";
+  const parts = pathEnv.split(path.delimiter).filter(Boolean);
+  const extensions = process.platform === "win32"
+    ? (process.env.PATHEXT ?? ".EXE;.CMD;.BAT").split(";").filter(Boolean)
+    : [""];
+
+  let foundFfmpeg = false;
+  let foundFfprobe = false;
+
+  for (const dir of parts) {
+    for (const ext of extensions) {
+      if (!foundFfmpeg) {
+        try {
+          fs.accessSync(path.join(dir, `ffmpeg${ext}`), fs.constants.X_OK);
+          foundFfmpeg = true;
+        } catch { /* keep scanning */ }
+      }
+      if (!foundFfprobe) {
+        try {
+          fs.accessSync(path.join(dir, `ffprobe${ext}`), fs.constants.X_OK);
+          foundFfprobe = true;
+        } catch { /* keep scanning */ }
+      }
+      if (foundFfmpeg && foundFfprobe) break;
+    }
+    if (foundFfmpeg && foundFfprobe) break;
+  }
+
+  ffmpegAvailable = foundFfmpeg && foundFfprobe;
+
+  if (ffmpegAvailable) {
+    logger.log("[ffmpeg] 检测到 ffmpeg 和 ffprobe 已安装");
+  } else {
+    logger.log(`[ffmpeg] 未检测到 ffmpeg/ffprobe（ffmpeg: ${foundFfmpeg}, ffprobe: ${foundFfprobe}）`);
+  }
+
+  return ffmpegAvailable;
+}
+
+// ======================= ffprobe 探测 =======================
+
+async function runFfprobe(args: string[]): Promise<string> {
+  const { stdout } = await execFileAsync("ffprobe", args, {
+    timeout: FFPROBE_TIMEOUT_MS,
+    maxBuffer: MAX_BUFFER_BYTES,
+  });
+  return stdout.toString();
+}
+
+async function runFfmpeg(args: string[]): Promise<string> {
+  const { stdout } = await execFileAsync("ffmpeg", args, {
+    timeout: FFMPEG_TIMEOUT_MS,
+    maxBuffer: MAX_BUFFER_BYTES,
+  });
+  return stdout.toString();
+}
+
+/**
+ * 获取音频/视频的时长（毫秒）
+ * @param filePath - 本地文件路径
+ * @returns 时长（毫秒），整数
+ */
+export async function getMediaDuration(filePath: string): Promise<number> {
+  const stdout = await runFfprobe([
+    "-v", "error",
+    "-show_entries", "format=duration",
+    "-of", "csv=p=0",
+    filePath,
+  ]);
+  const durationSec = parseFloat(stdout.trim());
+  if (isNaN(durationSec)) {
+    throw new Error(`无法解析时长: ${stdout.trim()}`);
+  }
+  return Math.round(durationSec * 1000);
+}
+
+/**
+ * 获取视频的宽高
+ * @param filePath - 本地文件路径
+ * @returns { width, height }
+ */
+export async function getVideoResolution(filePath: string): Promise<{ width: number; height: number }> {
+  const stdout = await runFfprobe([
+    "-v", "error",
+    "-select_streams", "v:0",
+    "-show_entries", "stream=width,height",
+    "-of", "csv=p=0:s=x",
+    filePath,
+  ]);
+  const match = stdout.trim().match(/^(\d+)x(\d+)/);
+  if (!match) {
+    throw new Error(`无法解析视频分辨率: ${stdout.trim()}`);
+  }
+  return { width: parseInt(match[1], 10), height: parseInt(match[2], 10) };
+}
+
+/**
+ * 提取视频的第一帧作为封面图
+ * @param videoPath - 本地视频文件路径
+ * @returns 封面图片的 Buffer（JPEG 格式）
+ */
+export async function extractVideoCover(videoPath: string): Promise<Buffer> {
+  const tmpDir = os.tmpdir();
+  const coverPath = path.join(tmpDir, `dingtalk-cover-${crypto.randomUUID()}.jpg`);
+
+  try {
+    await runFfmpeg([
+      "-y",
+      "-i", videoPath,
+      "-vframes", "1",
+      "-q:v", "2",
+      "-f", "image2",
+      coverPath,
+    ]);
+
+    const buffer = fs.readFileSync(coverPath);
+    return buffer;
+  } finally {
+    // 清理临时文件
+    try {
+      fs.unlinkSync(coverPath);
+    } catch { /* ignore */ }
+  }
+}
+
+export interface MediaProbeResult {
+  /** 时长（毫秒），整数 */
+  duration: number;
+  /** 视频分辨率（仅视频有） */
+  width?: number;
+  height?: number;
+  /** 视频封面图 Buffer（仅视频有） */
+  coverBuffer?: Buffer;
+}
+
+/**
+ * 将 Buffer 写入临时文件，执行探测，然后清理
+ * @param buffer - 媒体文件内容
+ * @param fileName - 文件名（用于扩展名推断）
+ * @param type - 媒体类型 "voice" | "video"
+ */
+export async function probeMediaBuffer(
+  buffer: Buffer,
+  fileName: string,
+  type: "voice" | "video"
+): Promise<MediaProbeResult> {
+  const ext = path.extname(fileName) || (type === "video" ? ".mp4" : ".mp3");
+  const tmpDir = os.tmpdir();
+  const tmpPath = path.join(tmpDir, `dingtalk-probe-${crypto.randomUUID()}${ext}`);
+
+  fs.writeFileSync(tmpPath, buffer);
+
+  try {
+    const duration = await getMediaDuration(tmpPath);
+    const result: MediaProbeResult = { duration };
+
+    if (type === "video") {
+      try {
+        const { width, height } = await getVideoResolution(tmpPath);
+        result.width = width;
+        result.height = height;
+      } catch (err) {
+        logger.warn(`[ffmpeg] 获取视频分辨率失败: ${err}`);
+      }
+
+      try {
+        result.coverBuffer = await extractVideoCover(tmpPath);
+      } catch (err) {
+        logger.warn(`[ffmpeg] 提取视频封面失败: ${err}`);
+      }
+    }
+
+    return result;
+  } finally {
+    try {
+      fs.unlinkSync(tmpPath);
+    } catch { /* ignore */ }
+  }
+}

package/src/monitor.ts

@@ -1,5 +1,5 @@
 import { DWClient, TOPIC_ROBOT, type DWClientDownStream } from "dingtalk-stream";
-import type { OpenClawConfig, RuntimeEnv } from "openclaw/plugin-sdk";
+import { recordInboundSession, type OpenClawConfig, type RuntimeEnv } from "openclaw/plugin-sdk";
 import type { DingTalkMessageData, ResolvedDingTalkAccount, DingTalkGroupConfig, AudioContent, VideoContent, FileContent, PictureContent, RichTextContent, RichTextElement, RichTextPictureElement } from "./types.js";
 import { replyViaWebhook, getFileDownloadUrl, downloadFromUrl, sendTextMessage } from "./client.js";
 import { resolveDingTalkAccount } from "./accounts.js";
@@ -540,10 +540,7 @@ export interface MonitorOptions {
   abortSignal?: AbortSignal;
 }
 
-export interface MonitorResult {
-  account: ResolvedDingTalkAccount;
-  stop: () => void;
-}
+export type MonitorResult = Promise<void>;
 
 // Track runtime state in memory
 const runtimeState = new Map<
@@ -781,7 +778,7 @@ export function monitorDingTalkProvider(options: MonitorOptions): MonitorResult
     return { textContent, rawBody };
   };
 
-  /** 构建入站消息上下文 */
+  /** 构建入站消息上下文（含路由信息） */
   const buildInboundContext = (
     data: DingTalkMessageData,
     sender: ReturnType<typeof buildSenderInfo>,
@@ -797,7 +794,7 @@ export function monitorDingTalkProvider(options: MonitorOptions): MonitorResult
       channel: PLUGIN_ID,
       accountId,
       peer: {
-        kind: isGroup ? "group" : "dm",
+        kind: isGroup ? "group" : "direct",
         id: sender.chatId,
       },
     });
@@ -848,10 +845,12 @@ export function monitorDingTalkProvider(options: MonitorOptions): MonitorResult
     // 合并媒体字段
     const mediaFields = buildMediaContextFields(media);
 
-    return pluginRuntime.channel.reply.finalizeInboundContext({
+    const ctxPayload = pluginRuntime.channel.reply.finalizeInboundContext({
       ...baseContext,
       ...mediaFields,
     });
+
+    return { ctxPayload, route };
   };
 
   /** 创建回复分发器 */
@@ -905,10 +904,33 @@ export function monitorDingTalkProvider(options: MonitorOptions): MonitorResult
       // 2. 构建消息体
       const { rawBody } = buildMessageBody(data, media);
 
-      // 3. 构建入站上下文
-      const ctxPayload = buildInboundContext(data, sender, rawBody, media);
+      // 3. 构建入站上下文（含路由信息）
+      const { ctxPayload, route } = buildInboundContext(data, sender, rawBody, media);
+
+      // 4. 持久化 session 元数据 + 更新回复路由（参照 Discord/Telegram）
+      const storePath = pluginRuntime.channel.session.resolveStorePath(undefined, {
+        agentId: route.agentId,
+      });
+      const persistedSessionKey = ctxPayload.SessionKey ?? route.sessionKey;
+
+      await recordInboundSession({
+        storePath,
+        sessionKey: persistedSessionKey,
+        ctx: ctxPayload,
+        updateLastRoute: !sender.isGroup
+          ? {
+              sessionKey: route.mainSessionKey,
+              channel: PLUGIN_ID,
+              to: sender.toAddress,
+              accountId: route.accountId,
+            }
+          : undefined,
+        onRecordError: (err) => {
+          logger.error("recordInboundSession failed:", err);
+        },
+      });
 
-      // 4. 分发消息给 OpenClaw
+      // 5. 分发消息给 OpenClaw
       const { queuedFinal } = await pluginRuntime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
         ctx: ctxPayload,
         cfg: config,
@@ -961,7 +983,7 @@ export function monitorDingTalkProvider(options: MonitorOptions): MonitorResult
       // 打印收到的消息信息
       const preview = handler.getPreview(data);
       const chatLabel = isGroup
-        ? `群聊(${data.conversationTitle ?? groupId})`
+        ? `群聊(${data.conversationTitle ? `${data.conversationTitle} | ${groupId}` : groupId})`
         : "单聊";
       logger.log(`收到消息 | ${chatLabel} | ${data.senderNick}(${data.senderStaffId}) | ${preview}`);
 
@@ -1064,29 +1086,26 @@ export function monitorDingTalkProvider(options: MonitorOptions): MonitorResult
 
   client.connect();
 
-  // 处理中止信号
-  const stopHandler = () => {
-    logger.log(`[${accountId}] 停止 provider`);
-    client.disconnect();
-    recordChannelRuntimeState({
-      channel: PLUGIN_ID,
-      accountId,
-      state: {
-        running: false,
-        lastStopAt: Date.now(),
-      },
-    });
-  };
-
-  if (abortSignal) {
-    abortSignal.addEventListener("abort", stopHandler);
-  }
+  // 返回一个在 abort/disconnect 之前一直 pending 的 Promise。
+  // OpenClaw 框架将 startAccount 返回的 Promise resolve 视为 "channel 已退出"，
+  // 会触发 auto-restart。因此需要保持 pending 直到 abort。
+  return new Promise<void>((resolve) => {
+    const stopHandler = () => {
+      logger.log(`[${accountId}] 停止 provider`);
+      client.disconnect();
+      recordChannelRuntimeState({
+        channel: PLUGIN_ID,
+        accountId,
+        state: {
+          running: false,
+          lastStopAt: Date.now(),
+        },
+      });
+      resolve();
+    };
 
-  return {
-    account,
-    stop: () => {
-      stopHandler();
-      abortSignal?.removeEventListener("abort", stopHandler);
-    },
-  };
+    if (abortSignal) {
+      abortSignal.addEventListener("abort", stopHandler);
+    }
+  });
 }

package/src/onboarding.ts

@@ -1,9 +1,9 @@
-import type { OpenClawConfig } from "openclaw/plugin-sdk";
 import type { ChannelOnboardingAdapter } from "openclaw/plugin-sdk";
-import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk";
+import { DEFAULT_ACCOUNT_ID, promptAccountId } from "openclaw/plugin-sdk";
 import type { DingTalkConfig } from "./types.js";
 import {
   listDingTalkAccountIds,
+  resolveDefaultDingTalkAccountId,
   resolveDingTalkAccount,
 } from "./accounts.js";
 import { PLUGIN_ID } from "./constants.js";
@@ -29,7 +29,132 @@ async function noteDingTalkCredentialsHelp(prompter: {
 }
 
 /**
- * DingTalk Onboarding Adapter（单账户模式）
+ * Prompt for DingTalk credentials (clientId + clientSecret)
+ */
+async function promptDingTalkCredentials(prompter: {
+  text: (opts: { message: string; validate?: (value: string) => string | undefined }) => Promise<string | symbol>;
+}): Promise<{ clientId: string; clientSecret: string }> {
+  const clientId = String(
+    await prompter.text({
+      message: "Enter DingTalk AppKey (Client ID)",
+      validate: (value) => (value?.trim() ? undefined : "Required"),
+    })
+  ).trim();
+  const clientSecret = String(
+    await prompter.text({
+      message: "Enter DingTalk AppSecret (Client Secret)",
+      validate: (value) => (value?.trim() ? undefined : "Required"),
+    })
+  ).trim();
+  return { clientId, clientSecret };
+}
+
+/** 需要从顶层迁移到 accounts.default 的字段 */
+const ACCOUNT_LEVEL_KEYS = new Set([
+  "name",
+  "clientId",
+  "clientSecret",
+  "allowFrom",
+  "groupPolicy",
+  "groupAllowFrom",
+  "groups",
+]);
+
+/**
+ * 当添加非 default 账号时，把顶层的账号级字段迁移到 accounts.default 下。
+ * 如果 accounts 字典已存在（已经是多账号模式），则不做迁移。
+ */
+function moveTopLevelToDefaultAccount(
+  section: DingTalkConfig,
+): DingTalkConfig {
+  // 已有 accounts 字典，不需要迁移
+  if (section.accounts && Object.keys(section.accounts).length > 0) {
+    return section;
+  }
+
+  const defaultAccount: Record<string, unknown> = {};
+  const cleaned: Record<string, unknown> = {};
+
+  for (const [key, value] of Object.entries(section)) {
+    if (key === "accounts" || key === "defaultAccount") {
+      cleaned[key] = value;
+    } else if (ACCOUNT_LEVEL_KEYS.has(key) && value !== undefined) {
+      defaultAccount[key] = value;
+      // 不复制到 cleaned，从顶层移除
+    } else {
+      cleaned[key] = value;
+    }
+  }
+
+  // 没有可迁移的字段
+  if (Object.keys(defaultAccount).length === 0) {
+    return section;
+  }
+
+  return {
+    ...cleaned,
+    accounts: {
+      [DEFAULT_ACCOUNT_ID]: defaultAccount,
+    },
+  } as DingTalkConfig;
+}
+
+/**
+ * Apply credentials to the config for a given accountId.
+ *
+ * 策略（与框架层 Discord/Telegram 一致）：
+ * - default 账号：写顶层（兼容单账号模式）
+ * - 非 default 账号：先把顶层账号级字段迁移到 accounts.default，再写 accounts[accountId]
+ */
+function applyCredentials(
+  cfg: Record<string, unknown>,
+  accountId: string,
+  credentials: { clientId: string; clientSecret: string }
+): Record<string, unknown> {
+  const dingtalkConfig = ((cfg.channels as Record<string, unknown>)?.[PLUGIN_ID] ?? {}) as DingTalkConfig;
+
+  if (accountId === DEFAULT_ACCOUNT_ID) {
+    // default 账号：写顶层
+    return {
+      ...cfg,
+      channels: {
+        ...(cfg.channels as Record<string, unknown>),
+        [PLUGIN_ID]: {
+          ...dingtalkConfig,
+          enabled: true,
+          clientId: credentials.clientId,
+          clientSecret: credentials.clientSecret,
+        },
+      },
+    };
+  }
+
+  // 非 default 账号：先迁移顶层到 accounts.default，再写新账号
+  const migrated = moveTopLevelToDefaultAccount(dingtalkConfig);
+
+  return {
+    ...cfg,
+    channels: {
+      ...(cfg.channels as Record<string, unknown>),
+      [PLUGIN_ID]: {
+        ...migrated,
+        enabled: true,
+        accounts: {
+          ...migrated.accounts,
+          [accountId]: {
+            ...migrated.accounts?.[accountId],
+            enabled: true,
+            clientId: credentials.clientId,
+            clientSecret: credentials.clientSecret,
+          },
+        },
+      },
+    },
+  };
+}
+
+/**
+ * DingTalk Onboarding Adapter（支持多账号）
  */
 export const dingtalkOnboardingAdapter: ChannelOnboardingAdapter = {
   channel,
@@ -49,73 +174,58 @@ export const dingtalkOnboardingAdapter: ChannelOnboardingAdapter = {
   configure: async ({
     cfg,
     prompter,
+    shouldPromptAccountIds,
+    accountOverrides,
   }) => {
     let next = cfg;
-    const resolvedAccount = resolveDingTalkAccount({ cfg: next });
-    const accountConfigured = Boolean(
-      resolvedAccount.clientId?.trim() && resolvedAccount.clientSecret?.trim()
-    );
-    const dingtalkConfig = (next.channels?.[PLUGIN_ID] ?? {}) as DingTalkConfig;
-    const hasConfigCredentials = Boolean(dingtalkConfig.clientId);
 
-    let clientId: string | null = null;
-    let clientSecret: string | null = null;
+    // 1. 解析 accountId：支持多账号选择 / 添加新账号
+    const defaultAccountId = resolveDefaultDingTalkAccountId(cfg);
+    const override = accountOverrides?.[PLUGIN_ID]?.trim();
+    let accountId = override ?? defaultAccountId;
 
-    if (!accountConfigured) {
-      await noteDingTalkCredentialsHelp(prompter);
+    if (shouldPromptAccountIds && !override) {
+      accountId = await promptAccountId({
+        cfg,
+        prompter,
+        label: "DingTalk",
+        currentId: accountId,
+        listAccountIds: listDingTalkAccountIds,
+        defaultAccountId,
+      });
     }
 
-    if (hasConfigCredentials) {
+    // 2. 检查该账号自身是否已配置凭据（不继承顶层，避免新账号误判为已配置）
+    const accountConfigured = (() => {
+      const dingtalkSection = (next.channels as Record<string, unknown>)?.[PLUGIN_ID] as DingTalkConfig | undefined;
+      if (!dingtalkSection) return false;
+      // 检查 accounts[accountId] 自身
+      const acct = dingtalkSection.accounts?.[accountId];
+      if (acct?.clientId?.trim() && acct?.clientSecret?.trim()) return true;
+      // default 账号额外兼容顶层旧配置（手动编辑或旧版迁移）
+      if (accountId === DEFAULT_ACCOUNT_ID) {
+        return Boolean(dingtalkSection.clientId?.trim() && dingtalkSection.clientSecret?.trim());
+      }
+      return false;
+    })();
+
+    // 3. 凭据输入
+    if (!accountConfigured) {
+      await noteDingTalkCredentialsHelp(prompter);
+      const credentials = await promptDingTalkCredentials(prompter);
+      next = applyCredentials(next, accountId, credentials) as typeof next;
+    } else {
       const keep = await prompter.confirm({
         message: "DingTalk credentials already configured. Keep them?",
         initialValue: true,
       });
       if (!keep) {
-        clientId = String(
-          await prompter.text({
-            message: "Enter DingTalk AppKey (Client ID)",
-            validate: (value) => (value?.trim() ? undefined : "Required"),
-          })
-        ).trim();
-        clientSecret = String(
-          await prompter.text({
-            message: "Enter DingTalk AppSecret (Client Secret)",
-            validate: (value) => (value?.trim() ? undefined : "Required"),
-          })
-        ).trim();
+        const credentials = await promptDingTalkCredentials(prompter);
+        next = applyCredentials(next, accountId, credentials) as typeof next;
       }
-    } else {
-      clientId = String(
-        await prompter.text({
-          message: "Enter DingTalk AppKey (Client ID)",
-          validate: (value) => (value?.trim() ? undefined : "Required"),
-        })
-      ).trim();
-      clientSecret = String(
-        await prompter.text({
-          message: "Enter DingTalk AppSecret (Client Secret)",
-          validate: (value) => (value?.trim() ? undefined : "Required"),
-        })
-      ).trim();
-    }
-
-    if (clientId && clientSecret) {
-      const updatedDingtalkConfig = (next.channels?.[PLUGIN_ID] ?? {}) as DingTalkConfig;
-      next = {
-        ...next,
-        channels: {
-          ...next.channels,
-          [PLUGIN_ID]: {
-            ...updatedDingtalkConfig,
-            enabled: true,
-            clientId,
-            clientSecret,
-          },
-        },
-      };
     }
 
-    return { cfg: next, accountId: DEFAULT_ACCOUNT_ID };
+    return { cfg: next, accountId };
   },
   disable: (cfg) => {
     const dingtalkConfig = (cfg.channels?.[PLUGIN_ID] ?? {}) as DingTalkConfig;

package/src/types.ts

@@ -23,13 +23,14 @@ export const DingTalkGroupConfigSchema = z.object({
 export type DingTalkGroupConfig = z.infer<typeof DingTalkGroupConfigSchema>;
 
 /**
- * 钉钉渠道配置 Schema（单账户）
+ * 单个钉钉账户配置 Schema
+ * 每个账户对应一个钉钉企业机器人应用
  */
-export const DingTalkConfigSchema = z.object({
-  /** 是否启用钉钉渠道 */
-  enabled: z.boolean().optional(),
+export const DingTalkAccountConfigSchema = z.object({
   /** 账户名称 */
   name: z.string().optional(),
+  /** 是否启用 */
+  enabled: z.boolean().optional(),
   /** 钉钉应用 AppKey */
   clientId: z.string().optional(),
   /** 钉钉应用 AppSecret */
@@ -44,6 +45,38 @@ export const DingTalkConfigSchema = z.object({
   groups: z.record(z.string(), DingTalkGroupConfigSchema).optional(),
 });
 
+export type DingTalkAccountConfig = z.infer<typeof DingTalkAccountConfigSchema>;
+
+/**
+ * 钉钉渠道配置 Schema
+ *
+ * 支持两种配置格式（兼容旧版单账户 + 新版多账户）：
+ *
+ * 单账户（旧版兼容）：
+ * ```json
+ * { "channels": { "ddingtalk": { "clientId": "xxx", "clientSecret": "yyy" } } }
+ * ```
+ *
+ * 多账户（新版）：
+ * ```json
+ * { "channels": { "ddingtalk": {
+ *     "accounts": {
+ *       "bot1": { "clientId": "xxx", "clientSecret": "yyy" },
+ *       "bot2": { "clientId": "aaa", "clientSecret": "bbb" }
+ *     },
+ *     "defaultAccount": "bot1"
+ * } } }
+ * ```
+ *
+ * 顶层字段作为所有账户的默认值，账户级字段可覆盖。
+ */
+export const DingTalkConfigSchema = DingTalkAccountConfigSchema.extend({
+  /** 多账户配置字典，key 为 accountId */
+  accounts: z.record(z.string(), DingTalkAccountConfigSchema).optional(),
+  /** 默认账户 ID（多账户时指定） */
+  defaultAccount: z.string().optional(),
+});
+
 export type DingTalkConfig = z.infer<typeof DingTalkConfigSchema>;
 
 // ======================= Resolved Account Type =======================
@@ -52,7 +85,7 @@ export type DingTalkConfig = z.infer<typeof DingTalkConfigSchema>;
  * 解析后的钉钉账户配置
  */
 export interface ResolvedDingTalkAccount {
-  /** 账户 ID（固定为 default） */
+  /** 账户 ID */
   accountId: string;
   /** 账户名称 */
   name?: string;