@yaoyuanchao/dingtalk 1.2.0

package/src/api.ts

@@ -0,0 +1,382 @@
+import https from "node:https";
+import http from "node:http";
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+const DINGTALK_API_BASE = "https://api.dingtalk.com/v1.0";
+const DINGTALK_OAPI_BASE = "https://oapi.dingtalk.com";
+
+/** Temp directory for downloaded pictures */
+const TEMP_DIR = path.join(os.tmpdir(), "dingtalk-pictures");
+
+/** Cache access tokens per clientId */
+const tokenCache = new Map<string, { token: string; expiresAt: number }>();
+
+function jsonPost(url: string, body: any, headers?: Record<string, string>): Promise<any> {
+  return new Promise((resolve, reject) => {
+    const data = JSON.stringify(body);
+    const urlObj = new URL(url);
+    const mod = urlObj.protocol === "https:" ? https : http;
+    const req = mod.request(urlObj, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Content-Length": Buffer.byteLength(data),
+        ...headers,
+      },
+      timeout: 10000, // 10 second timeout
+      family: 4, // Force IPv4 to avoid IPv6 connection issues
+    }, (res) => {
+      let buf = "";
+      res.on("data", (chunk: any) => { buf += chunk; });
+      res.on("end", () => {
+        try { resolve(JSON.parse(buf)); }
+        catch { resolve({ raw: buf }); }
+      });
+    });
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("Request timeout"));
+    });
+    req.write(data);
+    req.end();
+  });
+}
+
+function httpGetBuffer(url: string, headers?: Record<string, string>): Promise<Buffer> {
+  return new Promise((resolve, reject) => {
+    const urlObj = new URL(url);
+    const mod = urlObj.protocol === "https:" ? https : http;
+    const req = mod.request(urlObj, {
+      method: "GET",
+      headers: headers || {},
+      timeout: 30000, // 30 second timeout for file downloads
+      family: 4,
+    }, (res) => {
+      const chunks: Buffer[] = [];
+      res.on("data", (chunk: Buffer) => { chunks.push(chunk); });
+      res.on("end", () => {
+        resolve(Buffer.concat(chunks));
+      });
+    });
+    req.on("error", reject);
+    req.on("timeout", () => {
+      req.destroy();
+      reject(new Error("Download timeout"));
+    });
+    req.end();
+  });
+}
+
+export async function getDingTalkAccessToken(clientId: string, clientSecret: string): Promise<string> {
+  const cached = tokenCache.get(clientId);
+  if (cached && cached.expiresAt > Date.now() + 60_000) {
+    return cached.token;
+  }
+  const res = await jsonPost(`${DINGTALK_API_BASE}/oauth2/accessToken`, {
+    appKey: clientId,
+    appSecret: clientSecret,
+  });
+  if (!res.accessToken) {
+    throw new Error(`DingTalk token error: ${JSON.stringify(res)}`);
+  }
+  tokenCache.set(clientId, {
+    token: res.accessToken,
+    expiresAt: Date.now() + (res.expireIn ?? 7200) * 1000,
+  });
+  return res.accessToken;
+}
+
+/** Send reply via sessionWebhook (preferred, no auth needed) */
+export async function sendViaSessionWebhook(
+  sessionWebhook: string,
+  text: string,
+): Promise<{ ok: boolean }> {
+  const res = await jsonPost(sessionWebhook, {
+    msgtype: "text",
+    text: { content: text },
+  });
+  return { ok: res?.errcode === 0 || !res?.errcode };
+}
+
+/** Send markdown via sessionWebhook */
+export async function sendMarkdownViaSessionWebhook(
+  sessionWebhook: string,
+  title: string,
+  text: string,
+): Promise<{ ok: boolean }> {
+  const res = await jsonPost(sessionWebhook, {
+    msgtype: "markdown",
+    markdown: { title, text },
+  });
+  return { ok: res?.errcode === 0 || !res?.errcode };
+}
+
+/** Send image via sessionWebhook using markdown format */
+export async function sendImageViaSessionWebhook(
+  sessionWebhook: string,
+  imageUrl: string,
+  caption?: string,
+): Promise<{ ok: boolean }> {
+  const title = caption || "图片";
+  const text = caption
+    ? `${caption}\n\n![image](${imageUrl})`
+    : `![image](${imageUrl})`;
+
+  return sendMarkdownViaSessionWebhook(sessionWebhook, title, text);
+}
+
+/** Send message via REST API (proactive/outbound, requires token) */
+export async function sendDingTalkRestMessage(params: {
+  clientId: string;
+  clientSecret: string;
+  robotCode: string;
+  userId?: string;
+  conversationId?: string;
+  text: string;
+}): Promise<{ ok: boolean }> {
+  const token = await getDingTalkAccessToken(params.clientId, params.clientSecret);
+  const headers = { "x-acs-dingtalk-access-token": token };
+
+  if (params.userId) {
+    const res = await jsonPost(
+      `${DINGTALK_API_BASE}/robot/oToMessages/batchSend`,
+      {
+        robotCode: params.robotCode,
+        userIds: [params.userId],
+        msgKey: "sampleText",
+        msgParam: JSON.stringify({ content: params.text }),
+      },
+      headers,
+    );
+    if (res?.errcode && res.errcode !== 0) {
+      throw new Error(`DingTalk DM send error: ${JSON.stringify(res)}`);
+    }
+    return { ok: !!res?.processQueryKey || !res?.code };
+  }
+
+  if (params.conversationId) {
+    const res = await jsonPost(
+      `${DINGTALK_API_BASE}/robot/groupMessages/send`,
+      {
+        robotCode: params.robotCode,
+        openConversationId: params.conversationId,
+        msgKey: "sampleText",
+        msgParam: JSON.stringify({ content: params.text }),
+      },
+      headers,
+    );
+    if (res?.errcode && res.errcode !== 0) {
+      throw new Error(`DingTalk group send error: ${JSON.stringify(res)}`);
+    }
+    return { ok: !!res?.processQueryKey || !res?.code };
+  }
+
+  throw new Error("Either userId or conversationId required");
+}
+
+/** Probe DingTalk connection by getting an access token */
+export async function probeDingTalk(
+  clientId: string,
+  clientSecret: string,
+): Promise<{ ok: boolean; error?: string }> {
+  try {
+    await getDingTalkAccessToken(clientId, clientSecret);
+    return { ok: true };
+  } catch (err) {
+    return { ok: false, error: String(err) };
+  }
+}
+
+/** User info cache - persisted to local file */
+const USER_CACHE_FILE = path.join(os.homedir(), ".clawdbot", "extensions", "dingtalk", ".cache", "users.json");
+let userCache: Map<string, { name: string; avatar?: string }> | null = null;
+
+function loadUserCache(): Map<string, { name: string; avatar?: string }> {
+  if (userCache) return userCache;
+
+  try {
+    if (fs.existsSync(USER_CACHE_FILE)) {
+      const data = fs.readFileSync(USER_CACHE_FILE, "utf-8");
+      const obj = JSON.parse(data);
+      userCache = new Map(Object.entries(obj));
+      return userCache;
+    }
+  } catch (err) {
+    console.warn("[dingtalk] Failed to load user cache:", err);
+  }
+
+  userCache = new Map();
+  return userCache;
+}
+
+function saveUserCache(cache: Map<string, { name: string; avatar?: string }>): void {
+  try {
+    const dir = path.dirname(USER_CACHE_FILE);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    const obj = Object.fromEntries(cache.entries());
+    fs.writeFileSync(USER_CACHE_FILE, JSON.stringify(obj, null, 2), "utf-8");
+  } catch (err) {
+    console.warn("[dingtalk] Failed to save user cache:", err);
+  }
+}
+
+/** Get user info by userid (staffId), with persistent cache */
+export async function getUserInfo(
+  clientId: string,
+  clientSecret: string,
+  userid: string,
+): Promise<{ name: string; avatar?: string } | null> {
+  const cache = loadUserCache();
+
+  // Check cache first
+  const cached = cache.get(userid);
+  if (cached) return cached;
+
+  // Call DingTalk API
+  try {
+    const token = await getDingTalkAccessToken(clientId, clientSecret);
+    const res = await jsonPost(
+      `${DINGTALK_OAPI_BASE}/topapi/v2/user/get?access_token=${token}`,
+      {
+        userid,
+        language: "zh_CN",
+      },
+    );
+
+    if (res.errcode !== 0) {
+      console.warn(`[dingtalk] Failed to get user info for ${userid}: ${res.errmsg}`);
+      return null;
+    }
+
+    const userInfo = {
+      name: res.result?.name || userid,
+      avatar: res.result?.avatar,
+    };
+
+    // Save to cache
+    cache.set(userid, userInfo);
+    saveUserCache(cache);
+
+    return userInfo;
+  } catch (err) {
+    console.warn(`[dingtalk] Error getting user info for ${userid}:`, err);
+    return null;
+  }
+}
+
+/** Batch get user info with timeout */
+export async function batchGetUserInfo(
+  clientId: string,
+  clientSecret: string,
+  userids: string[],
+  timeoutMs: number = 500,
+): Promise<Map<string, string>> {
+  const result = new Map<string, string>();
+
+  if (userids.length === 0) return result;
+
+  const promises = userids.map(async (userid) => {
+    const info = await getUserInfo(clientId, clientSecret, userid);
+    if (info) {
+      result.set(userid, info.name);
+    }
+  });
+
+  try {
+    await Promise.race([
+      Promise.all(promises),
+      new Promise((_, reject) => setTimeout(() => reject(new Error("timeout")), timeoutMs)),
+    ]);
+  } catch (err) {
+    // Timeout or error - return partial results
+    console.warn(`[dingtalk] Batch user info fetch timeout/error:`, err);
+  }
+
+  return result;
+}
+
+/** Download picture from DingTalk and return as base64 or file path */
+export async function downloadPicture(
+  clientId: string,
+  clientSecret: string,
+  robotCode: string,
+  downloadCode: string,
+): Promise<{ base64?: string; filePath?: string; error?: string }> {
+  try {
+    const token = await getDingTalkAccessToken(clientId, clientSecret);
+
+    // DingTalk picture download API (v1.0 API, NOT oapi)
+    const url = `${DINGTALK_API_BASE}/robot/messageFiles/download`;
+    const headers = {
+      "x-acs-dingtalk-access-token": token,
+    };
+    const body = {
+      downloadCode,
+      robotCode,
+    };
+
+    // Download as buffer
+    const response = await jsonPost(url, body, headers);
+
+    // Check if response contains error
+    if (response.errcode && response.errcode !== 0) {
+      console.warn(`[dingtalk] Picture download failed: ${response.errmsg}`);
+      return { error: response.errmsg || "Download failed" };
+    }
+
+    // If response has a file URL, download it
+    if (response.downloadUrl) {
+      const imageBuffer = await httpGetBuffer(response.downloadUrl);
+
+      // Convert to base64
+      const base64 = imageBuffer.toString('base64');
+
+      // Also save to temp file for reference
+      if (!fs.existsSync(TEMP_DIR)) {
+        fs.mkdirSync(TEMP_DIR, { recursive: true });
+      }
+
+      const timestamp = Date.now();
+      const filename = `picture_${timestamp}.jpg`;
+      const filePath = path.join(TEMP_DIR, filename);
+
+      fs.writeFileSync(filePath, imageBuffer);
+
+      console.log(`[dingtalk] Picture downloaded successfully: ${filePath} (${imageBuffer.length} bytes)`);
+
+      return { base64, filePath };
+    }
+
+    return { error: "No download URL in response" };
+  } catch (err) {
+    console.warn(`[dingtalk] Error downloading picture:`, err);
+    return { error: String(err) };
+  }
+}
+
+/** Clean up old picture files (older than 1 hour) */
+export function cleanupOldPictures(): void {
+  try {
+    if (!fs.existsSync(TEMP_DIR)) return;
+
+    const files = fs.readdirSync(TEMP_DIR);
+    const oneHourAgo = Date.now() - 60 * 60 * 1000;
+
+    for (const file of files) {
+      const filePath = path.join(TEMP_DIR, file);
+      const stats = fs.statSync(filePath);
+
+      if (stats.mtimeMs < oneHourAgo) {
+        fs.unlinkSync(filePath);
+        console.log(`[dingtalk] Cleaned up old picture: ${filePath}`);
+      }
+    }
+  } catch (err) {
+    console.warn(`[dingtalk] Error cleaning up pictures:`, err);
+  }
+}

package/src/channel.ts

@@ -0,0 +1,271 @@
+import { getDingTalkRuntime } from './runtime.js';
+import { resolveDingTalkAccount } from './accounts.js';
+import { startDingTalkMonitor } from './monitor.js';
+import { sendDingTalkRestMessage } from './api.js';
+import { probeDingTalk } from './probe.js';
+
+export const dingtalkPlugin = {
+  id: 'dingtalk',
+
+  meta: {
+    label: 'DingTalk',
+    selectionLabel: 'DingTalk (钉钉)',
+    detailLabel: 'DingTalk',
+    blurb: 'DingTalk bot via Stream Mode (WebSocket)',
+    aliases: ['dingding', 'dd'],
+    order: 75,
+  },
+
+  capabilities: {
+    chatTypes: ['direct', 'group'],
+    media: true, // Supports images via markdown in sessionWebhook replies
+    threads: false,
+    reactions: false,
+    mentions: true,
+  },
+
+  config: {
+    schema: {
+      type: 'object',
+      properties: {
+        enabled: {
+          type: 'boolean',
+          title: 'Enable DingTalk',
+          default: true,
+        },
+        clientId: {
+          type: 'string',
+          title: 'Client ID (AppKey)',
+          description: 'DingTalk application AppKey',
+        },
+        clientSecret: {
+          type: 'string',
+          title: 'Client Secret (AppSecret)',
+          description: 'DingTalk application AppSecret',
+          secret: true,
+        },
+        robotCode: {
+          type: 'string',
+          title: 'Robot Code (Optional)',
+          description: 'Optional robot code, defaults to Client ID',
+        },
+        dm: {
+          type: 'object',
+          title: 'Direct Message Settings',
+          properties: {
+            enabled: {
+              type: 'boolean',
+              title: 'Enable DM',
+              default: true,
+            },
+            policy: {
+              type: 'string',
+              title: 'DM Access Policy',
+              enum: ['disabled', 'pairing', 'allowlist', 'open'],
+              default: 'pairing',
+              description: 'disabled=no DM, pairing=show staffId to add, allowlist=only allowed users, open=everyone',
+            },
+            allowFrom: {
+              type: 'array',
+              title: 'Allowed Staff IDs',
+              items: { type: 'string' },
+              default: [],
+              description: 'List of staff IDs allowed to DM the bot',
+            },
+          },
+        },
+        groupPolicy: {
+          type: 'string',
+          title: 'Group Chat Policy',
+          enum: ['disabled', 'allowlist', 'open'],
+          default: 'allowlist',
+          description: 'disabled=no groups, allowlist=specific groups, open=all groups',
+        },
+        groupAllowlist: {
+          type: 'array',
+          title: 'Allowed Group IDs',
+          items: { type: 'string' },
+          default: [],
+          description: 'List of conversation IDs for allowed groups (only used when groupPolicy is "allowlist")',
+        },
+        requireMention: {
+          type: 'boolean',
+          title: 'Require @ Mention in Groups',
+          default: true,
+          description: 'If true, bot only responds when @mentioned in group chats',
+        },
+        messageFormat: {
+          type: 'string',
+          title: 'Message Format',
+          enum: ['text', 'markdown'],
+          default: 'text',
+          description: 'text=plain text, markdown=DingTalk markdown (limited: no tables, use text for tables)',
+        },
+      },
+      required: ['clientId', 'clientSecret'],
+    },
+
+    listAccountIds(cfg) {
+      const channel = cfg?.channels?.dingtalk ?? {};
+      if (channel.clientId) return ['default'];
+      return [];
+    },
+
+    resolveAccount(cfg, accountId) {
+      return resolveDingTalkAccount({ cfg, accountId });
+    },
+
+    defaultAccountId() {
+      return 'default';
+    },
+
+    setAccountEnabled({ cfg, accountId, enabled }) {
+      const runtime = getDingTalkRuntime();
+      runtime.config.set('channels.dingtalk.enabled', enabled);
+    },
+
+    deleteAccount({ cfg, accountId }) {
+      const runtime = getDingTalkRuntime();
+      runtime.config.delete('channels.dingtalk');
+    },
+
+    isConfigured(account) {
+      return !!(account.clientId && account.clientSecret);
+    },
+
+    describeAccount(account) {
+      return {
+        accountId: account.accountId,
+        name: account.name || 'DingTalk Bot',
+        enabled: account.enabled,
+        configured: !!(account.clientId && account.clientSecret),
+        credentialSource: account.credentialSource,
+      };
+    },
+  },
+
+  security: {
+    resolveDmPolicy({ cfg, accountId, account }) {
+      const dm = account.config.dm ?? {};
+      return {
+        policy: dm.policy ?? 'pairing',
+        allowFrom: dm.allowFrom ?? [],
+      };
+    },
+  },
+
+  outbound: {
+    deliveryMode: 'buffer',
+    textChunkLimit: 2000,
+
+    async sendText({ to, text, accountId, cfg }) {
+      const account = resolveDingTalkAccount({ cfg, accountId });
+      const [type, id] = to.split(':');
+
+      if (type === 'dm') {
+        await sendDingTalkRestMessage({
+          clientId: account.clientId,
+          clientSecret: account.clientSecret,
+          robotCode: account.robotCode || account.clientId,
+          userId: id,
+          text,
+        });
+      } else if (type === 'group') {
+        await sendDingTalkRestMessage({
+          clientId: account.clientId,
+          clientSecret: account.clientSecret,
+          robotCode: account.robotCode || account.clientId,
+          conversationId: id,
+          text,
+        });
+      }
+
+      return { channel: 'dingtalk', ok: true };
+    },
+
+    async sendMedia({ to, text, mediaUrl, accountId, cfg }) {
+      // Note: DingTalk REST API (oToMessages/groupMessages) doesn't support markdown or images
+      // Images can only be sent via sessionWebhook (when replying to messages)
+      // For now, we send the image URL as a text link
+
+      if (!mediaUrl) {
+        throw new Error('mediaUrl is required for sending media on DingTalk');
+      }
+
+      // Check if URL is accessible (basic check)
+      if (!mediaUrl.startsWith('http://') && !mediaUrl.startsWith('https://')) {
+        throw new Error('DingTalk requires publicly accessible image URLs (http:// or https://)');
+      }
+
+      const account = resolveDingTalkAccount({ cfg, accountId });
+      const [type, id] = to.split(':');
+
+      // Build text message with image URL
+      const textMessage = text
+        ? `${text}\n\n图片链接: ${mediaUrl}`
+        : `图片链接: ${mediaUrl}`;
+
+      if (type === 'dm') {
+        await sendDingTalkRestMessage({
+          clientId: account.clientId,
+          clientSecret: account.clientSecret,
+          robotCode: account.robotCode || account.clientId,
+          userId: id,
+          text: textMessage,
+        });
+      } else if (type === 'group') {
+        await sendDingTalkRestMessage({
+          clientId: account.clientId,
+          clientSecret: account.clientSecret,
+          robotCode: account.robotCode || account.clientId,
+          conversationId: id,
+          text: textMessage,
+        });
+      }
+
+      return { channel: 'dingtalk', ok: true };
+    },
+  },
+
+  gateway: {
+    async startAccount({ account, signal, setStatus }) {
+      const runtime = getDingTalkRuntime();
+      const log = runtime.log?.child?.({ channel: 'dingtalk', account: account.accountId }) ?? runtime.log ?? console;
+      const cfg = runtime.config;
+
+      log.info?.('[dingtalk] Starting Stream connection...');
+
+      try {
+        await startDingTalkMonitor({
+          account,
+          cfg,
+          abortSignal: signal,
+          log,
+          setStatus,
+        });
+
+        log.info?.('[dingtalk] Stream connection started successfully');
+      } catch (err) {
+        log.error?.('[dingtalk] Failed to start Stream', err);
+        throw err;
+      }
+    },
+  },
+
+  status: {
+    async probeAccount(account) {
+      if (!account.configured || !account.clientId || !account.clientSecret) {
+        return { ok: false, error: 'Not configured' };
+      }
+
+      return await probeDingTalk(account.clientId, account.clientSecret);
+    },
+  },
+
+  onboarding: {
+    async run(ctx: any) {
+      const { onboardDingTalk } = await import('./onboarding.js');
+      return onboardDingTalk(ctx);
+    },
+  },
+};