@yaoyuanchao/dingtalk 1.4.10 → 1.4.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yaoyuanchao/dingtalk",
-  "version": "1.4.10",
+  "version": "1.4.11",
   "type": "module",
   "description": "DingTalk channel plugin for Clawdbot with Stream Mode support",
   "license": "MIT",

package/src/api.ts

@@ -494,3 +494,194 @@ export function cleanupOldMedia(): void {
 
 /** @deprecated Use cleanupOldMedia() instead */
 export const cleanupOldPictures = cleanupOldMedia;
+
+/**
+ * Upload a file to DingTalk and get media_id
+ * Uses the robot messageFiles upload API
+ */
+export async function uploadMediaFile(params: {
+  clientId: string;
+  clientSecret: string;
+  robotCode: string;
+  fileBuffer: Buffer;
+  fileName: string;
+  fileType?: 'image' | 'voice' | 'video' | 'file';
+}): Promise<{ mediaId?: string; error?: string }> {
+  try {
+    const token = await getDingTalkAccessToken(params.clientId, params.clientSecret);
+
+    // Build multipart form data manually
+    const boundary = `----DingTalkBoundary${Date.now()}`;
+    const fileType = params.fileType || 'file';
+
+    // Construct multipart body
+    const parts: Buffer[] = [];
+
+    // Add robotCode field
+    parts.push(Buffer.from(
+      `--${boundary}\r\n` +
+      `Content-Disposition: form-data; name="robotCode"\r\n\r\n` +
+      `${params.robotCode}\r\n`
+    ));
+
+    // Add file field
+    parts.push(Buffer.from(
+      `--${boundary}\r\n` +
+      `Content-Disposition: form-data; name="media"; filename="${params.fileName}"\r\n` +
+      `Content-Type: application/octet-stream\r\n\r\n`
+    ));
+    parts.push(params.fileBuffer);
+    parts.push(Buffer.from('\r\n'));
+
+    // End boundary
+    parts.push(Buffer.from(`--${boundary}--\r\n`));
+
+    const body = Buffer.concat(parts);
+
+    // Make request
+    const url = `${DINGTALK_API_BASE}/robot/messageFiles/upload?type=${fileType}`;
+
+    return new Promise((resolve) => {
+      const urlObj = new URL(url);
+      const req = https.request(urlObj, {
+        method: 'POST',
+        headers: {
+          'x-acs-dingtalk-access-token': token,
+          'Content-Type': `multipart/form-data; boundary=${boundary}`,
+          'Content-Length': body.length,
+        },
+        timeout: 60000, // 60 second timeout for upload
+        family: 4,
+      }, (res) => {
+        let buf = '';
+        res.on('data', (chunk: any) => { buf += chunk; });
+        res.on('end', () => {
+          try {
+            const json = JSON.parse(buf);
+            if (json.mediaId) {
+              console.log(`[dingtalk] File uploaded successfully: mediaId=${json.mediaId}`);
+              resolve({ mediaId: json.mediaId });
+            } else {
+              console.warn(`[dingtalk] File upload failed:`, json);
+              resolve({ error: json.message || json.errmsg || 'Upload failed' });
+            }
+          } catch {
+            resolve({ error: `Invalid response: ${buf}` });
+          }
+        });
+      });
+
+      req.on('error', (err) => {
+        console.warn(`[dingtalk] File upload error:`, err);
+        resolve({ error: String(err) });
+      });
+
+      req.on('timeout', () => {
+        req.destroy();
+        resolve({ error: 'Upload timeout' });
+      });
+
+      req.write(body);
+      req.end();
+    });
+  } catch (err) {
+    console.warn(`[dingtalk] Error uploading file:`, err);
+    return { error: String(err) };
+  }
+}
+
+/**
+ * Send a file message via REST API
+ * Requires mediaId from uploadMediaFile
+ */
+export async function sendFileMessage(params: {
+  clientId: string;
+  clientSecret: string;
+  robotCode: string;
+  userId?: string;
+  conversationId?: string;
+  mediaId: string;
+  fileName: string;
+}): Promise<{ ok: boolean; error?: string }> {
+  try {
+    const token = await getDingTalkAccessToken(params.clientId, params.clientSecret);
+    const headers = { 'x-acs-dingtalk-access-token': token };
+
+    const msgParam = JSON.stringify({
+      mediaId: params.mediaId,
+      fileName: params.fileName,
+      fileType: getFileExtension(params.fileName),
+    });
+
+    if (params.userId) {
+      // Send to DM
+      const res = await jsonPost(
+        `${DINGTALK_API_BASE}/robot/oToMessages/batchSend`,
+        {
+          robotCode: params.robotCode,
+          userIds: [params.userId],
+          msgKey: 'sampleFile',
+          msgParam,
+        },
+        headers,
+      );
+
+      if (res?.code || res?.errcode) {
+        console.warn(`[dingtalk] File send (DM) failed:`, res);
+        return { ok: false, error: res.message || res.errmsg };
+      }
+
+      console.log(`[dingtalk] File sent to DM: ${params.fileName}`);
+      return { ok: true };
+    }
+
+    if (params.conversationId) {
+      // Send to group
+      const res = await jsonPost(
+        `${DINGTALK_API_BASE}/robot/groupMessages/send`,
+        {
+          robotCode: params.robotCode,
+          openConversationId: params.conversationId,
+          msgKey: 'sampleFile',
+          msgParam,
+        },
+        headers,
+      );
+
+      if (res?.code || res?.errcode) {
+        console.warn(`[dingtalk] File send (group) failed:`, res);
+        return { ok: false, error: res.message || res.errmsg };
+      }
+
+      console.log(`[dingtalk] File sent to group: ${params.fileName}`);
+      return { ok: true };
+    }
+
+    return { ok: false, error: 'Either userId or conversationId required' };
+  } catch (err) {
+    console.warn(`[dingtalk] Error sending file:`, err);
+    return { ok: false, error: String(err) };
+  }
+}
+
+/** Get file extension from filename */
+function getFileExtension(fileName: string): string {
+  const ext = path.extname(fileName).toLowerCase();
+  return ext ? ext.slice(1) : 'bin';
+}
+
+/**
+ * Convert text to a markdown file buffer with UTF-8 BOM
+ * BOM is needed for proper Chinese display in DingTalk/Windows
+ */
+export function textToMarkdownFile(text: string, title?: string): { buffer: Buffer; fileName: string } {
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-').slice(0, 19);
+  const fileName = title ? `${title}.md` : `reply_${timestamp}.md`;
+
+  // Add UTF-8 BOM for proper Chinese display
+  const bom = Buffer.from([0xEF, 0xBB, 0xBF]);
+  const content = Buffer.from(text, 'utf-8');
+  const buffer = Buffer.concat([bom, content]);
+
+  return { buffer, fileName };
+}

package/src/config-schema.ts

@@ -13,6 +13,8 @@ export const messageFormatSchema = z.enum(['text', 'markdown', 'richtext', 'auto
   description: 'Message format for bot responses (richtext is an alias for markdown, auto detects markdown features)',
 });
 
+export const longTextModeSchema = z.enum(['chunk', 'file']);
+
 // DingTalk 配置 Schema
 export const dingTalkConfigSchema = z.object({
   enabled: z.boolean().default(true).describe('Enable DingTalk channel'),
@@ -71,6 +73,16 @@ export const dingTalkConfigSchema = z.object({
   // 高级配置（可选）
   textChunkLimit: z.number().int().positive().default(2000).optional()
     .describe('Text chunk size limit for long messages'),
+
+  // 长文本处理
+  longTextMode: longTextModeSchema.default('chunk')
+    .describe(
+      'How to handle long text messages:\n' +
+      '  - chunk: Split into multiple messages (default, same as official channels)\n' +
+      '  - file: Convert to .md file and send as attachment'
+    ),
+  longTextThreshold: z.number().int().positive().default(4000).optional()
+    .describe('Character threshold for longTextMode=file (default 4000)'),
 }).strict();
 
 // 导出配置类型

package/src/monitor.ts

@@ -1,5 +1,5 @@
 import type { DingTalkRobotMessage, ResolvedDingTalkAccount, ExtractedMessage } from "./types.js";
-import { sendViaSessionWebhook, sendMarkdownViaSessionWebhook, sendDingTalkRestMessage, batchGetUserInfo, downloadPicture, downloadMediaFile, cleanupOldMedia } from "./api.js";
+import { sendViaSessionWebhook, sendMarkdownViaSessionWebhook, sendDingTalkRestMessage, batchGetUserInfo, downloadPicture, downloadMediaFile, cleanupOldMedia, uploadMediaFile, sendFileMessage, textToMarkdownFile } from "./api.js";
 import { getDingTalkRuntime } from "./runtime.js";
 
 export interface DingTalkMonitorContext {
@@ -890,8 +890,26 @@ function resolveDeliverText(payload: any, log?: any): string | undefined {
 
 async function deliverReply(target: any, text: string, log?: any): Promise<void> {
   const now = Date.now();
-  const chunkLimit = 2000;
+  const chunkLimit = target.account.config.textChunkLimit ?? 2000;
   const messageFormat = target.account.config.messageFormat ?? "text";
+  const longTextMode = target.account.config.longTextMode ?? "chunk";
+  const longTextThreshold = target.account.config.longTextThreshold ?? 4000;
+
+  // Check if we should send as file instead of text
+  if (longTextMode === 'file' && text.length > longTextThreshold) {
+    log?.info?.("[dingtalk] Text exceeds threshold (" + text.length + " > " + longTextThreshold + "), sending as file");
+
+    // Only attempt file send if we have credentials (REST API required)
+    if (target.account.clientId && target.account.clientSecret) {
+      const fileSent = await sendTextAsFile(target, text, log);
+      if (fileSent) {
+        return; // Successfully sent as file
+      }
+      log?.info?.("[dingtalk] File send failed, falling back to chunked text");
+    } else {
+      log?.info?.("[dingtalk] No credentials for file send, falling back to chunked text");
+    }
+  }
 
   // Determine if this message should use markdown format
   let isMarkdown: boolean;
@@ -976,6 +994,57 @@ async function deliverReply(target: any, text: string, log?: any): Promise<void>
   }
 }
 
+/**
+ * Helper function to send text as a markdown file
+ * Used when longTextMode is 'file' and text exceeds threshold
+ */
+async function sendTextAsFile(target: any, text: string, log?: any): Promise<boolean> {
+  try {
+    // Generate markdown file with UTF-8 BOM for proper Chinese display
+    const { buffer, fileName } = textToMarkdownFile(text, "AI Response");
+    log?.info?.("[dingtalk] Converting text to file: " + fileName + " (" + buffer.length + " bytes)");
+
+    // Upload the file
+    const uploadResult = await uploadMediaFile({
+      clientId: target.account.clientId,
+      clientSecret: target.account.clientSecret,
+      robotCode: target.account.robotCode || target.account.clientId,
+      fileBuffer: buffer,
+      fileName: fileName,
+      fileType: 'file',
+    });
+
+    if (!uploadResult.mediaId) {
+      log?.info?.("[dingtalk] File upload failed: " + (uploadResult.error || "no mediaId returned"));
+      return false;
+    }
+
+    log?.info?.("[dingtalk] File uploaded, mediaId=" + uploadResult.mediaId);
+
+    // Send the file message
+    const sendResult = await sendFileMessage({
+      clientId: target.account.clientId,
+      clientSecret: target.account.clientSecret,
+      robotCode: target.account.robotCode || target.account.clientId,
+      userId: target.isDm ? target.senderId : undefined,
+      conversationId: !target.isDm ? target.conversationId : undefined,
+      mediaId: uploadResult.mediaId,
+      fileName: fileName,
+    });
+
+    if (!sendResult.ok) {
+      log?.info?.("[dingtalk] File send failed: " + (sendResult.error || "unknown error"));
+      return false;
+    }
+
+    log?.info?.("[dingtalk] File sent successfully");
+    return true;
+  } catch (err) {
+    log?.info?.("[dingtalk] sendTextAsFile error: " + (err instanceof Error ? err.message : String(err)));
+    return false;
+  }
+}
+
 /**
  * Convert bare image URLs to markdown image syntax
  * Detects patterns like "图1: https://..." or "https://...png" and converts to ![](url)