@soimy/dingtalk 3.5.2 → 3.6.0

package/src/messaging/channel-actions.ts

@@ -0,0 +1,173 @@
+import { jsonResult } from "openclaw/plugin-sdk/channel-actions";
+import type { ChannelMessageActionAdapter } from "openclaw/plugin-sdk/channel-contract";
+import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
+import { readStringParam } from "openclaw/plugin-sdk/param-readers";
+import { extractToolSend } from "openclaw/plugin-sdk/tool-send";
+import { getConfig, stripTargetPrefix } from "../config";
+import { getLogger } from "../logger-context";
+import { resolveOriginalPeerId } from "../peer-id-registry";
+import { sendMedia, sendMessage } from "../send-service";
+import { parseBooleanLike } from "../utils";
+
+function readBooleanLikeParam(params: Record<string, unknown>, key: string): boolean | undefined {
+  return parseBooleanLike(params[key]);
+}
+
+function readSharedAudioAsVoiceParam(params: Record<string, unknown>): boolean {
+  const sharedValue = readBooleanLikeParam(params, "audioAsVoice");
+  if (sharedValue !== undefined) {
+    return sharedValue;
+  }
+  return readBooleanLikeParam(params, "asVoice") === true;
+}
+
+function resolveConversationIdFromSessionKey(sessionKey?: string | null): string | undefined {
+  const trimmed = sessionKey?.trim();
+  if (!trimmed) {
+    return undefined;
+  }
+
+  const markers = [":group:", ":channel:", ":direct:"] as const;
+  const marker = markers.find((candidate) => trimmed.includes(candidate));
+  if (!marker) {
+    return undefined;
+  }
+
+  const suffix = trimmed.slice(trimmed.indexOf(marker) + marker.length);
+  const threadMarker = ":topic:";
+  const threadIndex = suffix.indexOf(threadMarker);
+  const conversationId = (threadIndex >= 0 ? suffix.slice(0, threadIndex) : suffix).trim();
+  return conversationId || undefined;
+}
+
+function inferCardOwnerIdFromTarget(target: string): string | undefined {
+  const trimmed = target.trim();
+  if (!trimmed || trimmed.startsWith("cid")) {
+    return undefined;
+  }
+  return trimmed;
+}
+
+function describeDingTalkMessageTool(cfg: OpenClawConfig) {
+  const config = getConfig(cfg);
+  const configured = Boolean(config.clientId && config.clientSecret);
+  if (!configured && !(config.accounts && Object.keys(config.accounts).length > 0)) {
+    return { actions: [], capabilities: [], schema: null };
+  }
+  const hasCardMode =
+    config.messageType === "card" ||
+    (config.accounts && Object.values(config.accounts).some((account) => account?.messageType === "card"));
+  return {
+    actions: ["send"] as const,
+    capabilities: hasCardMode ? (["cards"] as const) : [],
+    schema: null,
+  };
+}
+
+export function createDingTalkMessageActions(): ChannelMessageActionAdapter {
+  return {
+    describeMessageTool: ({ cfg }) => describeDingTalkMessageTool(cfg),
+    supportsAction: ({ action }) => action === "send",
+    extractToolSend: ({ args }) => extractToolSend(args, "sendMessage"),
+    handleAction: async ({ action, params, cfg, accountId, dryRun, mediaLocalRoots, sessionKey }) => {
+      if (action !== "send") {
+        throw new Error(`Action ${action} is not supported for provider dingtalk.`);
+      }
+
+      const to = readStringParam(params, "to", { required: true });
+      const mediaInput =
+        readStringParam(params, "media", { trim: false }) ??
+        readStringParam(params, "path", { trim: false }) ??
+        readStringParam(params, "filePath", { trim: false }) ??
+        readStringParam(params, "mediaUrl", { trim: false });
+
+      const hasMedia = Boolean(mediaInput && mediaInput.trim());
+      const caption = readStringParam(params, "caption", { allowEmpty: true }) ?? "";
+      let message =
+        readStringParam(params, "message", {
+          required: !hasMedia,
+          allowEmpty: true,
+        }) ?? "";
+
+      if (!message.trim() && caption.trim()) {
+        message = caption;
+      }
+
+      const asVoice = readSharedAudioAsVoiceParam(params);
+      const requestedMediaType = readStringParam(params, "mediaType") as
+        | "image"
+        | "voice"
+        | "video"
+        | "file"
+        | undefined;
+
+      const target = resolveOriginalPeerId(stripTargetPrefix(to).targetId);
+
+      if (dryRun) {
+        return jsonResult({
+          ok: true,
+          dryRun: true,
+          to: target,
+          hasMedia,
+          asVoice,
+        });
+      }
+
+      const log = getLogger();
+      const config = getConfig(cfg, accountId ?? undefined);
+
+      if (hasMedia && mediaInput) {
+        const conversationId = resolveConversationIdFromSessionKey(sessionKey) ?? target;
+        const expectedCardOwnerId =
+          readStringParam(params, "expectedCardOwnerId") ?? inferCardOwnerIdFromTarget(target);
+        const result = await sendMedia(config, target, mediaInput, {
+          log,
+          accountId: accountId ?? undefined,
+          conversationId,
+          mediaType: requestedMediaType ?? undefined,
+          audioAsVoice: asVoice,
+          mediaLocalRoots: mediaLocalRoots ? [...mediaLocalRoots] : undefined,
+          expectedCardOwnerId: expectedCardOwnerId ?? undefined,
+        });
+
+        if (!result.ok) {
+          throw new Error(result.error || "send media failed");
+        }
+
+        return jsonResult({
+          ok: true,
+          to: target,
+          messageId: result.messageId ?? null,
+          result: result.data ?? null,
+        });
+      }
+
+      if (asVoice) {
+        throw new Error(
+          "DingTalk send with asVoice requires media/path/filePath/mediaUrl pointing to an audio file.",
+        );
+      }
+
+      if (!message.trim()) {
+        throw new Error("send requires message when media is not provided");
+      }
+
+      const result = await sendMessage(config, target, message, {
+        log,
+        accountId: accountId ?? undefined,
+      });
+
+      if (!result.ok) {
+        throw new Error(result.error || "send message failed");
+      }
+
+      const data = result.data as any;
+      return jsonResult({
+        ok: true,
+        to: target,
+        messageId: data?.processQueryKey || data?.messageId || null,
+        result: data ?? null,
+      });
+    },
+  };
+}

package/src/messaging/channel-outbound.ts

@@ -0,0 +1,158 @@
+import { randomUUID } from "node:crypto";
+import { getConfig } from "../config";
+import { getLogger } from "../logger-context";
+import { getDingTalkRuntime } from "../runtime";
+import { sendMedia, sendMessage } from "../send-service";
+import { normalizeResolvedDingTalkTarget } from "../targeting/target-directory-adapter";
+import type { DingTalkChannelPlugin } from "../types";
+import { formatDingTalkErrorPayloadLog, parseBooleanLike } from "../utils";
+
+function readBooleanLikeParam(params: Record<string, unknown>, key: string): boolean | undefined {
+  return parseBooleanLike(params[key]);
+}
+
+function readSharedAudioAsVoiceParam(params: Record<string, unknown>): boolean {
+  const sharedValue = readBooleanLikeParam(params, "audioAsVoice");
+  if (sharedValue !== undefined) {
+    return sharedValue;
+  }
+  return readBooleanLikeParam(params, "asVoice") === true;
+}
+
+export function createDingTalkOutbound(): NonNullable<DingTalkChannelPlugin["outbound"]> {
+  return {
+    deliveryMode: "direct",
+    resolveTarget: ({ to }: any) => {
+      const trimmed = to?.trim();
+      if (!trimmed) {
+        return {
+          ok: false as const,
+          error: new Error("DingTalk message requires --to <conversationId>"),
+        };
+      }
+      return { ok: true as const, to: normalizeResolvedDingTalkTarget(trimmed) };
+    },
+    sendText: async ({ cfg, to, text, accountId, log }: any) => {
+      const config = getConfig(cfg, accountId);
+      const runtime = getDingTalkRuntime();
+      const storePath = runtime.channel.session.resolveStorePath(cfg.session?.store, {
+        agentId: accountId,
+      });
+      const effectiveLog = getLogger(accountId) || log;
+      try {
+        const result = await sendMessage(config, to, text, {
+          log: effectiveLog,
+          accountId,
+          storePath,
+          conversationId: to,
+        });
+        effectiveLog?.debug?.(`[DingTalk] sendText: "${text}" result: ${JSON.stringify(result)}`);
+        if (!result.ok) {
+          throw new Error(result.error || "sendText failed");
+        }
+        const data = result.data as any;
+        const messageId = String(data?.processQueryKey || data?.messageId || randomUUID());
+        const meta =
+          result.data || result.tracking
+            ? {
+                ...(result.data ? { data: result.data as unknown as Record<string, unknown> } : {}),
+                ...(result.tracking ? { tracking: result.tracking } : {}),
+              }
+            : undefined;
+        return {
+          channel: "dingtalk",
+          messageId,
+          meta,
+        };
+      } catch (err: any) {
+        if (err?.response?.data !== undefined) {
+          effectiveLog?.error?.(formatDingTalkErrorPayloadLog("outbound.sendText", err.response.data));
+        }
+        throw new Error(
+          typeof err?.response?.data === "string"
+            ? err.response.data
+            : err?.message || "sendText failed",
+          { cause: err },
+        );
+      }
+    },
+    sendMedia: async ({
+      cfg,
+      to,
+      mediaPath,
+      filePath,
+      mediaUrl,
+      mediaType: providedMediaType,
+      audioAsVoice,
+      asVoice,
+      accountId,
+      mediaLocalRoots,
+      log,
+      expectedCardOwnerId,
+    }: any) => {
+      const config = getConfig(cfg, accountId);
+      const runtime = getDingTalkRuntime();
+      const storePath = runtime.channel.session.resolveStorePath(cfg.session?.store, {
+        agentId: accountId,
+      });
+      const effectiveLog = getLogger(accountId) || log;
+      if (!config.clientId) {
+        throw new Error("DingTalk not configured");
+      }
+
+      const rawMediaPath = mediaPath || filePath || mediaUrl;
+      if (!rawMediaPath) {
+        throw new Error(
+          `mediaPath, filePath, or mediaUrl is required. Received: ${JSON.stringify({
+            to,
+            mediaPath,
+            filePath,
+            mediaUrl,
+          })}`,
+        );
+      }
+
+      const requestedMediaType = typeof providedMediaType === "string"
+        ? (providedMediaType as "image" | "voice" | "video" | "file")
+        : undefined;
+
+      try {
+        const result = await sendMedia(config, to, rawMediaPath, {
+          log: effectiveLog,
+          accountId,
+          storePath,
+          conversationId: to,
+          mediaType: requestedMediaType,
+          audioAsVoice: readSharedAudioAsVoiceParam({ audioAsVoice, asVoice }),
+          mediaLocalRoots,
+          expectedCardOwnerId,
+        });
+        effectiveLog?.debug?.(`[DingTalk] sendMedia result: ${JSON.stringify(result)}`);
+        if (!result.ok) {
+          throw new Error(result.error || "sendMedia failed");
+        }
+        const data = result.data;
+        const messageId = String(
+          result.messageId || data?.processQueryKey || data?.messageId || randomUUID(),
+        );
+        return {
+          channel: "dingtalk",
+          messageId,
+          meta: result.data
+            ? { data: result.data as unknown as Record<string, unknown> }
+            : undefined,
+        };
+      } catch (err: any) {
+        if (err?.response?.data !== undefined) {
+          effectiveLog?.error?.(formatDingTalkErrorPayloadLog("outbound.sendMedia", err.response.data));
+        }
+        throw new Error(
+          typeof err?.response?.data === "string"
+            ? err.response.data
+            : err?.message || "sendMedia failed",
+          { cause: err },
+        );
+      }
+    },
+  };
+}

package/src/messaging/quoted-file-service.ts

@@ -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;
         }