@axhub/genie 0.1.6 → 0.1.8

package/server/channels/plugins/dingtalk/DingTalkPlugin.js

@@ -0,0 +1,592 @@
+import https from 'https';
+
+import { DWClient, TOPIC_ROBOT, EventAck } from 'dingtalk-stream';
+
+import { BasePlugin } from '../BasePlugin.js';
+import {
+  DINGTALK_MESSAGE_LIMIT,
+  encodeChatId,
+  parseChatId,
+  toDingTalkSendParams,
+  toIncomingMessage,
+  convertHtmlToDingTalkMarkdown,
+  truncateDingTalkText,
+} from './DingTalkAdapter.js';
+
+const EVENT_CACHE_TTL = 5 * 60 * 1000;
+const EVENT_CACHE_CLEANUP_INTERVAL = 60 * 1000;
+const DINGTALK_API_BASE = 'https://api.dingtalk.com';
+const AI_CARD_TEMPLATE_ID = '382e4302-551d-4880-bf29-a30acfab2e71.schema';
+
+const AI_CARD_STATUS = {
+  INPUTING: '2',
+  FINISHED: '3',
+};
+
+export class DingTalkPlugin extends BasePlugin {
+  constructor() {
+    super('dingtalk');
+
+    this.client = null;
+    this.isConnected = false;
+
+    this.clientId = '';
+    this.clientSecret = '';
+
+    this.tokenCache = null;
+    this.activeUsers = new Set();
+    this.processedEvents = new Map();
+    this.eventCleanupTimer = null;
+
+    this.aiCardSessions = new Map();
+    this.webhookCache = new Map();
+  }
+
+  async onInitialize(config) {
+    const clientId = config?.clientId;
+    const clientSecret = config?.clientSecret;
+
+    if (!clientId || !clientSecret) {
+      throw new Error('DingTalk Client ID and Client Secret are required');
+    }
+
+    this.clientId = String(clientId).trim();
+    this.clientSecret = String(clientSecret).trim();
+  }
+
+  async onStart() {
+    if (!this.clientId || !this.clientSecret) {
+      throw new Error('DingTalk credentials are missing');
+    }
+
+    await this.refreshAccessToken();
+
+    this.client = new DWClient({
+      clientId: this.clientId,
+      clientSecret: this.clientSecret,
+      keepAlive: true,
+      debug: false,
+    });
+
+    this.client.registerCallbackListener(TOPIC_ROBOT, (msg) => {
+      this.client?.socketCallBackResponse(msg.headers.messageId, EventAck.SUCCESS);
+
+      try {
+        const data = JSON.parse(msg.data);
+        void this.handleRobotMessage(data, msg.headers.messageId).catch((error) => {
+          console.error('[DingTalkPlugin] Error handling robot message:', error);
+        });
+      } catch (error) {
+        console.error('[DingTalkPlugin] Failed to parse robot message:', error);
+      }
+    });
+
+    await this.client.connect();
+    this.isConnected = true;
+    this.startEventCleanup();
+
+    console.log(`[DingTalkPlugin] Started for client ${this.clientId}`);
+  }
+
+  async onStop() {
+    this.stopEventCleanup();
+
+    if (this.client) {
+      try {
+        this.client.disconnect();
+      } catch {
+        // ignore
+      }
+      this.client = null;
+    }
+
+    this.tokenCache = null;
+    this.activeUsers.clear();
+    this.processedEvents.clear();
+    this.aiCardSessions.clear();
+    this.webhookCache.clear();
+    this.isConnected = false;
+
+    console.log('[DingTalkPlugin] Stopped and cleaned up');
+  }
+
+  getActiveUserCount() {
+    return this.activeUsers.size;
+  }
+
+  getBotInfo() {
+    if (!this.clientId) {
+      return null;
+    }
+    return {
+      id: this.clientId,
+      displayName: 'Genie DingTalk Bot',
+    };
+  }
+
+  async sendText(chatId, text) {
+    return this.sendMessage(chatId, {
+      type: 'text',
+      text: truncateDingTalkText(convertHtmlToDingTalkMarkdown(String(text || '')), DINGTALK_MESSAGE_LIMIT),
+    });
+  }
+
+  async sendMessage(chatId, message) {
+    await this.ensureAccessToken();
+
+    const { contentType, content, rawText } = toDingTalkSendParams(message);
+    const { type: chatType, id } = parseChatId(chatId);
+
+    if (contentType === 'markdown' && rawText !== undefined) {
+      try {
+        const cardMessageId = await this.createAndDeliverAICard(chatType, id);
+        const initialText = truncateDingTalkText(convertHtmlToDingTalkMarkdown(rawText), DINGTALK_MESSAGE_LIMIT);
+        if (initialText) {
+          await this.streamAICard(this.aiCardSessions.get(cardMessageId)?.outTrackId, initialText, false);
+        }
+        return cardMessageId;
+      } catch (error) {
+        console.warn('[DingTalkPlugin] AI Card failed, falling back to webhook/API:', error?.message || error);
+      }
+    }
+
+    const webhook = this.webhookCache.get(chatId);
+    if (webhook) {
+      const messageId = await this.sendViaWebhook(webhook, contentType, content, rawText);
+      return messageId;
+    }
+
+    return this.sendViaAPI(chatType, id, contentType, content, rawText);
+  }
+
+  async editMessage(chatId, messageId, message) {
+    const session = this.aiCardSessions.get(messageId);
+    const isFinal = !!message?.isFinal;
+
+    if (!session || session.isFinished) {
+      if (isFinal && message?.text) {
+        await this.sendPlainMessage(chatId, message);
+      }
+      return;
+    }
+
+    const text = truncateDingTalkText(
+      convertHtmlToDingTalkMarkdown(String(message?.text || '')),
+      DINGTALK_MESSAGE_LIMIT
+    ) || ' ';
+
+    try {
+      await this.streamAICard(session.outTrackId, text, isFinal);
+
+      if (isFinal) {
+        await this.finishAICard(session.outTrackId, text);
+        this.aiCardSessions.set(messageId, { ...session, isFinished: true });
+      }
+    } catch (error) {
+      console.error('[DingTalkPlugin] Failed to update AI Card:', error);
+      this.aiCardSessions.set(messageId, { ...session, isFinished: true });
+
+      if (isFinal && message?.text) {
+        await this.sendPlainMessage(chatId, message);
+      }
+    }
+  }
+
+  async handleRobotMessage(data, streamMessageId) {
+    const eventId = data?.msgId || streamMessageId;
+
+    if (eventId && this.isEventProcessed(eventId)) {
+      return;
+    }
+    if (eventId) {
+      this.markEventProcessed(eventId);
+    }
+
+    const userId = String(data?.senderStaffId || '').trim();
+    if (!userId) {
+      return;
+    }
+
+    this.activeUsers.add(userId);
+
+    if (data?.sessionWebhook) {
+      const chatId = encodeChatId(data);
+      this.webhookCache.set(chatId, data.sessionWebhook);
+    }
+
+    const incoming = toIncomingMessage(data);
+    if (!incoming || !this.messageHandler) {
+      return;
+    }
+
+    try {
+      await this.messageHandler(incoming);
+    } catch (error) {
+      console.error('[DingTalkPlugin] Failed to process incoming message:', error);
+    }
+  }
+
+  async createAndDeliverAICard(chatType, id) {
+    const token = await this.getAccessToken();
+    const outTrackId = `genie_${Date.now()}_${Math.random().toString(36).slice(2, 8)}`;
+
+    await this.apiRequest('POST', '/v1.0/card/instances', token, {
+      cardTemplateId: AI_CARD_TEMPLATE_ID,
+      outTrackId,
+      cardData: {
+        cardParamMap: {},
+      },
+      callbackType: 'STREAM',
+      imGroupOpenSpaceModel: { supportForward: true },
+      imRobotOpenSpaceModel: { supportForward: true },
+    });
+
+    const openSpaceId = chatType === 'group' ? `dtv1.card//IM_GROUP.${id}` : `dtv1.card//IM_ROBOT.${id}`;
+
+    await this.apiRequest('POST', '/v1.0/card/instances/deliver', token, {
+      outTrackId,
+      openSpaceId,
+      userIdType: 1,
+      imGroupOpenDeliverModel: chatType === 'group' ? { robotCode: this.clientId } : undefined,
+      imRobotOpenDeliverModel: chatType === 'user' ? { spaceType: 'IM_ROBOT' } : undefined,
+    });
+
+    const messageId = `aicard_${outTrackId}`;
+    this.aiCardSessions.set(messageId, {
+      outTrackId,
+      openSpaceId,
+      isFinished: false,
+      inputingStarted: false,
+    });
+
+    return messageId;
+  }
+
+  async streamAICard(outTrackId, content, isFinalize = false) {
+    if (!outTrackId) {
+      throw new Error('Missing outTrackId for AI Card stream');
+    }
+
+    const token = await this.getAccessToken();
+    const session = this.findCardSessionByTrackId(outTrackId);
+
+    if (session && !session.inputingStarted) {
+      await this.apiRequest('PUT', '/v1.0/card/instances', token, {
+        outTrackId,
+        cardData: {
+          cardParamMap: {
+            flowStatus: AI_CARD_STATUS.INPUTING,
+            msgContent: '',
+            staticMsgContent: '',
+            sys_full_json_obj: JSON.stringify({ order: ['msgContent'] }),
+          },
+        },
+      });
+      session.inputingStarted = true;
+    }
+
+    await this.apiRequest('PUT', '/v1.0/card/streaming', token, {
+      outTrackId,
+      key: 'msgContent',
+      content,
+      isFull: true,
+      isFinalize,
+      isError: false,
+      guid: `${Date.now()}_${Math.random().toString(36).slice(2, 6)}`,
+    });
+  }
+
+  async finishAICard(outTrackId, finalContent) {
+    if (!outTrackId) {
+      return;
+    }
+
+    const token = await this.getAccessToken();
+    await this.apiRequest('PUT', '/v1.0/card/instances', token, {
+      outTrackId,
+      cardData: {
+        cardParamMap: {
+          flowStatus: AI_CARD_STATUS.FINISHED,
+          msgContent: finalContent,
+          staticMsgContent: '',
+          sys_full_json_obj: JSON.stringify({ order: ['msgContent'] }),
+        },
+      },
+    });
+  }
+
+  findCardSessionByTrackId(outTrackId) {
+    for (const session of this.aiCardSessions.values()) {
+      if (session.outTrackId === outTrackId) {
+        return session;
+      }
+    }
+    return undefined;
+  }
+
+  async sendPlainMessage(chatId, message) {
+    try {
+      await this.ensureAccessToken();
+      const { contentType, content, rawText } = toDingTalkSendParams(message);
+      const { type: chatType, id } = parseChatId(chatId);
+
+      const webhook = this.webhookCache.get(chatId);
+      if (webhook) {
+        await this.sendViaWebhook(webhook, contentType, content, rawText);
+        return;
+      }
+
+      await this.sendViaAPI(chatType, id, contentType, content, rawText);
+    } catch (error) {
+      console.error('[DingTalkPlugin] Fallback plain message send failed:', error);
+    }
+  }
+
+  async sendViaWebhook(webhook, contentType, content, rawText) {
+    let body;
+
+    if (contentType === 'actionCard') {
+      body = {
+        msgtype: 'actionCard',
+        actionCard: content,
+      };
+    } else {
+      body = {
+        msgtype: 'markdown',
+        markdown: {
+          title: 'Message',
+          text: rawText || JSON.stringify(content),
+        },
+      };
+    }
+
+    const response = await this.httpPost(webhook, body);
+    return response?.messageId || `webhook_${Date.now()}`;
+  }
+
+  async sendViaAPI(chatType, id, contentType, content, rawText) {
+    const token = await this.getAccessToken();
+
+    if (chatType === 'user') {
+      const body = {
+        robotCode: this.clientId,
+        userIds: [id],
+        msgKey: contentType === 'actionCard' ? 'sampleActionCard6' : 'sampleMarkdown',
+        msgParam:
+          contentType === 'actionCard'
+            ? JSON.stringify(content)
+            : JSON.stringify({ title: 'Message', text: rawText || '' }),
+      };
+
+      const response = await this.apiRequest('POST', '/v1.0/robot/oToMessages/batchSend', token, body);
+      return response?.processQueryKey || `api_${Date.now()}`;
+    }
+
+    const body = {
+      robotCode: this.clientId,
+      openConversationId: id,
+      msgKey: contentType === 'actionCard' ? 'sampleActionCard6' : 'sampleMarkdown',
+      msgParam:
+        contentType === 'actionCard'
+          ? JSON.stringify(content)
+          : JSON.stringify({ title: 'Message', text: rawText || '' }),
+    };
+
+    const response = await this.apiRequest('POST', '/v1.0/robot/groupMessages/send', token, body);
+    return response?.processQueryKey || `api_${Date.now()}`;
+  }
+
+  async getAccessToken() {
+    await this.ensureAccessToken();
+    return this.tokenCache?.accessToken || '';
+  }
+
+  async ensureAccessToken() {
+    const now = Date.now();
+    if (!this.tokenCache || this.tokenCache.expiresAt - now < 60 * 1000) {
+      await this.refreshAccessToken();
+    }
+  }
+
+  async refreshAccessToken() {
+    const response = await this.httpPost(`${DINGTALK_API_BASE}/v1.0/oauth2/accessToken`, {
+      appKey: this.clientId,
+      appSecret: this.clientSecret,
+    });
+
+    if (!response?.accessToken) {
+      throw new Error('Failed to refresh DingTalk access token');
+    }
+
+    this.tokenCache = {
+      accessToken: response.accessToken,
+      expiresAt: Date.now() + (response.expireIn || 7200) * 1000,
+    };
+  }
+
+  async apiRequest(method, path, token, body) {
+    const url = `${DINGTALK_API_BASE}${path}`;
+    return this.httpRequest(method, url, body, {
+      'x-acs-dingtalk-access-token': token,
+      'Content-Type': 'application/json',
+    });
+  }
+
+  async httpPost(url, body) {
+    return this.httpRequest('POST', url, body, {
+      'Content-Type': 'application/json',
+    });
+  }
+
+  httpRequest(method, url, body, headers = {}) {
+    return new Promise((resolve, reject) => {
+      const urlObj = new URL(url);
+      const payload = body ? JSON.stringify(body) : undefined;
+
+      const options = {
+        hostname: urlObj.hostname,
+        port: urlObj.port || 443,
+        path: urlObj.pathname + urlObj.search,
+        method,
+        headers: {
+          ...headers,
+          ...(payload ? { 'Content-Length': Buffer.byteLength(payload).toString() } : {}),
+        },
+      };
+
+      const req = https.request(options, (res) => {
+        let responseData = '';
+
+        res.on('data', (chunk) => {
+          responseData += chunk;
+        });
+
+        res.on('end', () => {
+          try {
+            const parsed = responseData ? JSON.parse(responseData) : {};
+            if (res.statusCode && res.statusCode >= 400) {
+              reject(new Error(`HTTP ${res.statusCode}: ${JSON.stringify(parsed)}`));
+              return;
+            }
+            resolve(parsed);
+          } catch {
+            resolve(responseData);
+          }
+        });
+      });
+
+      req.on('error', reject);
+      req.setTimeout(30000, () => {
+        req.destroy(new Error('Request timeout'));
+      });
+
+      if (payload) {
+        req.write(payload);
+      }
+
+      req.end();
+    });
+  }
+
+  isEventProcessed(eventId) {
+    return this.processedEvents.has(eventId);
+  }
+
+  markEventProcessed(eventId) {
+    this.processedEvents.set(eventId, Date.now());
+  }
+
+  startEventCleanup() {
+    if (this.eventCleanupTimer) {
+      return;
+    }
+
+    this.eventCleanupTimer = setInterval(() => {
+      const now = Date.now();
+      for (const [eventId, timestamp] of this.processedEvents.entries()) {
+        if (now - timestamp > EVENT_CACHE_TTL) {
+          this.processedEvents.delete(eventId);
+        }
+      }
+    }, EVENT_CACHE_CLEANUP_INTERVAL);
+  }
+
+  stopEventCleanup() {
+    if (!this.eventCleanupTimer) {
+      return;
+    }
+
+    clearInterval(this.eventCleanupTimer);
+    this.eventCleanupTimer = null;
+  }
+
+  static async testConnection(clientId, clientSecret = '') {
+    const resolvedClientId = String(clientId || '').trim();
+    const resolvedClientSecret = String(clientSecret || '').trim();
+
+    if (!resolvedClientId || !resolvedClientSecret) {
+      return {
+        success: false,
+        error: 'Client ID and Client Secret are required',
+      };
+    }
+
+    try {
+      const response = await new Promise((resolve, reject) => {
+        const data = JSON.stringify({
+          appKey: resolvedClientId,
+          appSecret: resolvedClientSecret,
+        });
+
+        const options = {
+          hostname: 'api.dingtalk.com',
+          port: 443,
+          path: '/v1.0/oauth2/accessToken',
+          method: 'POST',
+          headers: {
+            'Content-Type': 'application/json',
+            'Content-Length': Buffer.byteLength(data).toString(),
+          },
+        };
+
+        const req = https.request(options, (res) => {
+          let responseData = '';
+          res.on('data', (chunk) => {
+            responseData += chunk;
+          });
+          res.on('end', () => {
+            try {
+              resolve(JSON.parse(responseData));
+            } catch {
+              reject(new Error('Invalid response from DingTalk API'));
+            }
+          });
+        });
+
+        req.on('error', reject);
+        req.setTimeout(10000, () => {
+          req.destroy(new Error('Connection timeout'));
+        });
+        req.write(data);
+        req.end();
+      });
+
+      if (response?.accessToken) {
+        return {
+          success: true,
+          botInfo: { name: 'DingTalk Bot' },
+        };
+      }
+
+      return {
+        success: false,
+        error: response?.message || response?.errmsg || 'Failed to connect to DingTalk API',
+      };
+    } catch (error) {
+      return {
+        success: false,
+        error: error?.message || 'Failed to connect to DingTalk API',
+      };
+    }
+  }
+}

package/server/channels/plugins/dingtalk/index.js

@@ -0,0 +1,2 @@
+export { DingTalkPlugin } from './DingTalkPlugin.js';
+export * from './DingTalkAdapter.js';

package/server/channels/plugins/lark/LarkAdapter.js

@@ -0,0 +1,100 @@
+export const LARK_TEXT_LIMIT = 4000;
+
+export function extractEffectiveUserId(sender = {}) {
+  const senderId = sender?.sender_id || {};
+  return senderId.user_id || senderId.open_id || senderId.union_id || '';
+}
+
+export function toIncomingMessage(event = {}) {
+  const message = event?.message;
+  const sender = event?.sender;
+
+  if (!message || !sender) {
+    return null;
+  }
+
+  const effectiveUserId = extractEffectiveUserId(sender);
+  if (!effectiveUserId) {
+    return {
+      id: message.message_id || `${Date.now()}`,
+      chatId: message.chat_id || '',
+      effectiveUserId: '',
+      text: '',
+      messageType: message.message_type || 'unknown',
+      displayName: 'Unknown User',
+      raw: event,
+    };
+  }
+
+  const parsed = parseLarkContent(message.message_type, message.content);
+
+  return {
+    id: message.message_id || `${Date.now()}`,
+    chatId: message.chat_id || effectiveUserId,
+    effectiveUserId,
+    text: parsed.text,
+    messageType: message.message_type || 'text',
+    displayName: `User ${effectiveUserId.slice(-6)}`,
+    raw: event,
+  };
+}
+
+function parseLarkContent(messageType, content) {
+  let parsed = content;
+  try {
+    parsed = typeof content === 'string' ? JSON.parse(content) : content;
+  } catch {
+    parsed = content;
+  }
+
+  if (messageType === 'text') {
+    return {
+      text: typeof parsed === 'object' && parsed ? parsed.text || '' : String(parsed || ''),
+    };
+  }
+
+  return {
+    text: '',
+  };
+}
+
+export function convertHtmlToLarkMarkdown(input) {
+  if (!input) return '';
+
+  let text = String(input);
+  text = text
+    .replace(/"/gi, '"')
+    .replace(/'|'/gi, "'")
+    .replace(/&#x([0-9a-f]+);/gi, (_, hex) => String.fromCharCode(parseInt(hex, 16)))
+    .replace(/&#(\d+);/g, (_, dec) => String.fromCharCode(parseInt(dec, 10)));
+
+  text = text.replace(/<b>(.+?)<\/b>/gi, '**$1**');
+  text = text.replace(/<strong>(.+?)<\/strong>/gi, '**$1**');
+  text = text.replace(/<i>(.+?)<\/i>/gi, '*$1*');
+  text = text.replace(/<em>(.+?)<\/em>/gi, '*$1*');
+  text = text.replace(/<code>(.+?)<\/code>/gi, '`$1`');
+  text = text.replace(/<pre><code>([\s\S]+?)<\/code><\/pre>/gi, '```\n$1\n```');
+
+  text = text.replace(/<a href="([^"]+)">(.+?)<\/a>/gi, (_, url, label) => {
+    const normalized = String(url || '').trim().toLowerCase();
+    const safe = /^(https?:\/\/|mailto:|\/)|^[^:]*$/.test(normalized);
+    if (!safe) return label;
+    return `[${label}](${url})`;
+  });
+
+  let prev = '';
+  while (prev !== text) {
+    prev = text;
+    text = text.replace(/<[^>]+>/g, '');
+  }
+
+  return text;
+}
+
+export function truncateLarkText(text, maxLength = LARK_TEXT_LIMIT) {
+  const normalized = String(text || '');
+  if (normalized.length <= maxLength) {
+    return normalized;
+  }
+  return `${normalized.slice(0, maxLength - 3)}...`;
+}