@soimy/dingtalk 3.5.3 → 3.6.1

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

package/src/messaging/channel-actions.ts

@@ -0,0 +1,174 @@
+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 { hasConfiguredSecretInput } from "../secret-input";
+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 && hasConfiguredSecretInput(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 },
+        );
+      }
+    },
+  };
+}