@soimy/dingtalk 3.5.2 → 3.6.0

package/src/media-utils.ts

@@ -13,6 +13,7 @@ import { lookup as dnsLookup } from "node:dns/promises";
 import { BlockList, isIP } from "node:net";
 import axios from "./http-client";
 import FormData from "form-data";
+import { runFfmpeg, runFfprobe } from "openclaw/plugin-sdk/media-runtime";
 import type { DingTalkConfig, Logger } from "./types";
 import { formatDingTalkErrorPayloadLog, getProxyBypassOption } from "./utils";
 import { getDingTalkRuntime } from "./runtime";
@@ -207,6 +208,122 @@ export async function getMp3DurationSeconds(filePathOrBuffer: string | Buffer, l
 }
 
 const DEFAULT_VOICE_DURATION_MS = 1000;
+const DINGTALK_VOICE_UPLOAD_EXTENSIONS = new Set([".ogg", ".amr"]);
+const DINGTALK_VOICE_INPUT_EXTENSIONS = new Set([".ogg", ".amr", ".mp3", ".wav"]);
+
+async function getDurationMsWithFfprobe(filePath: string, log?: Logger): Promise<number> {
+  try {
+    const stdout = await runFfprobe([
+      "-v",
+      "error",
+      "-show_entries",
+      "format=duration",
+      "-of",
+      "csv=p=0",
+      filePath,
+    ]);
+    const duration = Number.parseFloat(stdout.trim());
+    if (!Number.isFinite(duration) || duration <= 0) {
+      return 0;
+    }
+    return Math.max(1, Math.round(duration * 1000));
+  } catch (err: unknown) {
+    log?.warn?.(`[DingTalk] Failed to probe voice duration: ${err instanceof Error ? err.message : String(err)}`);
+    return 0;
+  }
+}
+
+async function prepareVoiceUploadPath(
+  mediaPath: string,
+  log?: Logger,
+): Promise<{ path: string; cleanup?: () => Promise<void> }> {
+  const ext = path.extname(mediaPath).toLowerCase();
+  if (DINGTALK_VOICE_UPLOAD_EXTENSIONS.has(ext)) {
+    return { path: mediaPath };
+  }
+
+  const outputPath = path.join(os.tmpdir(), `dingtalk_voice_${randomUUID()}.ogg`);
+  await runFfmpeg([
+    "-y",
+    "-i",
+    mediaPath,
+    "-vn",
+    "-sn",
+    "-dn",
+    "-ar",
+    "16000",
+    "-ac",
+    "1",
+    "-c:a",
+    "libopus",
+    "-b:a",
+    "24k",
+    outputPath,
+  ]);
+
+  log?.debug?.(`[DingTalk] Transcoded voice upload to OGG: ${mediaPath} -> ${outputPath}`);
+
+  return {
+    path: outputPath,
+    cleanup: async () => {
+      await fsPromises.rm(outputPath, { force: true });
+    },
+  };
+}
+
+function getWavDurationMsFromBuffer(buffer: Buffer, log?: Logger): number {
+  try {
+    if (buffer.length < 44 || buffer.toString("ascii", 0, 4) !== "RIFF" || buffer.toString("ascii", 8, 12) !== "WAVE") {
+      return 0;
+    }
+
+    let offset = 12;
+    let byteRate = 0;
+    let sampleRate = 0;
+    let channels = 0;
+    let bitsPerSample = 0;
+    let dataSize = 0;
+
+    while (offset + 8 <= buffer.length) {
+      const chunkId = buffer.toString("ascii", offset, offset + 4);
+      const chunkSize = buffer.readUInt32LE(offset + 4);
+      const chunkDataStart = offset + 8;
+      const paddedChunkSize = chunkSize + (chunkSize % 2);
+
+      if (chunkDataStart + chunkSize > buffer.length) {
+        break;
+      }
+
+      if (chunkId === "fmt " && chunkSize >= 16) {
+        channels = buffer.readUInt16LE(chunkDataStart + 2);
+        sampleRate = buffer.readUInt32LE(chunkDataStart + 4);
+        byteRate = buffer.readUInt32LE(chunkDataStart + 8);
+        bitsPerSample = buffer.readUInt16LE(chunkDataStart + 14);
+      } else if (chunkId === "data") {
+        dataSize = chunkSize;
+      }
+
+      if (dataSize > 0 && (byteRate > 0 || (sampleRate > 0 && channels > 0 && bitsPerSample > 0))) {
+        break;
+      }
+
+      offset = chunkDataStart + paddedChunkSize;
+    }
+
+    const effectiveByteRate = byteRate || (sampleRate > 0 && channels > 0 && bitsPerSample > 0
+      ? sampleRate * channels * (bitsPerSample / 8)
+      : 0);
+
+    if (effectiveByteRate <= 0 || dataSize <= 0) {
+      return 0;
+    }
+
+    return Math.max(1, Math.round((dataSize / effectiveByteRate) * 1000));
+  } catch (err: unknown) {
+    log?.warn?.(`[DingTalk] Failed to parse WAV duration: ${err instanceof Error ? err.message : String(err)}`);
+    return 0;
+  }
+}
 
 export async function getVoiceDurationMs(
   filePath: string,
@@ -240,6 +357,26 @@ export async function getVoiceDurationMs(
     return DEFAULT_VOICE_DURATION_MS;
   }
 
+  if (ext === ".wav") {
+    try {
+      const buffer = options?.preReadBuffer
+        ?? (await readMediaBuffer(filePath, options, log)).buffer;
+      const durationMs = getWavDurationMsFromBuffer(buffer, log);
+      if (durationMs > 0) {
+        return durationMs;
+      }
+    } catch {
+      // Fall through to the safe default below.
+    }
+  }
+
+  if (ext === ".ogg" || ext === ".amr") {
+    const durationMs = await getDurationMsWithFfprobe(filePath, log);
+    if (durationMs > 0) {
+      return durationMs;
+    }
+  }
+
   return DEFAULT_VOICE_DURATION_MS;
 }
 
@@ -339,7 +476,7 @@ function isAllowedByMediaUrlAllowlist(url: URL, mediaUrlAllowlist: string[]): bo
  * Detect media type from file extension
  * Matches DingTalk's supported media types:
  * - image: jpg, gif, png, bmp (max 20MB)
- * - voice: amr, mp3, wav (max 2MB)
+ * - voice: ogg, amr, mp3, wav (max 2MB)
  * - video: mp4 (max 20MB)
  * - file: doc, docx, xls, xlsx, ppt, pptx, zip, pdf, rar (max 20MB)
  *
@@ -351,7 +488,7 @@ export function detectMediaTypeFromExtension(filePath: string): DingTalkMediaTyp
 
   if ([".jpg", ".jpeg", ".png", ".gif", ".bmp"].includes(ext)) {
     return "image";
-  } else if ([".mp3", ".amr", ".wav"].includes(ext)) {
+  } else if ([".ogg", ".mp3", ".amr", ".wav"].includes(ext)) {
     return "voice";
   } else if ([".mp4", ".avi", ".mov"].includes(ext)) {
     return "video";
@@ -386,8 +523,8 @@ export function resolveOutboundMediaType(params: {
       throw new Error('asVoice requires mediaType="voice" when mediaType is provided.');
     }
 
-    if (detectedType !== "voice") {
-      throw new Error("asVoice requires an audio file (mp3, amr, wav).");
+    if (detectedType !== "voice" || !DINGTALK_VOICE_INPUT_EXTENSIONS.has(path.extname(params.mediaPath).toLowerCase())) {
+      throw new Error("asVoice requires an audio file (ogg, amr, mp3, wav).");
     }
 
     return "voice";
@@ -397,6 +534,12 @@ export function resolveOutboundMediaType(params: {
     return explicitType;
   }
 
+  // Audio files default to "file" (attachment) unless asVoice is explicitly set.
+  // This prevents mp3/wav/ogg/amr from being sent as voice messages unexpectedly.
+  if (detectedType === "voice") {
+    return "file";
+  }
+
   return detectedType;
 }
 
@@ -687,6 +830,12 @@ export interface UploadMediaResult {
   mediaId: string;
   /** The file buffer read during upload, reusable for voice duration parsing etc. */
   buffer: Buffer;
+  /**
+   * Voice duration captured before any temporary transcoded file is cleaned up.
+   * This is the stable field callers should use instead of depending on any
+   * upload-time temp path lifecycle.
+   */
+  durationMs?: number;
 }
 
 export async function uploadMedia(
@@ -697,11 +846,22 @@ export async function uploadMedia(
   log?: Logger,
   options?: { mediaLocalRoots?: string[] },
 ): Promise<UploadMediaResult | null> {
+  let voicePreparedCleanup: (() => Promise<void>) | undefined;
   try {
     const token = await getAccessToken(config, log);
+    let resolvedMediaPath = mediaPath;
+
+    if (mediaType === "voice") {
+      const prepared = await prepareVoiceUploadPath(mediaPath, log);
+      resolvedMediaPath = prepared.path;
+      voicePreparedCleanup = prepared.cleanup;
+    }
 
     // Read file via sandbox-aware bridge (falls back to direct fs for host paths)
-    const { buffer, size } = await readMediaBuffer(mediaPath, options, log);
+    const { buffer, size } = await readMediaBuffer(resolvedMediaPath, options, log);
+    const durationMs = mediaType === "voice"
+      ? await getVoiceDurationMs(resolvedMediaPath, mediaType, log, { ...options, preReadBuffer: buffer })
+      : undefined;
 
     // Check file size
     const sizeLimit = FILE_SIZE_LIMITS[mediaType];
@@ -714,7 +874,7 @@ export async function uploadMedia(
       return null;
     }
 
-    const filename = path.basename(mediaPath);
+    const filename = path.basename(resolvedMediaPath);
 
     // Upload to DingTalk's media server using form-data
     const form = new FormData();
@@ -735,7 +895,7 @@ export async function uploadMedia(
       log?.debug?.(
         `[DingTalk] Media uploaded successfully: ${response.data.media_id} (${size} bytes)`,
       );
-      return { mediaId: response.data.media_id, buffer };
+      return { mediaId: response.data.media_id, buffer, durationMs };
     } else {
       log?.error?.(`[DingTalk] Media upload failed: ${JSON.stringify(response.data)}`);
       return null;
@@ -758,5 +918,7 @@ export async function uploadMedia(
       }
     }
     return null;
+  } finally {
+    await voicePreparedCleanup?.();
   }
 }

package/src/message-utils.ts

@@ -1,11 +1,18 @@
-import type { AtMention, DingTalkInboundMessage, MessageContent, QuotedInfo, SendMessageOptions } from "./types";
-
+import type {
+  AtMention,
+  DingTalkInboundMessage,
+  MessageContent,
+  QuotedInfo,
+  SendMessageOptions,
+} from "./types";
 
 interface DingTalkDocMeta {
   spaceId: string;
   fileId: string;
 }
 
+const UNKNOWN_PERSON_LABEL = "某人";
+
 function parseBizCustomActionUrl(url: string | undefined): DingTalkDocMeta | null {
   if (!url || typeof url !== "string") {
     return null;
@@ -76,7 +83,7 @@ function extractRichTextQuoteParts(
           ? part.atName
           : typeof textValue === "string"
             ? textValue
-            : "某人";
+            : UNKNOWN_PERSON_LABEL;
       textParts.push(`@${atName}`);
       continue;
     }
@@ -94,10 +101,20 @@ function extractRichTextQuoteParts(
   return {
     summary,
     pictureDownloadCode,
-    pictureDownloadCodes: uniquePictureDownloadCodes.length > 0 ? uniquePictureDownloadCodes : undefined,
+    pictureDownloadCodes:
+      uniquePictureDownloadCodes.length > 0 ? uniquePictureDownloadCodes : undefined,
   };
 }
 
+function extractAtMentionsFromText(text: string): AtMention[] {
+  const mentions: AtMention[] = [];
+  const matches = text.matchAll(/(?<!\w)@([^\s@.]+)(?!\.\w)/g);
+  for (const match of matches) {
+    mentions.push({ name: match[1].trim() });
+  }
+  return mentions;
+}
+
 function trimString(value: string | undefined): string | undefined {
   if (typeof value !== "string") {
     return undefined;
@@ -106,7 +123,101 @@ function trimString(value: string | undefined): string | undefined {
   return trimmed.length > 0 ? trimmed : undefined;
 }
 
-function buildQuotedMessageTypePlaceholder(messageType: string | undefined, fileName?: string): string | undefined {
+const MAX_CHAT_RECORD_ENTRIES = 30;
+
+function stringifyChatRecordContentValue(value: unknown): string | undefined {
+  if (typeof value === "string") {
+    return trimString(value);
+  }
+  if (!value || typeof value !== "object") {
+    return undefined;
+  }
+  const record = value as Record<string, unknown>;
+  const content = record.content;
+  const contentText =
+    typeof content === "string"
+      ? trimString(content)
+      : content && typeof content === "object"
+        ? trimString((content as Record<string, unknown>).text as string | undefined)
+        : undefined;
+
+  // Preserve DingTalk's observed chatRecord text priority: explicit text first,
+  // then nested content text, then the legacy message fallback.
+  return (
+    trimString(record.text as string | undefined) ||
+    contentText ||
+    trimString(record.message as string | undefined)
+  );
+}
+
+function getChatRecordEntriesSource(content: Record<string, unknown> | undefined): unknown {
+  return content?.chatRecord ?? content?.records ?? content?.messages;
+}
+
+function formatChatRecordEntries(rawRecord: unknown): string[] {
+  let entries = rawRecord;
+  if (typeof rawRecord === "string") {
+    const trimmed = rawRecord.trim();
+    if (!trimmed || trimmed === "[]") {
+      return [];
+    }
+    try {
+      entries = JSON.parse(trimmed);
+    } catch {
+      return [];
+    }
+  }
+  if (!Array.isArray(entries)) {
+    return [];
+  }
+  return entries
+    .map((entry) => {
+      if (!entry || typeof entry !== "object") {
+        return undefined;
+      }
+      const record = entry as Record<string, unknown>;
+      const sender =
+        trimString(record.senderName as string | undefined) ||
+        trimString(record.senderNick as string | undefined) ||
+        trimString(record.sender as string | undefined) ||
+        trimString(record.senderId as string | undefined) ||
+        UNKNOWN_PERSON_LABEL;
+      const body = stringifyChatRecordContentValue(
+        record.content ?? record.text ?? record.message ?? record.body,
+      );
+      return body ? `${sender}: ${body}` : undefined;
+    })
+    .filter((line): line is string => Boolean(line))
+    .slice(0, MAX_CHAT_RECORD_ENTRIES);
+}
+
+function formatChatRecordPreview(
+  content: Record<string, unknown> | undefined,
+  options: { useTitleAsLabel?: boolean } = {},
+): string | undefined {
+  const summary = typeof content?.summary === "string" ? content.summary.trim() : "";
+  const title = typeof content?.title === "string" ? content.title.trim() : "";
+  const rawRecord = getChatRecordEntriesSource(content);
+  const recordLines = formatChatRecordEntries(rawRecord);
+  const parts: string[] = [];
+  if (summary && summary !== "[]") {
+    const label = options.useTitleAsLabel
+      ? title
+        ? `[${title}] `
+        : "[聊天记录] "
+      : "[聊天记录摘要] ";
+    parts.push(`${label}${summary}`);
+  }
+  if (recordLines.length > 0) {
+    parts.push(`[聊天记录内容]\n${recordLines.join("\n")}`);
+  }
+  return parts.join("\n\n") || undefined;
+}
+
+function buildQuotedMessageTypePlaceholder(
+  messageType: string | undefined,
+  fileName?: string,
+): string | undefined {
   switch (messageType) {
     case "text":
       return undefined;
@@ -138,8 +249,7 @@ function buildLegacyQuoteMessagePreview(message: DingTalkInboundMessage["quoteMe
   const previewMessageType = trimString(message?.msgtype);
   return {
     previewText:
-      trimString(message?.text?.content) ||
-      buildQuotedMessageTypePlaceholder(previewMessageType),
+      trimString(message?.text?.content) || buildQuotedMessageTypePlaceholder(previewMessageType),
     previewMessageType,
     previewSenderId: trimString(message?.senderId),
   };
@@ -193,7 +303,10 @@ function buildRepliedMessagePreview(params: {
     return {
       isQuotedFile: true,
       fileCreatedAt: repliedMsg.createdAt,
-      previewText: buildQuotedMessageTypePlaceholder(repliedMsgType, hasFileName ? fileName : undefined),
+      previewText: buildQuotedMessageTypePlaceholder(
+        repliedMsgType,
+        hasFileName ? fileName : undefined,
+      ),
       previewMessageType: repliedMsgType,
       ...(hasFileName ? { previewFileName: fileName } : {}),
       previewSenderId: trimString(repliedMsg.senderId),
@@ -225,6 +338,17 @@ function buildRepliedMessagePreview(params: {
     };
   }
 
+  if (repliedMsgType === "chatRecord") {
+    return {
+      previewText:
+        formatChatRecordPreview(content as Record<string, unknown> | undefined, {
+          useTitleAsLabel: true,
+        }) || buildQuotedMessageTypePlaceholder("chatRecord"),
+      previewMessageType: "chatRecord",
+      previewSenderId: trimString(repliedMsg.senderId),
+    };
+  }
+
   const textPreview =
     trimString(content?.text) ||
     trimString(richTextQuote?.summary) ||
@@ -458,11 +582,7 @@ export function extractMessageContent(data: DingTalkInboundMessage): MessageCont
 
     // Strip quoted prefix before extracting @mentions to avoid matching @names inside quotes.
     const textForAtExtraction = textContent.replace(/^\[引用[^\]]*\]\s*/, "");
-    // Match @name but exclude email-like patterns (user@domain.com) and emoji (@_@).
-    const atMatches = textForAtExtraction.matchAll(/(?<!\w)@([^\s@.]+)(?!\.\w)/g);
-    for (const match of atMatches) {
-      atMentions.push({ name: match[1].trim() });
-    }
+    atMentions.push(...extractAtMentionsFromText(textForAtExtraction));
 
     return {
       text: textContent || quoted?.previewText || "",
@@ -501,7 +621,10 @@ export function extractMessageContent(data: DingTalkInboundMessage): MessageCont
       mediaPath: pictureDownloadCode,
       mediaPaths: uniquePictureDownloadCodes.length > 0 ? uniquePictureDownloadCodes : undefined,
       mediaType: pictureDownloadCode ? "image" : undefined,
-      mediaTypes: uniquePictureDownloadCodes.length > 0 ? uniquePictureDownloadCodes.map(() => "image") : undefined,
+      mediaTypes:
+        uniquePictureDownloadCodes.length > 0
+          ? uniquePictureDownloadCodes.map(() => "image")
+          : undefined,
       messageType: "richText",
       quoted: quoted ?? undefined,
       atMentions,
@@ -553,6 +676,18 @@ export function extractMessageContent(data: DingTalkInboundMessage): MessageCont
     };
   }
 
+  if (msgtype === "markdown") {
+    const mdText = typeof data.content?.text === "string" ? data.content.text.trim() : "";
+    atMentions.push(...extractAtMentionsFromText(mdText));
+    return {
+      text: mdText || "[markdown消息]",
+      messageType: "markdown",
+      quoted: quoted ?? undefined,
+      atMentions,
+      atUserDingtalkIds,
+    };
+  }
+
   if (msgtype === "interactiveCard") {
     const docMeta = parseBizCustomActionUrl(data.content?.biz_custom_action_url);
     if (docMeta) {
@@ -577,7 +712,8 @@ export function extractMessageContent(data: DingTalkInboundMessage): MessageCont
   if (msgtype === "chatRecord") {
     const content = data.content as Record<string, unknown> | undefined;
     const summary = typeof content?.summary === "string" ? content.summary.trim() : "";
-    const rawRecord = content?.chatRecord;
+    const rawRecord = getChatRecordEntriesSource(content);
+    const chatRecordText = formatChatRecordPreview(content);
     if (
       summary === "[]" ||
       (typeof rawRecord === "string" && rawRecord.trim() === "[]") ||
@@ -591,9 +727,9 @@ export function extractMessageContent(data: DingTalkInboundMessage): MessageCont
         atUserDingtalkIds,
       };
     }
-    if (summary) {
+    if (chatRecordText) {
       return {
-        text: `[聊天记录摘要] ${summary}`,
+        text: chatRecordText,
         messageType: "chatRecord",
         quoted: quoted ?? undefined,
         atMentions,

package/src/messaging/btw-deliver.ts

@@ -0,0 +1,85 @@
+import { sendMessage } from "../send-service";
+import type { DingTalkConfig, Logger } from "../types";
+
+const MAX_QUESTION_LENGTH = 80;
+const LEADING_MENTIONS_RE = /^(?:@\S+\s+)*/u;
+
+/**
+ * Strip leading `@mention` tokens from inbound text. Used by both the abort and
+ * BTW bypass branches in `inbound-handler.ts` so that command detection works
+ * uniformly in DM and group chats.
+ */
+export function stripLeadingMentions(text: string): string {
+  return text.replace(LEADING_MENTIONS_RE, "");
+}
+
+export function buildBtwBlockquote(senderName: string, rawQuestion: string): string {
+  const stripped = stripLeadingMentions(rawQuestion);
+  // Iterate by Unicode code points (not UTF-16 code units) so emoji /
+  // surrogate pairs aren't sliced in half at the truncation boundary.
+  const codePoints = Array.from(stripped);
+  const truncated =
+    codePoints.length > MAX_QUESTION_LENGTH
+      ? `${codePoints.slice(0, MAX_QUESTION_LENGTH).join("")}…`
+      : stripped;
+  const senderPrefix = senderName ? `${senderName}: ` : "";
+  return `> ${senderPrefix}${truncated}\n\n`;
+}
+
+export interface DeliverBtwReplyArgs {
+  config: DingTalkConfig;
+  sessionWebhook: string | undefined;
+  conversationId: string;
+  to: string;
+  senderName: string;
+  rawQuestion: string;
+  replyText: string;
+  log: Logger | undefined;
+  accountId?: string;
+  storePath?: string;
+}
+
+/**
+ * Deliver a BTW reply through the unified `sendMessage` entry point.
+ *
+ * BTW is a special inbound trigger, but the *outbound* reply is still a regular
+ * markdown/text message and must inherit the standard send-service semantics:
+ * persistence into the message context store, delivery metadata tracking, and
+ * the single `{ ok, error, ... }` contract. We pass `forceMarkdown: true` so
+ * that `sendMessage` skips the card branch even when the channel is configured
+ * for card mode — BTW must never create or touch an AI Card (see CLAUDE.md
+ * anti-pattern: "Do not create multiple active AI Cards for the same
+ * `accountId:conversationId`").
+ *
+ * When `sessionWebhook` is present `sendMessage` internally dispatches via
+ * `sendBySession`; otherwise it falls back to the proactive text/markdown API.
+ * Either way the caller sees the same return shape, and failures propagate as
+ * `{ ok: false }` instead of being silently swallowed.
+ */
+export async function deliverBtwReply(
+  args: DeliverBtwReplyArgs,
+): Promise<{ ok: boolean; error?: string }> {
+  const blockquote = buildBtwBlockquote(args.senderName, args.rawQuestion);
+  const fullText = `${blockquote}${args.replyText}`;
+
+  try {
+    const result = await sendMessage(args.config, args.to, fullText, {
+      log: args.log,
+      accountId: args.accountId,
+      storePath: args.storePath,
+      conversationId: args.conversationId,
+      sessionWebhook: args.sessionWebhook,
+      forceMarkdown: true,
+    });
+    if (!result.ok) {
+      args.log?.warn?.(
+        `[DingTalk] BTW reply delivery returned not-ok: ${result.error ?? "unknown"}`,
+      );
+    }
+    return { ok: result.ok, error: result.error };
+  } catch (err) {
+    const error = err instanceof Error ? err.message : String(err);
+    args.log?.warn?.(`[DingTalk] BTW reply delivery threw: ${error}`);
+    return { ok: false, error };
+  }
+}