@adongguo/dingtalk 0.1.3

package/src/reactions.ts

@@ -0,0 +1,64 @@
+import type { ClawdbotConfig } from "openclaw/plugin-sdk";
+
+// DingTalk doesn't have a message reactions API
+// This module provides stub implementations for interface compatibility
+
+export type DingTalkReaction = {
+  reactionId: string;
+  emojiType: string;
+  operatorType: "app" | "user";
+  operatorId: string;
+};
+
+/**
+ * Add a reaction (emoji) to a message.
+ * Note: DingTalk doesn't support message reactions via bot API.
+ */
+export async function addReactionDingTalk(_params: {
+  cfg: ClawdbotConfig;
+  messageId: string;
+  emojiType: string;
+}): Promise<{ reactionId: string }> {
+  // DingTalk doesn't support message reactions via bot API
+  throw new Error("DingTalk does not support message reactions via bot API");
+}
+
+/**
+ * Remove a reaction from a message.
+ * Note: DingTalk doesn't support message reactions via bot API.
+ */
+export async function removeReactionDingTalk(_params: {
+  cfg: ClawdbotConfig;
+  messageId: string;
+  reactionId: string;
+}): Promise<void> {
+  // DingTalk doesn't support message reactions via bot API
+  throw new Error("DingTalk does not support message reactions via bot API");
+}
+
+/**
+ * List all reactions for a message.
+ * Note: DingTalk doesn't support message reactions via bot API.
+ */
+export async function listReactionsDingTalk(_params: {
+  cfg: ClawdbotConfig;
+  messageId: string;
+  emojiType?: string;
+}): Promise<DingTalkReaction[]> {
+  // DingTalk doesn't support message reactions via bot API
+  return [];
+}
+
+/**
+ * Common emoji types for convenience.
+ * Note: These are placeholders since DingTalk doesn't support reactions.
+ */
+export const DingTalkEmoji = {
+  THUMBSUP: "THUMBSUP",
+  THUMBSDOWN: "THUMBSDOWN",
+  HEART: "HEART",
+  SMILE: "SMILE",
+  OK: "OK",
+} as const;
+
+export type DingTalkEmojiType = (typeof DingTalkEmoji)[keyof typeof DingTalkEmoji];

package/src/reply-dispatcher.ts

@@ -0,0 +1,167 @@
+import type { DWClient } from "dingtalk-stream";
+import {
+  createReplyPrefixContext,
+  createTypingCallbacks,
+  logTypingFailure,
+  type ClawdbotConfig,
+  type RuntimeEnv,
+  type ReplyPayload,
+} from "openclaw/plugin-sdk";
+import { getDingTalkRuntime } from "./runtime.js";
+import { sendMessageDingTalk, sendActionCardDingTalk } from "./send.js";
+import type { DingTalkConfig } from "./types.js";
+import {
+  addTypingIndicator,
+  removeTypingIndicator,
+  type TypingIndicatorState,
+} from "./typing.js";
+
+/**
+ * Detect if text contains markdown elements that benefit from card rendering.
+ * Used by auto render mode.
+ */
+function shouldUseCard(text: string): boolean {
+  // Code blocks (fenced)
+  if (/```[\s\S]*?```/.test(text)) return true;
+  // Tables (at least header + separator row with |)
+  if (/\|.+\|[\r\n]+\|[-:| ]+\|/.test(text)) return true;
+  return false;
+}
+
+export type CreateDingTalkReplyDispatcherParams = {
+  cfg: ClawdbotConfig;
+  agentId: string;
+  runtime: RuntimeEnv;
+  conversationId: string;
+  sessionWebhook: string;
+  client?: DWClient;
+};
+
+export function createDingTalkReplyDispatcher(params: CreateDingTalkReplyDispatcherParams) {
+  const core = getDingTalkRuntime();
+  const { cfg, agentId, conversationId, sessionWebhook, client } = params;
+
+  const prefixContext = createReplyPrefixContext({
+    cfg,
+    agentId,
+  });
+
+  // DingTalk doesn't have a native typing indicator API.
+  // We could use emoji reactions if available.
+  let typingState: TypingIndicatorState | null = null;
+
+  const typingCallbacks = createTypingCallbacks({
+    start: async () => {
+      // DingTalk typing indicator is optional and may not work for all bots
+      try {
+        typingState = await addTypingIndicator({ cfg, sessionWebhook });
+        params.runtime.log?.(`dingtalk: added typing indicator`);
+      } catch {
+        // Typing indicator not available, ignore
+      }
+    },
+    stop: async () => {
+      if (!typingState) return;
+      try {
+        await removeTypingIndicator({ cfg, state: typingState });
+        typingState = null;
+        params.runtime.log?.(`dingtalk: removed typing indicator`);
+      } catch {
+        // Ignore errors
+      }
+    },
+    onStartError: (err) => {
+      logTypingFailure({
+        log: (message) => params.runtime.log?.(message),
+        channel: "dingtalk",
+        action: "start",
+        error: err,
+      });
+    },
+    onStopError: (err) => {
+      logTypingFailure({
+        log: (message) => params.runtime.log?.(message),
+        channel: "dingtalk",
+        action: "stop",
+        error: err,
+      });
+    },
+  });
+
+  const textChunkLimit = core.channel.text.resolveTextChunkLimit({
+    cfg,
+    channel: "dingtalk",
+    defaultLimit: 4000,
+  });
+  const chunkMode = core.channel.text.resolveChunkMode(cfg, "dingtalk");
+  const tableMode = core.channel.text.resolveMarkdownTableMode({
+    cfg,
+    channel: "dingtalk",
+  });
+
+  const { dispatcher, replyOptions, markDispatchIdle } =
+    core.channel.reply.createReplyDispatcherWithTyping({
+      responsePrefix: prefixContext.responsePrefix,
+      responsePrefixContextProvider: prefixContext.responsePrefixContextProvider,
+      humanDelay: core.channel.reply.resolveHumanDelayConfig(cfg, agentId),
+      onReplyStart: typingCallbacks.onReplyStart,
+      deliver: async (payload: ReplyPayload) => {
+        params.runtime.log?.(`dingtalk deliver called: text=${payload.text?.slice(0, 100)}`);
+        const text = payload.text ?? "";
+        if (!text.trim()) {
+          params.runtime.log?.(`dingtalk deliver: empty text, skipping`);
+          return;
+        }
+
+        // Check render mode: auto (default), raw, or card
+        const dingtalkCfg = cfg.channels?.dingtalk as DingTalkConfig | undefined;
+        const renderMode = dingtalkCfg?.renderMode ?? "auto";
+
+        // Determine if we should use card for this message
+        const useCard =
+          renderMode === "card" || (renderMode === "auto" && shouldUseCard(text));
+
+        if (useCard) {
+          // Card mode: send as ActionCard with markdown rendering
+          const chunks = core.channel.text.chunkTextWithMode(text, textChunkLimit, chunkMode);
+          params.runtime.log?.(`dingtalk deliver: sending ${chunks.length} card chunks to ${conversationId}`);
+          for (const chunk of chunks) {
+            await sendActionCardDingTalk({
+              cfg,
+              sessionWebhook,
+              title: "Reply",
+              text: chunk,
+              client,
+            });
+          }
+        } else {
+          // Raw mode: send as plain text with table conversion
+          const converted = core.channel.text.convertMarkdownTables(text, tableMode);
+          const chunks = core.channel.text.chunkTextWithMode(converted, textChunkLimit, chunkMode);
+          params.runtime.log?.(`dingtalk deliver: sending ${chunks.length} text chunks to ${conversationId}`);
+          for (const chunk of chunks) {
+            await sendMessageDingTalk({
+              cfg,
+              sessionWebhook,
+              text: chunk,
+              client,
+            });
+          }
+        }
+      },
+      onError: (err, info) => {
+        params.runtime.error?.(`dingtalk ${info.kind} reply failed: ${String(err)}`);
+        typingCallbacks.onIdle?.();
+      },
+      onIdle: typingCallbacks.onIdle,
+    });
+
+  return {
+    dispatcher,
+    replyOptions: {
+      ...replyOptions,
+      onModelSelected: prefixContext.onModelSelected,
+    },
+    markDispatchIdle,
+  };
+}

package/src/runtime.ts

@@ -0,0 +1,14 @@
+import type { PluginRuntime } from "openclaw/plugin-sdk";
+
+let runtime: PluginRuntime | null = null;
+
+export function setDingTalkRuntime(next: PluginRuntime) {
+  runtime = next;
+}
+
+export function getDingTalkRuntime(): PluginRuntime {
+  if (!runtime) {
+    throw new Error("DingTalk runtime not initialized");
+  }
+  return runtime;
+}

package/src/send.ts

@@ -0,0 +1,314 @@
+import type { ClawdbotConfig } from "openclaw/plugin-sdk";
+import type { DWClient } from "dingtalk-stream";
+import type {
+  DingTalkConfig,
+  DingTalkSendResult,
+  DingTalkTextMessage,
+  DingTalkMarkdownMessage,
+  DingTalkActionCardMessage,
+  DingTalkOutboundMessage,
+} from "./types.js";
+import { getDingTalkRuntime } from "./runtime.js";
+
+export type DingTalkMessageInfo = {
+  messageId: string;
+  conversationId: string;
+  senderId?: string;
+  content: string;
+  contentType: string;
+  createTime?: number;
+};
+
+/**
+ * Send a message via DingTalk sessionWebhook.
+ * This is the primary method for sending messages in response to incoming messages.
+ */
+export async function sendViaWebhook(params: {
+  sessionWebhook: string;
+  message: DingTalkOutboundMessage;
+  accessToken?: string;
+}): Promise<DingTalkSendResult> {
+  const { sessionWebhook, message, accessToken } = params;
+
+  const headers: Record<string, string> = {
+    "Content-Type": "application/json",
+  };
+
+  if (accessToken) {
+    headers["x-acs-dingtalk-access-token"] = accessToken;
+  }
+
+  const response = await fetch(sessionWebhook, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(message),
+  });
+
+  if (!response.ok) {
+    const text = await response.text();
+    throw new Error(`DingTalk webhook send failed: ${response.status} ${text}`);
+  }
+
+  const result = await response.json() as { errcode?: number; errmsg?: string; processQueryKey?: string };
+
+  if (result.errcode && result.errcode !== 0) {
+    throw new Error(`DingTalk send failed: ${result.errmsg || `code ${result.errcode}`}`);
+  }
+
+  return {
+    conversationId: "",
+    processQueryKey: result.processQueryKey,
+  };
+}
+
+export type SendDingTalkMessageParams = {
+  cfg: ClawdbotConfig;
+  sessionWebhook: string;
+  text: string;
+  atUserIds?: string[];
+  client?: DWClient;
+};
+
+export async function sendMessageDingTalk(params: SendDingTalkMessageParams): Promise<DingTalkSendResult> {
+  const { cfg, sessionWebhook, text, atUserIds, client } = params;
+  const dingtalkCfg = cfg.channels?.dingtalk as DingTalkConfig | undefined;
+  if (!dingtalkCfg) {
+    throw new Error("DingTalk channel not configured");
+  }
+
+  const tableMode = getDingTalkRuntime().channel.text.resolveMarkdownTableMode({
+    cfg,
+    channel: "dingtalk",
+  });
+  const messageText = getDingTalkRuntime().channel.text.convertMarkdownTables(text ?? "", tableMode);
+
+  const message: DingTalkTextMessage = {
+    msgtype: "text",
+    text: {
+      content: messageText,
+    },
+  };
+
+  if (atUserIds && atUserIds.length > 0) {
+    message.at = {
+      atUserIds,
+      isAtAll: false,
+    };
+  }
+
+  let accessToken: string | undefined;
+  if (client) {
+    try {
+      accessToken = await client.getAccessToken();
+    } catch {
+      // Proceed without access token
+    }
+  }
+
+  return sendViaWebhook({ sessionWebhook, message, accessToken });
+}
+
+export type SendDingTalkMarkdownParams = {
+  cfg: ClawdbotConfig;
+  sessionWebhook: string;
+  title: string;
+  text: string;
+  atUserIds?: string[];
+  client?: DWClient;
+};
+
+export async function sendMarkdownDingTalk(params: SendDingTalkMarkdownParams): Promise<DingTalkSendResult> {
+  const { sessionWebhook, title, text, atUserIds, client } = params;
+
+  const message: DingTalkMarkdownMessage = {
+    msgtype: "markdown",
+    markdown: {
+      title,
+      text,
+    },
+  };
+
+  if (atUserIds && atUserIds.length > 0) {
+    message.at = {
+      atUserIds,
+      isAtAll: false,
+    };
+  }
+
+  let accessToken: string | undefined;
+  if (client) {
+    try {
+      accessToken = await client.getAccessToken();
+    } catch {
+      // Proceed without access token
+    }
+  }
+
+  return sendViaWebhook({ sessionWebhook, message, accessToken });
+}
+
+export type SendDingTalkActionCardParams = {
+  cfg: ClawdbotConfig;
+  sessionWebhook: string;
+  title: string;
+  text: string;
+  singleTitle?: string;
+  singleURL?: string;
+  client?: DWClient;
+};
+
+export async function sendActionCardDingTalk(params: SendDingTalkActionCardParams): Promise<DingTalkSendResult> {
+  const { sessionWebhook, title, text, singleTitle, singleURL, client } = params;
+
+  const message: DingTalkActionCardMessage = {
+    msgtype: "actionCard",
+    actionCard: {
+      title,
+      text,
+      singleTitle,
+      singleURL,
+    },
+  };
+
+  let accessToken: string | undefined;
+  if (client) {
+    try {
+      accessToken = await client.getAccessToken();
+    } catch {
+      // Proceed without access token
+    }
+  }
+
+  return sendViaWebhook({ sessionWebhook, message, accessToken });
+}
+
+/**
+ * Build an ActionCard message with markdown content.
+ * ActionCards render markdown properly (code blocks, tables, links, etc.)
+ */
+export function buildMarkdownCard(text: string, title?: string): DingTalkActionCardMessage {
+  return {
+    msgtype: "actionCard",
+    actionCard: {
+      title: title || "Message",
+      text,
+    },
+  };
+}
+
+/**
+ * Send a message as an ActionCard (for better markdown rendering).
+ */
+export async function sendMarkdownCardDingTalk(params: {
+  cfg: ClawdbotConfig;
+  sessionWebhook: string;
+  text: string;
+  title?: string;
+  client?: DWClient;
+}): Promise<DingTalkSendResult> {
+  const { cfg, sessionWebhook, text, title, client } = params;
+  const message = buildMarkdownCard(text, title);
+
+  let accessToken: string | undefined;
+  if (client) {
+    try {
+      accessToken = await client.getAccessToken();
+    } catch {
+      // Proceed without access token
+    }
+  }
+
+  return sendViaWebhook({ sessionWebhook, message, accessToken });
+}
+
+// ============ Simplified Send Functions (for streaming-handler) ============
+
+/**
+ * Send a text message via sessionWebhook (simplified, no cfg required).
+ */
+export async function sendDingTalkTextMessage(params: {
+  sessionWebhook: string;
+  text: string;
+  atUserId?: string;
+  client?: DWClient;
+}): Promise<DingTalkSendResult> {
+  const { sessionWebhook, text, atUserId, client } = params;
+
+  const message: DingTalkTextMessage = {
+    msgtype: "text",
+    text: { content: text },
+  };
+
+  if (atUserId) {
+    message.at = { atUserIds: [atUserId], isAtAll: false };
+  }
+
+  let accessToken: string | undefined;
+  if (client) {
+    try {
+      accessToken = await client.getAccessToken();
+    } catch {
+      // Proceed without access token
+    }
+  }
+
+  return sendViaWebhook({ sessionWebhook, message, accessToken });
+}
+
+/**
+ * Send a message via sessionWebhook with smart text/markdown selection.
+ */
+export async function sendDingTalkMessage(params: {
+  sessionWebhook: string;
+  text: string;
+  useMarkdown?: boolean;
+  title?: string;
+  atUserId?: string;
+  client?: DWClient;
+}): Promise<DingTalkSendResult> {
+  const { sessionWebhook, text, useMarkdown, title, atUserId, client } = params;
+
+  // Auto-detect markdown
+  const hasMarkdown = /^[#*>-]|[*_`#\[\]]/.test(text) || text.includes("\n");
+  const shouldUseMarkdown = useMarkdown !== false && (useMarkdown || hasMarkdown);
+
+  let accessToken: string | undefined;
+  if (client) {
+    try {
+      accessToken = await client.getAccessToken();
+    } catch {
+      // Proceed without access token
+    }
+  }
+
+  if (shouldUseMarkdown) {
+    const markdownTitle =
+      title || text.split("\n")[0].replace(/^[#*\s\->]+/, "").slice(0, 20) || "Message";
+
+    const message: DingTalkMarkdownMessage = {
+      msgtype: "markdown",
+      markdown: {
+        title: markdownTitle,
+        text: atUserId ? `${text} @${atUserId}` : text,
+      },
+    };
+
+    if (atUserId) {
+      message.at = { atUserIds: [atUserId], isAtAll: false };
+    }
+
+    return sendViaWebhook({ sessionWebhook, message, accessToken });
+  }
+
+  // Plain text
+  const message: DingTalkTextMessage = {
+    msgtype: "text",
+    text: { content: text },
+  };
+
+  if (atUserId) {
+    message.at = { atUserIds: [atUserId], isAtAll: false };
+  }
+
+  return sendViaWebhook({ sessionWebhook, message, accessToken });
+}

package/src/session.ts

@@ -0,0 +1,144 @@
+/**
+ * Session Management for DingTalk
+ *
+ * Handles session timeout and new session commands.
+ * Provides session key generation for conversation persistence.
+ */
+
+// ============ Types ============
+
+export interface UserSession {
+  lastActivity: number;
+  sessionId: string; // Format: dingtalk:<senderId> or dingtalk:<senderId>:<timestamp>
+}
+
+interface Logger {
+  info?: (msg: string) => void;
+  warn?: (msg: string) => void;
+  error?: (msg: string) => void;
+}
+
+// ============ Constants ============
+
+/** Commands that trigger a new session */
+const NEW_SESSION_COMMANDS = ["/new", "/reset", "/clear", "新会话", "重新开始", "清空对话"];
+
+/** Default session timeout: 30 minutes */
+export const DEFAULT_SESSION_TIMEOUT = 1800000;
+
+// ============ Session Storage ============
+
+/** User session cache Map<senderId, UserSession> */
+const userSessions = new Map<string, UserSession>();
+
+// ============ Functions ============
+
+/**
+ * Check if a message is a new session command.
+ */
+export function isNewSessionCommand(text: string): boolean {
+  const trimmed = text.trim().toLowerCase();
+  return NEW_SESSION_COMMANDS.some((cmd) => trimmed === cmd.toLowerCase());
+}
+
+/**
+ * Get list of new session commands for display purposes.
+ */
+export function getNewSessionCommands(): readonly string[] {
+  return NEW_SESSION_COMMANDS;
+}
+
+/**
+ * Get or create a session key for a user.
+ *
+ * @param senderId - The sender's ID
+ * @param forceNew - Force creation of a new session
+ * @param sessionTimeout - Session timeout in milliseconds
+ * @param log - Optional logger
+ * @returns Session key and whether it's a new session
+ */
+export function getSessionKey(
+  senderId: string,
+  forceNew: boolean,
+  sessionTimeout: number,
+  log?: Logger,
+): { sessionKey: string; isNew: boolean } {
+  const now = Date.now();
+  const existing = userSessions.get(senderId);
+
+  // Force new session
+  if (forceNew) {
+    const sessionId = `dingtalk:${senderId}:${now}`;
+    userSessions.set(senderId, { lastActivity: now, sessionId });
+    log?.info?.(`[DingTalk][Session] User requested new session: ${senderId}`);
+    return { sessionKey: sessionId, isNew: true };
+  }
+
+  // Check timeout
+  if (existing) {
+    const elapsed = now - existing.lastActivity;
+    if (elapsed > sessionTimeout) {
+      const sessionId = `dingtalk:${senderId}:${now}`;
+      userSessions.set(senderId, { lastActivity: now, sessionId });
+      log?.info?.(
+        `[DingTalk][Session] Session timeout (${Math.round(elapsed / 60000)} min), auto new session: ${senderId}`,
+      );
+      return { sessionKey: sessionId, isNew: true };
+    }
+    // Update activity time
+    existing.lastActivity = now;
+    return { sessionKey: existing.sessionId, isNew: false };
+  }
+
+  // First session
+  const sessionId = `dingtalk:${senderId}`;
+  userSessions.set(senderId, { lastActivity: now, sessionId });
+  log?.info?.(`[DingTalk][Session] New user first session: ${senderId}`);
+  return { sessionKey: sessionId, isNew: false };
+}
+
+/**
+ * Clear a user's session.
+ */
+export function clearSession(senderId: string): void {
+  userSessions.delete(senderId);
+}
+
+/**
+ * Get session info for a user (for debugging).
+ */
+export function getSessionInfo(senderId: string): UserSession | undefined {
+  return userSessions.get(senderId);
+}
+
+/**
+ * Clear all sessions (for testing or reset).
+ */
+export function clearAllSessions(): void {
+  userSessions.clear();
+}
+
+/**
+ * Get the number of active sessions.
+ */
+export function getActiveSessionCount(): number {
+  return userSessions.size;
+}
+
+/**
+ * Clean up expired sessions.
+ * Call this periodically to prevent memory leaks.
+ */
+export function cleanupExpiredSessions(sessionTimeout: number): number {
+  const now = Date.now();
+  let cleaned = 0;
+
+  for (const [senderId, session] of userSessions.entries()) {
+    if (now - session.lastActivity > sessionTimeout) {
+      userSessions.delete(senderId);
+      cleaned++;
+    }
+  }
+
+  return cleaned;
+}