@adongguo/dingtalk 0.1.3

package/src/bot.ts

@@ -0,0 +1,403 @@
+import type { DWClient } from "dingtalk-stream";
+import type { ClawdbotConfig, RuntimeEnv } from "openclaw/plugin-sdk";
+import {
+  buildPendingHistoryContextFromMap,
+  recordPendingHistoryEntryIfEnabled,
+  clearHistoryEntriesIfEnabled,
+  DEFAULT_GROUP_HISTORY_LIMIT,
+  type HistoryEntry,
+} from "openclaw/plugin-sdk";
+import type { DingTalkConfig, DingTalkMessageContext, DingTalkMediaInfo, DingTalkIncomingMessage } from "./types.js";
+import { getDingTalkRuntime } from "./runtime.js";
+import {
+  resolveDingTalkGroupConfig,
+  resolveDingTalkReplyPolicy,
+  resolveDingTalkAllowlistMatch,
+  isDingTalkGroupAllowed,
+} from "./policy.js";
+import { createDingTalkReplyDispatcher } from "./reply-dispatcher.js";
+import { downloadMediaDingTalk } from "./media.js";
+
+function parseMessageContent(message: DingTalkIncomingMessage): string {
+  if (message.msgtype === "text" && message.text?.content) {
+    return message.text.content.trim();
+  }
+  if (message.msgtype === "richText" && message.content) {
+    // For richText, try to extract text content
+    try {
+      const parsed = JSON.parse(message.content);
+      return extractRichTextContent(parsed);
+    } catch {
+      return message.content;
+    }
+  }
+  // For other message types, return a placeholder
+  return `[${message.msgtype}]`;
+}
+
+function extractRichTextContent(richText: unknown): string {
+  if (!richText || typeof richText !== "object") return "";
+  const parts: string[] = [];
+
+  function traverse(node: unknown): void {
+    if (!node || typeof node !== "object") return;
+    if (Array.isArray(node)) {
+      for (const item of node) {
+        traverse(item);
+      }
+      return;
+    }
+    const obj = node as Record<string, unknown>;
+    if (obj.text && typeof obj.text === "string") {
+      parts.push(obj.text);
+    }
+    if (obj.content) {
+      traverse(obj.content);
+    }
+  }
+
+  traverse(richText);
+  return parts.join("").trim() || "[富文本消息]";
+}
+
+function checkBotMentioned(message: DingTalkIncomingMessage): boolean {
+  // In DingTalk, if the bot is mentioned, isInAtList will be true
+  if (message.isInAtList) return true;
+  // Also check atUsers array
+  if (message.atUsers && message.atUsers.length > 0) return true;
+  return false;
+}
+
+function stripBotMention(text: string): string {
+  // DingTalk mentions are typically @bot_name format
+  // The text content usually already has mentions stripped in some cases
+  // But let's clean up any remaining @mentions at the start
+  return text.replace(/^@\S+\s*/g, "").trim();
+}
+
+function inferPlaceholder(msgtype: string): string {
+  switch (msgtype) {
+    case "image":
+    case "picture":
+      return "<media:image>";
+    case "file":
+      return "<media:document>";
+    case "voice":
+      return "<media:audio>";
+    case "video":
+      return "<media:video>";
+    default:
+      return "<media:document>";
+  }
+}
+
+async function resolveDingTalkMediaList(params: {
+  cfg: ClawdbotConfig;
+  message: DingTalkIncomingMessage;
+  maxBytes: number;
+  log?: (msg: string) => void;
+  client?: DWClient;
+}): Promise<DingTalkMediaInfo[]> {
+  const { cfg, message, maxBytes, log, client } = params;
+
+  // Only process media message types
+  const mediaTypes = ["image", "picture", "file", "voice", "video"];
+  if (!mediaTypes.includes(message.msgtype)) {
+    return [];
+  }
+
+  // DingTalk requires downloadCode to download media
+  if (!message.downloadCode) {
+    log?.(`dingtalk: no downloadCode for ${message.msgtype} message`);
+    return [];
+  }
+
+  const out: DingTalkMediaInfo[] = [];
+  const core = getDingTalkRuntime();
+
+  try {
+    const result = await downloadMediaDingTalk({
+      cfg,
+      downloadCode: message.downloadCode,
+      robotCode: message.robotCode,
+      client,
+    });
+
+    if (!result) {
+      log?.(`dingtalk: failed to download ${message.msgtype} media`);
+      return [];
+    }
+
+    let contentType = result.contentType;
+    if (!contentType) {
+      contentType = await core.media.detectMime({ buffer: result.buffer });
+    }
+
+    const saved = await core.channel.media.saveMediaBuffer(
+      result.buffer,
+      contentType,
+      "inbound",
+      maxBytes,
+    );
+
+    out.push({
+      path: saved.path,
+      contentType: saved.contentType,
+      placeholder: inferPlaceholder(message.msgtype),
+    });
+
+    log?.(`dingtalk: downloaded ${message.msgtype} media, saved to ${saved.path}`);
+  } catch (err) {
+    log?.(`dingtalk: failed to download ${message.msgtype} media: ${String(err)}`);
+  }
+
+  return out;
+}
+
+function buildDingTalkMediaPayload(
+  mediaList: DingTalkMediaInfo[],
+): {
+  MediaPath?: string;
+  MediaType?: string;
+  MediaUrl?: string;
+  MediaPaths?: string[];
+  MediaUrls?: string[];
+  MediaTypes?: string[];
+} {
+  const first = mediaList[0];
+  const mediaPaths = mediaList.map((media) => media.path);
+  const mediaTypes = mediaList.map((media) => media.contentType).filter(Boolean) as string[];
+  return {
+    MediaPath: first?.path,
+    MediaType: first?.contentType,
+    MediaUrl: first?.path,
+    MediaPaths: mediaPaths.length > 0 ? mediaPaths : undefined,
+    MediaUrls: mediaPaths.length > 0 ? mediaPaths : undefined,
+    MediaTypes: mediaTypes.length > 0 ? mediaTypes : undefined,
+  };
+}
+
+export function parseDingTalkMessage(message: DingTalkIncomingMessage): DingTalkMessageContext {
+  const rawContent = parseMessageContent(message);
+  const mentionedBot = checkBotMentioned(message);
+  const content = stripBotMention(rawContent);
+  const isGroup = message.conversationType === "2";
+
+  return {
+    conversationId: message.conversationId,
+    messageId: message.msgId,
+    senderId: message.senderStaffId || "",
+    senderNick: message.senderNick,
+    chatType: isGroup ? "group" : "p2p",
+    mentionedBot,
+    sessionWebhook: message.sessionWebhook,
+    sessionWebhookExpiredTime: message.sessionWebhookExpiredTime,
+    content,
+    contentType: message.msgtype,
+    robotCode: message.robotCode,
+    chatbotCorpId: message.chatbotCorpId,
+    isAdmin: message.isAdmin,
+  };
+}
+
+export async function handleDingTalkMessage(params: {
+  cfg: ClawdbotConfig;
+  message: DingTalkIncomingMessage;
+  runtime?: RuntimeEnv;
+  chatHistories?: Map<string, HistoryEntry[]>;
+  client?: DWClient;
+}): Promise<void> {
+  const { cfg, message, runtime, chatHistories, client } = params;
+  const dingtalkCfg = cfg.channels?.dingtalk as DingTalkConfig | undefined;
+  const log = runtime?.log ?? console.log;
+  const error = runtime?.error ?? console.error;
+
+  const ctx = parseDingTalkMessage(message);
+  const isGroup = ctx.chatType === "group";
+
+  log(`dingtalk: received message from ${ctx.senderNick} (${ctx.senderId}) in ${ctx.conversationId} (${ctx.chatType})`);
+
+  const historyLimit = Math.max(
+    0,
+    dingtalkCfg?.historyLimit ?? cfg.messages?.groupChat?.historyLimit ?? DEFAULT_GROUP_HISTORY_LIMIT,
+  );
+
+  if (isGroup) {
+    const groupPolicy = dingtalkCfg?.groupPolicy ?? "open";
+    const groupAllowFrom = dingtalkCfg?.groupAllowFrom ?? [];
+    const groupConfig = resolveDingTalkGroupConfig({ cfg: dingtalkCfg, groupId: ctx.conversationId });
+
+    const senderAllowFrom = groupConfig?.allowFrom ?? groupAllowFrom;
+    const allowed = isDingTalkGroupAllowed({
+      groupPolicy,
+      allowFrom: senderAllowFrom,
+      senderId: ctx.senderId,
+      senderName: ctx.senderNick,
+    });
+
+    if (!allowed) {
+      log(`dingtalk: sender ${ctx.senderId} not in group allowlist`);
+      return;
+    }
+
+    const { requireMention } = resolveDingTalkReplyPolicy({
+      isDirectMessage: false,
+      globalConfig: dingtalkCfg,
+      groupConfig,
+    });
+
+    if (requireMention && !ctx.mentionedBot) {
+      log(`dingtalk: message in group ${ctx.conversationId} did not mention bot, recording to history`);
+      if (chatHistories) {
+        recordPendingHistoryEntryIfEnabled({
+          historyMap: chatHistories,
+          historyKey: ctx.conversationId,
+          limit: historyLimit,
+          entry: {
+            sender: ctx.senderNick || ctx.senderId,
+            body: ctx.content,
+            timestamp: Date.now(),
+            messageId: ctx.messageId,
+          },
+        });
+      }
+      return;
+    }
+  } else {
+    const dmPolicy = dingtalkCfg?.dmPolicy ?? "pairing";
+    const allowFrom = dingtalkCfg?.allowFrom ?? [];
+
+    if (dmPolicy === "allowlist") {
+      const match = resolveDingTalkAllowlistMatch({
+        allowFrom,
+        senderId: ctx.senderId,
+      });
+      if (!match.allowed) {
+        log(`dingtalk: sender ${ctx.senderId} not in DM allowlist`);
+        return;
+      }
+    }
+  }
+
+  try {
+    const core = getDingTalkRuntime();
+
+    const dingtalkFrom = isGroup ? `dingtalk:group:${ctx.conversationId}` : `dingtalk:${ctx.senderId}`;
+    const dingtalkTo = isGroup ? `chat:${ctx.conversationId}` : `user:${ctx.senderId}`;
+
+    const route = core.channel.routing.resolveAgentRoute({
+      cfg,
+      channel: "dingtalk",
+      peer: {
+        kind: isGroup ? "group" : "dm",
+        id: isGroup ? ctx.conversationId : ctx.senderId,
+      },
+    });
+
+    const preview = ctx.content.replace(/\s+/g, " ").slice(0, 160);
+    const inboundLabel = isGroup
+      ? `DingTalk message in group ${ctx.conversationId}`
+      : `DingTalk DM from ${ctx.senderNick}`;
+
+    core.system.enqueueSystemEvent(`${inboundLabel}: ${preview}`, {
+      sessionKey: route.sessionKey,
+      contextKey: `dingtalk:message:${ctx.conversationId}:${ctx.messageId}`,
+    });
+
+    // Resolve media from message
+    const mediaMaxBytes = (dingtalkCfg?.mediaMaxMb ?? 30) * 1024 * 1024; // 30MB default
+    const mediaList = await resolveDingTalkMediaList({
+      cfg,
+      message,
+      maxBytes: mediaMaxBytes,
+      log,
+      client,
+    });
+    const mediaPayload = buildDingTalkMediaPayload(mediaList);
+
+    const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(cfg);
+
+    const body = core.channel.reply.formatAgentEnvelope({
+      channel: "DingTalk",
+      from: isGroup ? ctx.conversationId : ctx.senderNick || ctx.senderId,
+      timestamp: new Date(),
+      envelope: envelopeOptions,
+      body: ctx.content,
+    });
+
+    let combinedBody = body;
+    const historyKey = isGroup ? ctx.conversationId : undefined;
+
+    if (isGroup && historyKey && chatHistories) {
+      combinedBody = buildPendingHistoryContextFromMap({
+        historyMap: chatHistories,
+        historyKey,
+        limit: historyLimit,
+        currentMessage: combinedBody,
+        formatEntry: (entry) =>
+          core.channel.reply.formatAgentEnvelope({
+            channel: "DingTalk",
+            from: ctx.conversationId,
+            timestamp: entry.timestamp,
+            body: `${entry.sender}: ${entry.body}`,
+            envelope: envelopeOptions,
+          }),
+      });
+    }
+
+    const ctxPayload = core.channel.reply.finalizeInboundContext({
+      Body: combinedBody,
+      RawBody: ctx.content,
+      CommandBody: ctx.content,
+      From: dingtalkFrom,
+      To: dingtalkTo,
+      SessionKey: route.sessionKey,
+      AccountId: route.accountId,
+      ChatType: isGroup ? "group" : "direct",
+      GroupSubject: isGroup ? ctx.conversationId : undefined,
+      SenderName: ctx.senderNick || ctx.senderId,
+      SenderId: ctx.senderId,
+      Provider: "dingtalk" as const,
+      Surface: "dingtalk" as const,
+      MessageSid: ctx.messageId,
+      Timestamp: Date.now(),
+      WasMentioned: ctx.mentionedBot,
+      CommandAuthorized: true,
+      OriginatingChannel: "dingtalk" as const,
+      OriginatingTo: dingtalkTo,
+      ...mediaPayload,
+    });
+
+    const { dispatcher, replyOptions, markDispatchIdle } = createDingTalkReplyDispatcher({
+      cfg,
+      agentId: route.agentId,
+      runtime: runtime as RuntimeEnv,
+      conversationId: ctx.conversationId,
+      sessionWebhook: ctx.sessionWebhook,
+      client,
+    });
+
+    log(`dingtalk: dispatching to agent (session=${route.sessionKey})`);
+
+    const { queuedFinal, counts } = await core.channel.reply.dispatchReplyFromConfig({
+      ctx: ctxPayload,
+      cfg,
+      dispatcher,
+      replyOptions,
+    });
+
+    markDispatchIdle();
+
+    if (isGroup && historyKey && chatHistories) {
+      clearHistoryEntriesIfEnabled({
+        historyMap: chatHistories,
+        historyKey,
+        limit: historyLimit,
+      });
+    }
+
+    log(`dingtalk: dispatch complete (queuedFinal=${queuedFinal}, replies=${counts.final})`);
+  } catch (err) {
+    error(`dingtalk: failed to dispatch message: ${String(err)}`);
+  }
+}

package/src/channel.ts

@@ -0,0 +1,220 @@
+import type { ChannelPlugin, ClawdbotConfig } from "openclaw/plugin-sdk";
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk";
+import type { ResolvedDingTalkAccount, DingTalkConfig } from "./types.js";
+import { resolveDingTalkAccount, resolveDingTalkCredentials } from "./accounts.js";
+import { dingtalkOutbound } from "./outbound.js";
+import { probeDingTalk } from "./probe.js";
+import { resolveDingTalkGroupToolPolicy } from "./policy.js";
+import { normalizeDingTalkTarget, looksLikeDingTalkId } from "./targets.js";
+import {
+  listDingTalkDirectoryPeers,
+  listDingTalkDirectoryGroups,
+  listDingTalkDirectoryPeersLive,
+  listDingTalkDirectoryGroupsLive,
+} from "./directory.js";
+import { dingtalkOnboardingAdapter } from "./onboarding.js";
+
+const meta = {
+  id: "dingtalk",
+  label: "DingTalk",
+  selectionLabel: "DingTalk (钉钉)",
+  docsPath: "/channels/dingtalk",
+  docsLabel: "dingtalk",
+  blurb: "钉钉/DingTalk enterprise messaging.",
+  aliases: ["dingding"],
+  order: 70,
+} as const;
+
+export const dingtalkPlugin: ChannelPlugin<ResolvedDingTalkAccount> = {
+  id: "dingtalk",
+  meta: {
+    ...meta,
+  },
+  pairing: {
+    idLabel: "dingtalkUserId",
+    normalizeAllowEntry: (entry) => entry.replace(/^(dingtalk|user|staff):/i, ""),
+    notifyApproval: async ({ cfg, id }) => {
+      // Note: DingTalk pairing approval requires sessionWebhook which is only available
+      // during active message handling. This is a limitation of the DingTalk API.
+      console.log(`[dingtalk] Pairing approved for user ${id}. Cannot send notification without sessionWebhook.`);
+    },
+  },
+  capabilities: {
+    chatTypes: ["direct", "channel"],
+    polls: false,
+    threads: false, // DingTalk has limited thread support
+    media: true,
+    reactions: false, // DingTalk doesn't support reactions via bot API
+    edit: false, // DingTalk doesn't support message editing via sessionWebhook
+    reply: true,
+  },
+  agentPrompt: {
+    messageToolHints: () => [
+      "- DingTalk targeting: messages are sent via sessionWebhook to the current conversation.",
+      "- DingTalk supports text, markdown, and ActionCard message types.",
+    ],
+  },
+  groups: {
+    resolveToolPolicy: resolveDingTalkGroupToolPolicy,
+  },
+  reload: { configPrefixes: ["channels.dingtalk"] },
+  configSchema: {
+    schema: {
+      type: "object",
+      additionalProperties: false,
+      properties: {
+        enabled: { type: "boolean" },
+        appKey: { type: "string" },
+        appSecret: { type: "string" },
+        robotCode: { type: "string" },
+        connectionMode: { type: "string", enum: ["stream", "webhook"] },
+        webhookPath: { type: "string" },
+        webhookPort: { type: "integer", minimum: 1 },
+        dmPolicy: { type: "string", enum: ["open", "pairing", "allowlist"] },
+        allowFrom: { type: "array", items: { oneOf: [{ type: "string" }, { type: "number" }] } },
+        groupPolicy: { type: "string", enum: ["open", "allowlist", "disabled"] },
+        groupAllowFrom: { type: "array", items: { oneOf: [{ type: "string" }, { type: "number" }] } },
+        requireMention: { type: "boolean" },
+        historyLimit: { type: "integer", minimum: 0 },
+        dmHistoryLimit: { type: "integer", minimum: 0 },
+        textChunkLimit: { type: "integer", minimum: 1 },
+        chunkMode: { type: "string", enum: ["length", "newline"] },
+        mediaMaxMb: { type: "number", minimum: 0 },
+        renderMode: { type: "string", enum: ["auto", "raw", "card"] },
+        cooldownMs: { type: "integer", minimum: 0 },
+      },
+    },
+  },
+  config: {
+    listAccountIds: () => [DEFAULT_ACCOUNT_ID],
+    resolveAccount: (cfg) => resolveDingTalkAccount({ cfg }),
+    defaultAccountId: () => DEFAULT_ACCOUNT_ID,
+    setAccountEnabled: ({ cfg, enabled }) => ({
+      ...cfg,
+      channels: {
+        ...cfg.channels,
+        dingtalk: {
+          ...cfg.channels?.dingtalk,
+          enabled,
+        },
+      },
+    }),
+    deleteAccount: ({ cfg }) => {
+      const next = { ...cfg } as ClawdbotConfig;
+      const nextChannels = { ...cfg.channels };
+      delete (nextChannels as Record<string, unknown>).dingtalk;
+      if (Object.keys(nextChannels).length > 0) {
+        next.channels = nextChannels;
+      } else {
+        delete next.channels;
+      }
+      return next;
+    },
+    isConfigured: (_account, cfg) =>
+      Boolean(resolveDingTalkCredentials(cfg.channels?.dingtalk as DingTalkConfig | undefined)),
+    describeAccount: (account) => ({
+      accountId: account.accountId,
+      enabled: account.enabled,
+      configured: account.configured,
+    }),
+    resolveAllowFrom: ({ cfg }) =>
+      (cfg.channels?.dingtalk as DingTalkConfig | undefined)?.allowFrom ?? [],
+    formatAllowFrom: ({ allowFrom }) =>
+      allowFrom
+        .map((entry) => String(entry).trim())
+        .filter(Boolean)
+        .map((entry) => entry.toLowerCase()),
+  },
+  security: {
+    collectWarnings: ({ cfg }) => {
+      const dingtalkCfg = cfg.channels?.dingtalk as DingTalkConfig | undefined;
+      const defaultGroupPolicy = (cfg.channels as Record<string, { groupPolicy?: string }> | undefined)?.defaults?.groupPolicy;
+      const groupPolicy = dingtalkCfg?.groupPolicy ?? defaultGroupPolicy ?? "allowlist";
+      if (groupPolicy !== "open") return [];
+      return [
+        `- DingTalk groups: groupPolicy="open" allows any member to trigger (mention-gated). Set channels.dingtalk.groupPolicy="allowlist" + channels.dingtalk.groupAllowFrom to restrict senders.`,
+      ];
+    },
+  },
+  setup: {
+    resolveAccountId: () => DEFAULT_ACCOUNT_ID,
+    applyAccountConfig: ({ cfg }) => ({
+      ...cfg,
+      channels: {
+        ...cfg.channels,
+        dingtalk: {
+          ...cfg.channels?.dingtalk,
+          enabled: true,
+        },
+      },
+    }),
+  },
+  onboarding: dingtalkOnboardingAdapter,
+  messaging: {
+    normalizeTarget: normalizeDingTalkTarget,
+    targetResolver: {
+      looksLikeId: looksLikeDingTalkId,
+      hint: "<conversationId|user:staffId>",
+    },
+  },
+  directory: {
+    self: async () => null,
+    listPeers: async ({ cfg, query, limit }) =>
+      listDingTalkDirectoryPeers({ cfg, query, limit }),
+    listGroups: async ({ cfg, query, limit }) =>
+      listDingTalkDirectoryGroups({ cfg, query, limit }),
+    listPeersLive: async ({ cfg, query, limit }) =>
+      listDingTalkDirectoryPeersLive({ cfg, query, limit }),
+    listGroupsLive: async ({ cfg, query, limit }) =>
+      listDingTalkDirectoryGroupsLive({ cfg, query, limit }),
+  },
+  outbound: dingtalkOutbound,
+  status: {
+    defaultRuntime: {
+      accountId: DEFAULT_ACCOUNT_ID,
+      running: false,
+      lastStartAt: null,
+      lastStopAt: null,
+      lastError: null,
+      port: null,
+    },
+    buildChannelSummary: ({ snapshot }) => ({
+      configured: snapshot.configured ?? false,
+      running: snapshot.running ?? false,
+      lastStartAt: snapshot.lastStartAt ?? null,
+      lastStopAt: snapshot.lastStopAt ?? null,
+      lastError: snapshot.lastError ?? null,
+      port: snapshot.port ?? null,
+      probe: snapshot.probe,
+      lastProbeAt: snapshot.lastProbeAt ?? null,
+    }),
+    probeAccount: async ({ cfg }) =>
+      await probeDingTalk(cfg.channels?.dingtalk as DingTalkConfig | undefined),
+    buildAccountSnapshot: ({ account, runtime, probe }) => ({
+      accountId: account.accountId,
+      enabled: account.enabled,
+      configured: account.configured,
+      running: runtime?.running ?? false,
+      lastStartAt: runtime?.lastStartAt ?? null,
+      lastStopAt: runtime?.lastStopAt ?? null,
+      lastError: runtime?.lastError ?? null,
+      port: runtime?.port ?? null,
+      probe,
+    }),
+  },
+  gateway: {
+    startAccount: async (ctx) => {
+      const { monitorDingTalkProvider } = await import("./monitor.js");
+      const dingtalkCfg = ctx.cfg.channels?.dingtalk as DingTalkConfig | undefined;
+      const port = dingtalkCfg?.webhookPort ?? null;
+      ctx.setStatus({ accountId: ctx.accountId, port });
+      ctx.log?.info(`starting dingtalk provider (mode: ${dingtalkCfg?.connectionMode ?? "stream"})`);
+      return monitorDingTalkProvider({
+        config: ctx.cfg,
+        runtime: ctx.runtime,
+        abortSignal: ctx.abortSignal,
+        accountId: ctx.accountId,
+      });
+    },
+  },
+};

package/src/client.ts

@@ -0,0 +1,49 @@
+import { DWClient } from "dingtalk-stream";
+import type { DingTalkConfig } from "./types.js";
+import { resolveDingTalkCredentials } from "./accounts.js";
+
+let cachedClient: DWClient | null = null;
+let cachedConfig: { appKey: string; appSecret: string } | null = null;
+
+export function createDingTalkClient(cfg: DingTalkConfig): DWClient {
+  const creds = resolveDingTalkCredentials(cfg);
+  if (!creds) {
+    throw new Error("DingTalk credentials not configured (appKey, appSecret required)");
+  }
+
+  if (
+    cachedClient &&
+    cachedConfig &&
+    cachedConfig.appKey === creds.appKey &&
+    cachedConfig.appSecret === creds.appSecret
+  ) {
+    return cachedClient;
+  }
+
+  const client = new DWClient({
+    clientId: creds.appKey,
+    clientSecret: creds.appSecret,
+  });
+
+  cachedClient = client;
+  cachedConfig = { appKey: creds.appKey, appSecret: creds.appSecret };
+
+  return client;
+}
+
+export function clearClientCache() {
+  if (cachedClient) {
+    try {
+      cachedClient.disconnect();
+    } catch {
+      // Ignore disconnect errors
+    }
+  }
+  cachedClient = null;
+  cachedConfig = null;
+}
+
+export async function getAccessToken(cfg: DingTalkConfig): Promise<string> {
+  const client = createDingTalkClient(cfg);
+  return await client.getAccessToken();
+}