@soimy/dingtalk 3.2.0 → 3.3.0

package/index.ts

@@ -1,9 +1,17 @@
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk";
+import * as pluginSdk from "openclaw/plugin-sdk";
 import { emptyPluginConfigSchema } from "openclaw/plugin-sdk";
 import { dingtalkPlugin } from "./src/channel";
+import { getConfig } from "./src/config";
+import { appendToDoc, createDoc, DocCreateAppendError, listDocs, searchDocs } from "./src/docs-service";
 import { setDingTalkRuntime } from "./src/runtime";
 import type { DingtalkPluginModule } from "./src/types";
 
+type GatewayMethodContext = Pick<
+  Parameters<Parameters<OpenClawPluginApi["registerGatewayMethod"]>[1]>[0],
+  "params" | "respond"
+>;
+
 const plugin: DingtalkPluginModule = {
   id: "dingtalk",
   name: "DingTalk Channel",
@@ -12,6 +20,60 @@ const plugin: DingtalkPluginModule = {
   register(api: OpenClawPluginApi): void {
     setDingTalkRuntime(api.runtime);
     api.registerChannel({ plugin: dingtalkPlugin });
+    api.registerGatewayMethod("dingtalk.docs.create", async ({ respond, params }: GatewayMethodContext) => {
+      const accountId = pluginSdk.readStringParam(params, "accountId");
+      const spaceId = pluginSdk.readStringParam(params, "spaceId", { required: true });
+      const title = pluginSdk.readStringParam(params, "title", { required: true });
+      const content = pluginSdk.readStringParam(params, "content", { allowEmpty: true });
+      const parentId = pluginSdk.readStringParam(params, "parentId");
+      const config = getConfig(api.config, accountId ?? undefined);
+      try {
+        const doc = await createDoc(
+          config,
+          spaceId,
+          title,
+          content ?? undefined,
+          api.logger,
+          parentId ?? undefined,
+        );
+        return respond(true, doc);
+      } catch (error) {
+        if (error instanceof DocCreateAppendError) {
+          return respond(true, {
+            partialSuccess: true,
+            initContentAppended: false,
+            docId: error.doc.docId,
+            doc: error.doc,
+            appendError: error.message,
+          });
+        }
+        throw error;
+      }
+    });
+    api.registerGatewayMethod("dingtalk.docs.append", async ({ respond, params }: GatewayMethodContext) => {
+      const accountId = pluginSdk.readStringParam(params, "accountId");
+      const docId = pluginSdk.readStringParam(params, "docId", { required: true });
+      const content = pluginSdk.readStringParam(params, "content", { required: true, allowEmpty: false });
+      const config = getConfig(api.config, accountId ?? undefined);
+      const result = await appendToDoc(config, docId, content, api.logger);
+      return respond(true, result);
+    });
+    api.registerGatewayMethod("dingtalk.docs.search", async ({ respond, params }: GatewayMethodContext) => {
+      const accountId = pluginSdk.readStringParam(params, "accountId");
+      const keyword = pluginSdk.readStringParam(params, "keyword", { required: true });
+      const spaceId = pluginSdk.readStringParam(params, "spaceId");
+      const config = getConfig(api.config, accountId ?? undefined);
+      const docs = await searchDocs(config, keyword, spaceId, api.logger);
+      return respond(true, { docs });
+    });
+    api.registerGatewayMethod("dingtalk.docs.list", async ({ respond, params }: GatewayMethodContext) => {
+      const accountId = pluginSdk.readStringParam(params, "accountId");
+      const spaceId = pluginSdk.readStringParam(params, "spaceId", { required: true });
+      const parentId = pluginSdk.readStringParam(params, "parentId");
+      const config = getConfig(api.config, accountId ?? undefined);
+      const docs = await listDocs(config, spaceId, parentId, api.logger);
+      return respond(true, { docs });
+    });
   },
 };
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soimy/dingtalk",
-  "version": "3.2.0",
+  "version": "3.3.0",
   "description": "DingTalk (钉钉) channel plugin for OpenClaw",
   "keywords": [
     "bot",
@@ -44,6 +44,8 @@
     "axios": "^1.6.0",
     "dingtalk-stream": "^2.1.4",
     "form-data": "^4.0.0",
+    "mammoth": "^1.12.0",
+    "pdf-parse": "^2.4.5",
     "zod": "^4.3.6"
   },
   "devDependencies": {

package/src/access-control.ts

@@ -53,3 +53,21 @@ export function isSenderGroupAllowed(params: {
   }
   return false;
 }
+
+export function isSenderOwner(params: {
+  allow: NormalizedAllowFrom;
+  senderId?: string;
+  rawSenderId?: string;
+}): boolean {
+  const { allow, senderId, rawSenderId } = params;
+  if (!allow.hasEntries) {
+    return false;
+  }
+  if (senderId && allow.entriesLower.includes(senderId.toLowerCase())) {
+    return true;
+  }
+  if (rawSenderId && allow.entriesLower.includes(rawSenderId.toLowerCase())) {
+    return true;
+  }
+  return false;
+}

package/src/ack-reaction-classifier.ts

@@ -0,0 +1,62 @@
+type SentenceType = "夸奖" | "责怪" | "命令" | "叙事" | "请求" | "未知";
+
+type AckReactionClassifyResult = {
+  type: SentenceType;
+  emoji: string;
+};
+
+type EmojiMap = Record<SentenceType, readonly string[]>;
+
+const CATCHPHRASE = "叽 ";
+
+const KEYWORDS = {
+  praise: ["真棒", "太好了", "厉害", "优秀", "聪明", "好样的", "赞", "牛", "完美", "出色", "真行", "干得漂亮", "天才", "棒极了"],
+  blame: ["怎么又", "搞砸", "太差了", "烦死了", "讨厌", "笨", "蠢", "马虎", "不负责任", "乱来", "糟糕", "废物", "气死我了", "错了"],
+  command: ["必须", "立刻", "马上", "赶紧", "不准", "不要", "别动", "别说", "别做", "快去", "去做", "给我", "听着", "站住", "闭嘴"],
+  request: ["能不能", "可以吗", "好吗", "请", "麻烦", "帮个忙", "帮忙", "劳驾", "能否", "想请你", "能帮我", "借我", "方便吗"],
+} as const;
+
+const POLITE_EXCLUSIONS = ["别客气", "别介意", "别见怪", "别担心", "别着急"] as const;
+
+const EMOJIS: EmojiMap = {
+  "夸奖": ["(๑•̀ㅂ•́)و✧", "(ﾉ≧∀≦)ﾉ", "٩(๑>◡<๑)۶", "(★▽★)", "(⌒▽⌒)☆", "(*≧ω≦)", "(ง •_•)ง", "ヾ(≧▽≦*)o"],
+  "责怪": ["(╬ Ò﹏Ó)", "(╯°□°）╯", "(▼皿▼#)", "(｡•́︿•̀｡)", "(╥﹏╥)", "ヽ(｀Д´)ﾉ", "(＃＞＜)", "(；′⌒`)"],
+  "命令": ["(¬_¬)", "(｀ε´)", "(＃｀Д´)", "(●｀∀´●)", "┌（┌ *｀д´）┐", "(｀д´)", "(•̀へ •́ ╮ )", "(￣ω￣;)"],
+  "叙事": ["(。・ω・。)", "(￣▽￣)", "(´• ω •`)", "(・・?)", "(。_。)", "(￣ω￣)", "(´▽`)", "(=_=)"],
+  "请求": ["(っ´∀｀)っ", "(๑•̀ω•́๑)✧", "(づ｡◕‿‿◕｡)づ", "(p≧w≦q)", "(♡˙︶˙♡)", "(⁄ ⁄•⁄ω⁄•⁄ ⁄)", "(´;ω;｀)", "(人•ᴗ•✿)"],
+  "未知": ["(•̀_•́)", "(；一_一)", "(???)"],
+};
+
+function containsAny(text: string, words: readonly string[]): boolean {
+  return words.some(word => text.includes(word));
+}
+
+export function classifyAckReactionEmoji(sentence: unknown): AckReactionClassifyResult {
+  if (!sentence || typeof sentence !== "string") {
+    return { type: "未知", emoji: `${CATCHPHRASE}(•̀_•́)` };
+  }
+
+  const s = sentence.trim();
+  const isPolitePhrase = POLITE_EXCLUSIONS.some(phrase => s.includes(phrase));
+  const isQuestion = /吗|呢|？|\?/.test(s);
+  const startsWithPlease = s.startsWith("请");
+  const hasExclamation = /[!！]/.test(s);
+  const imperativeStart = !isPolitePhrase && /^(快|别|不要|不准|必须|马上|立刻)/.test(s);
+
+  let type: SentenceType;
+  if (containsAny(s, KEYWORDS.request) || (isQuestion && (startsWithPlease || /帮|麻烦/.test(s)))) {
+    type = "请求";
+  } else if (imperativeStart || containsAny(s, KEYWORDS.command)) {
+    type = "命令";
+  } else if (containsAny(s, KEYWORDS.praise)) {
+    type = "夸奖";
+  } else if (containsAny(s, KEYWORDS.blame) || (hasExclamation && /烦|讨厌|笨|蠢|差|气死/.test(s))) {
+    type = "责怪";
+  } else {
+    type = "叙事";
+  }
+
+  const emojiList = EMOJIS[type];
+  const emoji = emojiList[Math.floor(Math.random() * emojiList.length)];
+  return { type, emoji: `${CATCHPHRASE}${emoji}` };
+}

package/src/ack-reaction-service.ts

@@ -0,0 +1,135 @@
+import axios from "axios";
+import { getAccessToken } from "./auth";
+import type { DingTalkConfig } from "./types";
+import { formatDingTalkErrorPayloadLog, getProxyBypassOption } from "./utils";
+
+// DingTalk currently exposes a dedicated native "thinking" reaction flow rather than
+// a generic arbitrary-emoji reaction API for this plugin path.
+const DINGTALK_NATIVE_ACK_REACTION = "🤔思考中";
+const THINKING_EMOTION_ID = "2659900";
+const THINKING_EMOTION_BACKGROUND_ID = "im_bg_1";
+const THINKING_REACTION_RECALL_DELAYS_MS = [0, 1500, 5000] as const;
+
+type AckReactionLogger = {
+  debug?: (msg: string) => void;
+  info?: (msg: string) => void;
+  warn?: (msg: string) => void;
+};
+
+type AckReactionTarget = {
+  msgId: string;
+  conversationId: string;
+  robotCode?: string;
+  reactionName?: string;
+};
+
+function resolveAckReactionPayload(config: DingTalkConfig, data: AckReactionTarget): {
+  robotCode: string;
+  reactionName: string;
+} | null {
+  const robotCode = (data.robotCode || config.robotCode || config.clientId || "").trim();
+  const reactionName =
+    (data.reactionName || DINGTALK_NATIVE_ACK_REACTION).trim() || DINGTALK_NATIVE_ACK_REACTION;
+  if (!robotCode || !data.msgId || !data.conversationId) {
+    return null;
+  }
+  return { robotCode, reactionName };
+}
+
+async function callEmotionApi(
+  config: DingTalkConfig,
+  data: AckReactionTarget,
+  endpoint: "reply" | "recall",
+  successLog: string,
+  errorLogPrefix: string,
+  errorPayloadKey: "inbound.ackReactionAttach" | "inbound.ackReactionRecall",
+  log?: AckReactionLogger,
+): Promise<boolean> {
+  const payload = resolveAckReactionPayload(config, data);
+  if (!payload) {
+    return false;
+  }
+
+  try {
+    const token = await getAccessToken(config, log as any);
+    await axios.post(
+      `https://api.dingtalk.com/v1.0/robot/emotion/${endpoint}`,
+      {
+        robotCode: payload.robotCode,
+        openMsgId: data.msgId,
+        openConversationId: data.conversationId,
+        emotionType: 2,
+        emotionName: payload.reactionName,
+        textEmotion: {
+          emotionId: THINKING_EMOTION_ID,
+          emotionName: payload.reactionName,
+          text: payload.reactionName,
+          backgroundId: THINKING_EMOTION_BACKGROUND_ID,
+        },
+      },
+      {
+        headers: {
+          "x-acs-dingtalk-access-token": token,
+          "Content-Type": "application/json",
+        },
+        timeout: 5000,
+        ...getProxyBypassOption(config),
+      },
+    );
+    log?.info?.(successLog);
+    return true;
+  } catch (err: any) {
+    log?.warn?.(`${errorLogPrefix}: ${err.message}`);
+    if (err?.response?.data !== undefined) {
+      log?.warn?.(formatDingTalkErrorPayloadLog(errorPayloadKey, err.response.data));
+    }
+    return false;
+  }
+}
+
+export async function attachNativeAckReaction(
+  config: DingTalkConfig,
+  data: AckReactionTarget,
+  log?: AckReactionLogger,
+): Promise<boolean> {
+  return callEmotionApi(
+    config,
+    data,
+    "reply",
+    "[DingTalk] Native ack reaction attach succeeded",
+    "[DingTalk] Native ack reaction attach failed",
+    "inbound.ackReactionAttach",
+    log,
+  );
+}
+
+async function recallNativeAckReaction(
+  config: DingTalkConfig,
+  data: AckReactionTarget,
+  log?: AckReactionLogger,
+): Promise<boolean> {
+  return callEmotionApi(
+    config,
+    data,
+    "recall",
+    "[DingTalk] Native ack reaction recall succeeded",
+    "[DingTalk] Native ack reaction recall failed",
+    "inbound.ackReactionRecall",
+    log,
+  );
+}
+
+export async function recallNativeAckReactionWithRetry(
+  config: DingTalkConfig,
+  data: AckReactionTarget,
+  log?: AckReactionLogger,
+): Promise<void> {
+  for (const delayMs of THINKING_REACTION_RECALL_DELAYS_MS) {
+    if (delayMs > 0) {
+      await new Promise(resolve => setTimeout(resolve, delayMs));
+    }
+    if (await recallNativeAckReaction(config, data, log)) {
+      return;
+    }
+  }
+}

package/src/attachment-text-extractor.ts

@@ -0,0 +1,147 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+
+const MAX_EXTRACTED_TEXT_CHARS = 6000;
+const MAX_ATTACHMENT_EXTRACT_BYTES = 2 * 1024 * 1024;
+
+export interface AttachmentTextExtractionInput {
+  path: string;
+  mimeType?: string;
+  fileName?: string;
+}
+
+export interface AttachmentTextExtractionResult {
+  text: string;
+  truncated: boolean;
+  sourceType: "text" | "html" | "pdf" | "docx";
+}
+
+async function isFileTooLarge(filePath: string): Promise<boolean> {
+  const stat = await fs.stat(filePath);
+  return stat.size > MAX_ATTACHMENT_EXTRACT_BYTES;
+}
+
+function isTextLikeMimeType(mimeType: string | undefined): boolean {
+  if (!mimeType) {
+    return false;
+  }
+  return (
+    mimeType.startsWith("text/") ||
+    mimeType === "application/json" ||
+    mimeType === "application/xml" ||
+    mimeType === "application/javascript"
+  );
+}
+
+function normalizeWhitespace(text: string): string {
+  return text
+    .replace(/\r\n/g, "\n")
+    .split("\u0000").join("")
+    .replace(/[ \t]{2,}/g, " ")
+    .replace(/[ \t]+\n/g, "\n")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+}
+
+function limitExtractedText(text: string): AttachmentTextExtractionResult | null {
+  const normalized = normalizeWhitespace(text);
+  if (!normalized) {
+    return null;
+  }
+  const truncated = normalized.length > MAX_EXTRACTED_TEXT_CHARS;
+  const limited = truncated ? `${normalized.slice(0, MAX_EXTRACTED_TEXT_CHARS)}\n\n[内容已截断]` : normalized;
+  return {
+    text: limited,
+    truncated,
+    sourceType: "text",
+  };
+}
+
+function stripHtml(html: string): string {
+  return html
+    .replace(/<script[\s\S]*?<\/script>/gi, " ")
+    .replace(/<style[\s\S]*?<\/style>/gi, " ")
+    .replace(/<[^>]+>/g, " ")
+    .replace(/&nbsp;/gi, " ")
+    .replace(/&lt;/gi, "<")
+    .replace(/&gt;/gi, ">")
+    .replace(/&amp;/gi, "&")
+    .replace(/&#39;/gi, "'")
+    .replace(/&quot;/gi, "\"");
+}
+
+async function extractTextLikeFile(filePath: string): Promise<AttachmentTextExtractionResult | null> {
+  const raw = await fs.readFile(filePath, "utf8");
+  return limitExtractedText(raw);
+}
+
+async function extractPdf(filePath: string): Promise<AttachmentTextExtractionResult | null> {
+  const pdfParseModule = await import("pdf-parse");
+  const fileBuffer = await fs.readFile(filePath);
+  const parser = new pdfParseModule.PDFParse({ data: new Uint8Array(fileBuffer) });
+  try {
+    const result = await parser.getText();
+    const limited = limitExtractedText(result.text || "");
+    return limited ? { ...limited, sourceType: "pdf" } : null;
+  } finally {
+    await parser.destroy();
+  }
+}
+
+async function extractDocx(filePath: string): Promise<AttachmentTextExtractionResult | null> {
+  const mammothModule = await import("mammoth");
+  const result = await mammothModule.extractRawText({ path: filePath });
+  const limited = limitExtractedText(result.value || "");
+  return limited ? { ...limited, sourceType: "docx" } : null;
+}
+
+async function extractHtml(filePath: string): Promise<AttachmentTextExtractionResult | null> {
+  const raw = await fs.readFile(filePath, "utf8");
+  const limited = limitExtractedText(stripHtml(raw));
+  return limited ? { ...limited, sourceType: "html" } : null;
+}
+
+export async function extractAttachmentText(
+  input: AttachmentTextExtractionInput,
+): Promise<AttachmentTextExtractionResult | null> {
+  const mimeType = input.mimeType?.toLowerCase();
+  const fileName = (input.fileName || path.basename(input.path)).toLowerCase();
+
+  if (mimeType?.startsWith("image/") || mimeType?.startsWith("audio/") || mimeType?.startsWith("video/")) {
+    return null;
+  }
+
+  if (await isFileTooLarge(input.path)) {
+    return null;
+  }
+
+  if (
+    mimeType === "application/vnd.openxmlformats-officedocument.wordprocessingml.document" ||
+    fileName.endsWith(".docx")
+  ) {
+    return extractDocx(input.path);
+  }
+
+  if (mimeType === "application/pdf" || fileName.endsWith(".pdf")) {
+    return extractPdf(input.path);
+  }
+
+  if (mimeType === "text/html" || mimeType === "application/xhtml+xml" || fileName.endsWith(".html") || fileName.endsWith(".htm")) {
+    return extractHtml(input.path);
+  }
+
+  if (
+    isTextLikeMimeType(mimeType) ||
+    fileName.endsWith(".txt") ||
+    fileName.endsWith(".md") ||
+    fileName.endsWith(".markdown") ||
+    fileName.endsWith(".csv") ||
+    fileName.endsWith(".json") ||
+    fileName.endsWith(".xml") ||
+    fileName.endsWith(".log")
+  ) {
+    return extractTextLikeFile(input.path);
+  }
+
+  return null;
+}

package/src/card-callback-service.ts

@@ -0,0 +1,119 @@
+export interface CardCallbackAnalysis {
+  summary: string;
+  actionId?: string;
+  feedbackTarget?: string;
+  feedbackAckText?: string;
+  userId?: string;
+  processQueryKey?: string;
+}
+
+function stringifyCandidate(value: unknown): string {
+  if (typeof value === "string") {
+    return value;
+  }
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return "[unserializable]";
+  }
+}
+
+function asRecord(value: unknown): Record<string, unknown> | undefined {
+  if (!value || typeof value !== "object" || Array.isArray(value)) {
+    return undefined;
+  }
+  return value as Record<string, unknown>;
+}
+
+function parseEmbeddedJson(value: unknown): unknown {
+  if (typeof value !== "string") {
+    return value;
+  }
+  try {
+    return JSON.parse(value);
+  } catch {
+    return value;
+  }
+}
+
+export function extractCardActionSummary(data: unknown): string {
+  const record = asRecord(data);
+  const candidates = [
+    record?.action,
+    record?.actionType,
+    record?.actionValue,
+    record?.value,
+    record?.eventType,
+    record?.operate,
+    record?.callbackType,
+    record?.cardPrivateData,
+    record?.privateData,
+  ].filter((value) => value !== undefined && value !== null);
+
+  if (candidates.length === 0) {
+    return "(no action field found)";
+  }
+
+  return candidates.map(stringifyCandidate).join(" | ");
+}
+
+export function extractCardActionId(data: unknown): string | undefined {
+  const record = asRecord(data);
+  const embeddedValue = parseEmbeddedJson(record?.value);
+  const embeddedContent = parseEmbeddedJson(record?.content);
+
+  for (const source of [embeddedValue, embeddedContent, record].filter(Boolean)) {
+    const sourceRecord = asRecord(source);
+    const cardPrivateData = asRecord(sourceRecord?.cardPrivateData);
+    const actionIds = cardPrivateData?.actionIds;
+    if (Array.isArray(actionIds) && actionIds.length > 0 && typeof actionIds[0] === "string") {
+      return actionIds[0];
+    }
+    if (typeof sourceRecord?.actionValue === "string" && sourceRecord.actionValue.trim()) {
+      return sourceRecord.actionValue.trim();
+    }
+    if (typeof sourceRecord?.eventKey === "string" && sourceRecord.eventKey.trim()) {
+      return sourceRecord.eventKey.trim();
+    }
+    if (typeof sourceRecord?.value === "string" && sourceRecord.value.trim()) {
+      return sourceRecord.value.trim();
+    }
+  }
+
+  return undefined;
+}
+
+export function analyzeCardCallback(data: unknown): CardCallbackAnalysis {
+  const record = asRecord(data);
+  const summary = extractCardActionSummary(data);
+  const actionId = extractCardActionId(data);
+  const embeddedValue = asRecord(parseEmbeddedJson(record?.value));
+  const embeddedContent = asRecord(parseEmbeddedJson(record?.content));
+  const processQueryKey =
+    (typeof record?.processQueryKey === "string" && record.processQueryKey.trim()) ||
+    (typeof embeddedValue?.processQueryKey === "string" && embeddedValue.processQueryKey.trim()) ||
+    (typeof embeddedContent?.processQueryKey === "string" && embeddedContent.processQueryKey.trim()) ||
+    undefined;
+
+  if (actionId !== "feedback_up" && actionId !== "feedback_down") {
+    return { summary, actionId, processQueryKey };
+  }
+
+  const spaceType = typeof record?.spaceType === "string" ? record.spaceType.trim().toLowerCase() : "";
+  const spaceId = typeof record?.spaceId === "string" ? record.spaceId.trim() : "";
+  const userId = typeof record?.userId === "string" ? record.userId.trim() : "";
+  const feedbackTarget = spaceType === "im" ? userId : spaceId;
+  const feedbackAckText =
+    actionId === "feedback_up"
+      ? "✅ 已收到你的点赞（反馈已记录）"
+      : "⚠️ 已收到你的点踩（反馈已记录，我会改进）";
+
+  return {
+    summary,
+    actionId,
+    feedbackTarget: feedbackTarget || undefined,
+    feedbackAckText,
+    userId: userId || undefined,
+    processQueryKey,
+  };
+}