@soimy/dingtalk 3.5.1 → 3.5.3

package/src/logger-context.ts

@@ -1,17 +1,31 @@
 import type { Logger } from "./types";
 
 let currentLogger: Logger | undefined;
+const loggerByAccountId = new Map<string, Logger>();
 
 /**
  * Persist current request logger for shared services invoked outside handler scope.
  */
-export function setCurrentLogger(log?: Logger): void {
+export function setCurrentLogger(log?: Logger, accountId?: string | null): void {
   currentLogger = log;
+  const normalizedAccountId = typeof accountId === "string" ? accountId.trim() : "";
+  if (!normalizedAccountId) {
+    return;
+  }
+  if (log) {
+    loggerByAccountId.set(normalizedAccountId, log);
+    return;
+  }
+  loggerByAccountId.delete(normalizedAccountId);
 }
 
 /**
  * Read current logger bound by inbound handler.
  */
-export function getLogger(): Logger | undefined {
+export function getLogger(accountId?: string | null): Logger | undefined {
+  const normalizedAccountId = typeof accountId === "string" ? accountId.trim() : "";
+  if (normalizedAccountId) {
+    return loggerByAccountId.get(normalizedAccountId);
+  }
   return currentLogger;
 }

package/src/media-utils.ts

@@ -11,8 +11,9 @@ import * as path from "node:path";
 import { promises as fsPromises } from "node:fs";
 import { lookup as dnsLookup } from "node:dns/promises";
 import { BlockList, isIP } from "node:net";
-import axios from "axios";
+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";
@@ -26,7 +27,7 @@ interface PluginRuntimeWithMedia {
   media?: {
     loadWebMedia(
       mediaPath: string,
-      options?: { mediaLocalRoots?: string[] },
+      options?: { localRoots?: readonly string[] | "any" },
     ): Promise<{ buffer: Buffer | ArrayBuffer; fileName?: string; contentType?: string } | null>;
   };
   [key: string]: unknown;
@@ -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";
@@ -667,7 +804,7 @@ async function readMediaBuffer(
   }
 
   const media = await rt.media.loadWebMedia(mediaPath, {
-    mediaLocalRoots: options?.mediaLocalRoots,
+    localRoots: options?.mediaLocalRoots,
   });
 
   if (!media || !media.buffer) {
@@ -687,6 +824,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 +840,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 +868,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 +889,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 +912,7 @@ export async function uploadMedia(
       }
     }
     return null;
+  } finally {
+    await voicePreparedCleanup?.();
   }
 }

package/src/message-utils.ts

@@ -98,6 +98,15 @@ function extractRichTextQuoteParts(
   };
 }
 
+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;
@@ -225,6 +234,17 @@ function buildRepliedMessagePreview(params: {
     };
   }
 
+  if (repliedMsgType === "chatRecord") {
+    const summary = typeof content?.summary === "string" ? content.summary.trim() : "";
+    const title = typeof content?.title === "string" ? content.title.trim() : "";
+    const chatRecordLabel = title ? `[${title}] ` : "[聊天记录] ";
+    return {
+      previewText: summary ? `${chatRecordLabel}${summary}` : buildQuotedMessageTypePlaceholder("chatRecord"),
+      previewMessageType: "chatRecord",
+      previewSenderId: trimString(repliedMsg.senderId),
+    };
+  }
+
   const textPreview =
     trimString(content?.text) ||
     trimString(richTextQuote?.summary) ||
@@ -458,11 +478,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 || "",
@@ -553,6 +569,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) {

package/src/{attachment-text-extractor.ts → messaging/attachment-text-extractor.ts}

@@ -1,6 +1,6 @@
 import fs from "node:fs/promises";
 import path from "node:path";
-import type { AttachmentTextSource } from "./types";
+import type { AttachmentTextSource } from "../types";
 
 const MAX_EXTRACTED_TEXT_CHARS = 6000;
 const MAX_ATTACHMENT_EXTRACT_BYTES = 2 * 1024 * 1024;

package/src/{quoted-file-service.ts → messaging/quoted-file-service.ts}

@@ -1,10 +1,10 @@
 import http from "node:http";
 import https from "node:https";
-import axios from "axios";
-import { getAccessToken } from "./auth";
-import { getDingTalkRuntime } from "./runtime";
-import type { DingTalkConfig, Logger, MediaFile } from "./types";
-import { formatDingTalkErrorPayload, formatDingTalkErrorPayloadLog } from "./utils";
+import axios from "../http-client";
+import { getAccessToken } from "../auth";
+import { getDingTalkRuntime } from "../runtime";
+import type { DingTalkConfig, Logger, MediaFile } from "../types";
+import { formatDingTalkErrorPayload, formatDingTalkErrorPayloadLog } from "../utils";
 
 function asRecord(value: unknown): Record<string, unknown> | undefined {
     if (!value || typeof value !== "object" || Array.isArray(value)) {
@@ -229,6 +229,7 @@ export async function downloadGroupFile(
     dentryId: string,
     unionId: string,
     log?: Logger,
+    originalFilename?: string,
 ): Promise<MediaFile | null> {
     const rt = getDingTalkRuntime();
     const token = await getAccessToken(config, log);
@@ -294,9 +295,13 @@ export async function downloadGroupFile(
         const maxBytes =
             config.mediaMaxMb && config.mediaMaxMb > 0 ? config.mediaMaxMb * 1024 * 1024 : undefined;
         try {
-            const saved = maxBytes
-                ? await rt.channel.media.saveMediaBuffer(buffer, contentType, "inbound", maxBytes)
-                : await rt.channel.media.saveMediaBuffer(buffer, contentType, "inbound");
+            const saved = await rt.channel.media.saveMediaBuffer(
+                buffer,
+                contentType,
+                "inbound",
+                maxBytes,
+                originalFilename,
+            );
 
             return { path: saved.path, mimeType: saved.contentType ?? contentType };
         } catch (err: unknown) {
@@ -353,7 +358,7 @@ export async function resolveQuotedFile(
         }
 
         stage = "download-file";
-        const media = await downloadGroupFile(config, spaceId, match.dentryId, unionId, log);
+        const media = await downloadGroupFile(config, spaceId, match.dentryId, unionId, log, match.name);
         if (!media) {
             return null;
         }

package/src/onboarding.ts

@@ -122,10 +122,12 @@ function applyAccountConfig(params: {
       ? { groupAllowFrom: input.groupAllowFrom }
       : {}),
     ...(input.displayNameResolution ? { displayNameResolution: input.displayNameResolution } : {}),
+    ...(input.contextVisibility ? { contextVisibility: input.contextVisibility } : {}),
     ...(input.mediaUrlAllowlist && input.mediaUrlAllowlist.length > 0
       ? { mediaUrlAllowlist: input.mediaUrlAllowlist }
       : {}),
     ...(input.messageType ? { messageType: input.messageType } : {}),
+    ...(input.cardStreamingMode ? { cardStreamingMode: input.cardStreamingMode } : {}),
     ...(typeof input.maxReconnectCycles === "number"
       ? { maxReconnectCycles: input.maxReconnectCycles }
       : {}),
@@ -233,6 +235,7 @@ async function configureDingTalkAccount(params: {
   });
 
   let messageType: "markdown" | "card" = "markdown";
+  let cardStreamingMode: DingTalkConfig["cardStreamingMode"];
 
   if (wantsCardMode) {
     await prompter.note(
@@ -244,6 +247,15 @@ async function configureDingTalkAccount(params: {
       "Built-in AI Card Template",
     );
     messageType = "card";
+    cardStreamingMode = (await prompter.select({
+      message: "Card streaming mode",
+      options: [
+        { label: "Off - answer does not stream incrementally", value: "off" },
+        { label: "Answer - only answer streams incrementally", value: "answer" },
+        { label: "All - answer and thinking stream incrementally", value: "all" },
+      ],
+      initialValue: resolved.cardStreamingMode ?? (resolved.cardRealTimeStream ? "all" : "off"),
+    })) as DingTalkConfig["cardStreamingMode"];
   }
 
   const dmPolicyValue = await prompter.select({
@@ -333,6 +345,22 @@ async function configureDingTalkAccount(params: {
     initialValue: resolved.displayNameResolution ?? "disabled",
   });
 
+  await prompter.note(
+    [
+      "Advanced host context visibility is available as channels.dingtalk.contextVisibility.",
+      "Recommended advanced mode: allowlist_quote.",
+      "Modes:",
+      "- all: preserve the current host supplemental-context behavior",
+      "- allowlist: keep only host allowlisted supplemental context",
+      "- allowlist_quote: keep explicit quote/reply context while filtering extra context",
+      "This is separate from displayNameResolution and should be set manually if needed.",
+      resolved.contextVisibility
+        ? `Current resolved value: ${resolved.contextVisibility}`
+        : "Current resolved value: host default",
+    ].join("\n"),
+    "Advanced context visibility",
+  );
+
   let maxReconnectCycles: number | undefined;
   const wantsReconnectLimits = await prompter.confirm({
     message: "Configure runtime reconnect cycle limit? (recommended)",
@@ -410,6 +438,7 @@ async function configureDingTalkAccount(params: {
       displayNameResolution: displayNameResolutionValue as "disabled" | "all",
       mediaUrlAllowlist,
       messageType,
+      cardStreamingMode,
       maxReconnectCycles,
       mediaMaxMb,
       journalTTLDays,

package/src/plugin-sdk-channel-actions-augment.ts

@@ -0,0 +1,11 @@
+import type { ChannelMessageActionAdapter } from "openclaw/plugin-sdk/channel-contract";
+
+type JsonResultReturn = NonNullable<ChannelMessageActionAdapter["handleAction"]> extends (
+  ...args: unknown[]
+) => Promise<infer TResult>
+  ? TResult
+  : never;
+
+declare module "openclaw/plugin-sdk/channel-actions" {
+  export function jsonResult(payload: unknown): JsonResultReturn;
+}