@satorijs/adapter-dingtalk 2.0.3 → 2.0.5

package/src/bot.ts

@@ -0,0 +1,129 @@
+import { Bot, Context, Quester, Schema } from '@satorijs/satori'
+import { HttpServer } from './http'
+import { DingtalkMessageEncoder } from './message'
+import { WsClient } from './ws'
+import { Internal } from './internal'
+
+// https://open.dingtalk.com/document/orgapp/enterprise-created-chatbot
+export class DingtalkBot<C extends Context = Context> extends Bot<C, DingtalkBot.Config> {
+  static MessageEncoder = DingtalkMessageEncoder
+
+  public oldHttp: Quester
+  public http: Quester
+  public internal: Internal
+  private refreshTokenTimer: NodeJS.Timeout
+
+  constructor(ctx: C, config: DingtalkBot.Config) {
+    super(ctx, config, 'dingtalk')
+    this.selfId = config.appkey
+    this.http = ctx.http.extend(config.api)
+    this.oldHttp = ctx.http.extend(config.oldApi)
+    this.internal = new Internal(this)
+
+    if (config.protocol === 'http') {
+      ctx.plugin(HttpServer, this)
+    } else if (config.protocol === 'ws') {
+      ctx.plugin(WsClient, this)
+    }
+  }
+
+  async getLogin() {
+    try {
+      const { appList } = await this.internal.listAllInnerApps()
+      const self = appList.find(v => v.agentId === this.config.agentId)
+      if (self) {
+        this.user.name = self.name
+        this.user.avatar = self.icon
+        return this.toJSON()
+      }
+    } catch (e) {
+      this.logger.warn(e)
+    }
+
+    const data = await this.internal.oapiMicroappList()
+    if (!data.appList) {
+      this.logger.error('getLogin failed: %o', data)
+      return this.toJSON()
+    }
+    const self = data.appList.find(v => v.agentId === this.config.agentId)
+    if (self) {
+      this.user.name = self.name
+      this.user.avatar = self.appIcon
+    }
+    return this.toJSON()
+  }
+
+  stop() {
+    clearTimeout(this.refreshTokenTimer)
+    return super.stop()
+  }
+
+  public token: string
+
+  async refreshToken() {
+    const data = await this.internal.getAccessToken({
+      appKey: this.config.appkey,
+      appSecret: this.config.secret,
+    })
+    this.logger.debug('gettoken result: %o', data)
+    this.token = data.accessToken
+    // https://open.dingtalk.com/document/orgapp/authorization-overview
+    this.http = this.http.extend({
+      headers: {
+        'x-acs-dingtalk-access-token': data.accessToken,
+      },
+    }).extend(this.config.api)
+    this.refreshTokenTimer = setTimeout(this.refreshToken.bind(this), (data.expireIn - 10) * 1000)
+  }
+
+  // https://open.dingtalk.com/document/orgapp/download-the-file-content-of-the-robot-receiving-message
+  async downloadFile(downloadCode: string): Promise<string> {
+    const { downloadUrl } = await this.internal.robotMessageFileDownload({
+      downloadCode,
+      robotCode: this.selfId,
+    })
+    return downloadUrl
+  }
+
+  async deleteMessage(channelId: string, messageId: string): Promise<void> {
+    if (channelId.startsWith('cid')) {
+      await this.internal.orgGroupRecall({
+        robotCode: this.selfId,
+        processQueryKeys: [messageId],
+        openConversationId: channelId,
+      })
+    } else {
+      await this.internal.batchRecallOTO({
+        robotCode: this.selfId,
+        processQueryKeys: [messageId],
+      })
+    }
+  }
+}
+
+export namespace DingtalkBot {
+  export interface Config extends WsClient.Config {
+    secret: string
+    protocol: string
+    appkey: string
+    agentId?: number
+    api: Quester.Config
+    oldApi: Quester.Config
+  }
+
+  export const Config: Schema<Config> = Schema.intersect([
+    Schema.object({
+      protocol: process.env.KOISHI_ENV === 'browser'
+        ? Schema.const('ws').default('ws')
+        : Schema.union(['http', 'ws']).description('选择要使用的协议。').required(),
+    }),
+    Schema.object({
+      secret: Schema.string().required().description('机器人密钥。'),
+      agentId: Schema.number().description('AgentId'),
+      appkey: Schema.string().required(),
+      api: Quester.createConfig('https://api.dingtalk.com/v1.0/'),
+      oldApi: Quester.createConfig('https://oapi.dingtalk.com/'),
+    }),
+    WsClient.Config,
+  ])
+}

package/src/http.ts

@@ -0,0 +1,44 @@
+import { Adapter, Context, Logger } from '@satorijs/satori'
+import {} from '@satorijs/router'
+import { DingtalkBot } from './bot'
+import crypto from 'node:crypto'
+import { Message } from './types'
+import { decodeMessage } from './utils'
+
+export class HttpServer<C extends Context = Context> extends Adapter<C, DingtalkBot<C>> {
+  static inject = ['router']
+
+  private logger: Logger
+
+  constructor(ctx: C, bot: DingtalkBot<C>) {
+    super(ctx)
+    this.logger = ctx.logger('dingtalk')
+  }
+
+  async connect(bot: DingtalkBot<C>) {
+    await bot.refreshToken()
+    await bot.getLogin()
+
+    // https://open.dingtalk.com/document/orgapp/receive-message
+    bot.ctx.router.post('/dingtalk', async (ctx) => {
+      const timestamp = ctx.get('timestamp')
+      const sign = ctx.get('sign')
+
+      if (!timestamp || !sign) return ctx.status = 403
+      const timeDiff = Math.abs(Date.now() - Number(timestamp))
+      if (timeDiff > 3600000) return ctx.status = 401
+      const signContent = timestamp + '\n' + bot.config.secret
+      const computedSign = crypto
+        .createHmac('sha256', bot.config.secret)
+        .update(signContent)
+        .digest('base64')
+
+      if (computedSign !== sign) return ctx.status = 403
+      const body = ctx.request.body as Message
+      this.logger.debug(body)
+      const session = await decodeMessage(bot, body)
+      this.logger.debug(session)
+      if (session) bot.dispatch(session)
+    })
+  }
+}

package/src/index.ts

@@ -0,0 +1,9 @@
+import { DingtalkBot } from './bot'
+
+export * from './bot'
+export * from './utils'
+export * from './types'
+export * from './http'
+export * from './message'
+
+export default DingtalkBot

package/src/internal.ts

@@ -0,0 +1,47 @@
+import { Dict, Quester } from '@satorijs/satori'
+import { DingtalkBot } from './bot'
+
+export class Internal {
+  constructor(private bot: DingtalkBot) { }
+
+  static define(routes: Dict<Partial<Record<Quester.Method, Record<string, boolean>>>>) {
+    for (const path in routes) {
+      for (const key in routes[path]) {
+        const method = key as Quester.Method
+        for (const name of Object.keys(routes[path][method])) {
+          const isOldApi = routes[path][method][name]
+          Internal.prototype[name] = async function (this: Internal, ...args: any[]) {
+            const raw = args.join(', ')
+            const url = path.replace(/\{([^}]+)\}/g, () => {
+              if (!args.length) throw new Error(`too few arguments for ${path}, received ${raw}`)
+              return args.shift()
+            })
+            const config: Quester.AxiosRequestConfig = {}
+            if (args.length === 1) {
+              if (method === 'GET' || method === 'DELETE') {
+                config.params = args[0]
+              } else {
+                config.data = args[0]
+              }
+            } else if (args.length === 2 && method !== 'GET' && method !== 'DELETE') {
+              config.data = args[0]
+              config.params = args[1]
+            } else if (args.length > 1) {
+              throw new Error(`too many arguments for ${path}, received ${raw}`)
+            }
+            const quester = isOldApi ? this.bot.oldHttp : this.bot.http
+            if (isOldApi) {
+              config.params = { ...config.params, access_token: this.bot.token }
+            }
+            try {
+              return await quester(method, url, config)
+            } catch (error) {
+              if (!Quester.isAxiosError(error) || !error.response) throw error
+              throw new Error(`[${error.response.status}] ${JSON.stringify(error.response.data)}`)
+            }
+          }
+        }
+      }
+    }
+  }
+}

package/src/message.ts

@@ -0,0 +1,141 @@
+import { Context, Dict, h, MessageEncoder } from '@satorijs/satori'
+import { DingtalkBot } from './bot'
+import FormData from 'form-data'
+import { SendMessageData } from './types'
+
+export const escape = (val: string) =>
+  val
+    .replace(/(?<!\u200b)[\*_~`]/g, '\u200B$&')
+    .replace(/([\\`*_{}[\]\-(#!>])/g, '\\$&')
+    .replace(/([\-\*]|\d\.) /g, '\u200B$&')
+    .replace(/^(\s{4})/gm, '\u200B&nbsp;&nbsp;&nbsp;&nbsp;')
+
+export const unescape = (val: string) =>
+  val
+    .replace(/\u200b([\*_~`])/g, '$1')
+
+export class DingtalkMessageEncoder<C extends Context = Context> extends MessageEncoder<C, DingtalkBot<C>> {
+  buffer = ''
+
+  /**
+   * Markdown: https://open.dingtalk.com/document/isvapp/robot-message-types-and-data-format
+   */
+  hasRichContent = true
+
+  async flush(): Promise<void> {
+    if (this.buffer.length && !this.hasRichContent) {
+      await this.sendMessage('sampleText', {
+        content: this.buffer,
+      })
+    } else if (this.buffer.length && this.hasRichContent) {
+      await this.sendMessage('sampleMarkdown', {
+        text: this.buffer.replace(/\n/g, '\n\n'),
+      })
+    }
+  }
+
+  // https://open.dingtalk.com/document/orgapp/the-robot-sends-a-group-message
+  async sendMessage<T extends keyof SendMessageData>(msgType: T, msgParam: SendMessageData[T]) {
+    const { processQueryKey } = this.session.isDirect ? await this.bot.internal.batchSendOTO({
+      msgKey: msgType,
+      msgParam: JSON.stringify(msgParam),
+      robotCode: this.bot.config.appkey,
+      userIds: [this.session.channelId],
+    }) : await this.bot.internal.orgGroupSend({
+      // https://open.dingtalk.com/document/orgapp/types-of-messages-sent-by-robots
+      msgKey: msgType,
+      msgParam: JSON.stringify(msgParam),
+      robotCode: this.bot.config.appkey,
+      openConversationId: this.channelId,
+    })
+    const session = this.bot.session()
+    session.messageId = processQueryKey
+    session.channelId = this.session.channelId
+    session.guildId = this.session.guildId
+    session.app.emit(session, 'send', session)
+    this.results.push({
+      id: processQueryKey,
+    })
+  }
+
+  // https://open.dingtalk.com/document/orgapp/upload-media-files?spm=ding_open_doc.document.0.0.3b166172ERBuHw
+  async uploadMedia(attrs: Dict) {
+    const { data, mime } = await this.bot.ctx.http.file(attrs.url, attrs)
+    const form = new FormData()
+    // https://github.com/form-data/form-data/issues/468
+    const value = process.env.KOISHI_ENV === 'browser'
+      ? new Blob([data], { type: mime })
+      : Buffer.from(data)
+    let type: string
+    if (mime.startsWith('image/') || mime.startsWith('video/')) {
+      type = mime.split('/')[0]
+    } else if (mime.startsWith('audio/')) {
+      type = 'voice'
+    } else {
+      type = 'file'
+    }
+    form.append('type', type)
+    form.append('media', value)
+    const { media_id } = await this.bot.oldHttp.post('/media/upload', form, {
+      headers: form.getHeaders(),
+    })
+    return media_id
+  }
+
+  private listType: 'ol' | 'ul' = null
+
+  async visit(element: h) {
+    const { type, attrs, children } = element
+    if (type === 'text') {
+      this.buffer += escape(attrs.content)
+    } else if (type === 'image' && attrs.url) {
+      // await this.flush()
+      // await this.sendMessage('sampleImageMsg', {
+      //   photoURL: attrs.url
+      // })
+      this.buffer += `![${attrs.alt}](${attrs.url})`
+    } else if (type === 'message') {
+      await this.flush()
+      await this.render(children)
+    } else if (type === 'at') {
+      this.buffer += `@${attrs.id}`
+    } else if (type === 'br') {
+      this.buffer += '\n'
+    } else if (type === 'p') {
+      if (!this.buffer.endsWith('\n')) this.buffer += '\n'
+      await this.render(children)
+      if (!this.buffer.endsWith('\n')) this.buffer += '\n'
+      this.buffer += '\n'
+    } else if (type === 'b' || type === 'strong') {
+      this.buffer += ` **`
+      await this.render(children)
+      this.buffer += `** `
+    } else if (type === 'i' || type === 'em') {
+      this.buffer += ` *`
+      await this.render(children)
+      this.buffer += `* `
+    } else if (type === 'a' && attrs.href) {
+      this.buffer += `[`
+      await this.render(children)
+      this.buffer += `](${encodeURI(attrs.href)})`
+    } else if (type === 'ul' || type === 'ol') {
+      this.listType = type
+      await this.render(children)
+      this.listType = null
+    } else if (type === 'li') {
+      if (!this.buffer.endsWith('\n')) this.buffer += '\n'
+      if (this.listType === 'ol') {
+        this.buffer += `1. `
+      } else if (this.listType === 'ul') {
+        this.buffer += '- '
+      }
+      this.render(children)
+      this.buffer += '\n'
+    } else if (type === 'blockquote') {
+      if (!this.buffer.endsWith('\n')) this.buffer += '\n'
+      this.buffer += '> '
+      await this.render(children)
+      this.buffer += '\n\n'
+    }
+  }
+}

package/src/types/index.ts

@@ -0,0 +1,140 @@
+export type AtUser = {
+  dingtalkId: string
+  staffId?: string // 企业内部群有的发送者在企业内的userid
+}
+
+export type DingtalkRequestBase = {
+  msgtype: string // 消息类型
+  msgId: string // 加密的消息ID
+  createAt: string // 消息的时间戳，单位毫秒
+  conversationType: string // 1：单聊 2：群聊
+  conversationId: string // 会话ID
+  conversationTitle?: string // 群聊时才有的会话标题
+  senderId: string // 加密的发送者ID
+  senderNick: string // 发送者昵称
+  senderCorpId?: string // 企业内部群有的发送者当前群的企业corpId
+  sessionWebhook: string // 当前会话的Webhook地址
+  sessionWebhookExpiredTime: number // 当前会话的Webhook地址过期时间
+  isAdmin?: boolean // 是否为管理员
+  chatbotCorpId?: string // 加密的机器人所在的企业corpId
+  isInAtList?: boolean // 是否在@列表中
+  senderStaffId?: string // 企业内部群中@该机器人的成员userid
+  chatbotUserId: string // 加密的机器人ID
+  atUsers?: AtUser[] // 被@人的信息
+  robotCode: string
+}
+
+export type Message = TextMessage | RichTextMessage | PictureMessage | FileMessage
+
+export interface TextMessage extends DingtalkRequestBase {
+  msgtype: 'text'
+  text: {
+    content: string
+  }
+}
+
+export interface FileMessage extends DingtalkRequestBase {
+  msgtype: 'file'
+  content: {
+    spaceId: string
+    fileName: string
+    downloadCode: string
+    fileId: string
+  }
+}
+
+export interface PictureMessage extends DingtalkRequestBase {
+  msgtype: 'picture'
+  content: {
+    downloadCode: string
+  }
+}
+
+export interface RichTextMessage extends DingtalkRequestBase {
+  msgtype: 'richText'
+  content: {
+    richText: ({
+      text: string
+    } & {
+      pictureDownloadCode: string
+      downloadCode: string
+      type: 'picture'
+    })[]
+  }
+}
+
+// https://open.dingtalk.com/document/orgapp/types-of-messages-sent-by-robots
+export interface SendMessageData {
+  sampleText: { content: string }
+  sampleMarkdown: {
+    title?: string
+    text: string
+  }
+  sampleImageMsg: {
+    photoURL: string
+  }
+  sampleLink: {
+    text: string
+    title: string
+    picUrl: string
+    messageUrl: string
+  }
+  sampleAudio: {
+    mediaId: string
+    duration: string
+  }
+  sampleFile: {
+    mediaId: string
+    fileName: string
+    fileType: string
+  }
+  sampleVideo: {
+    duration: string
+    videoMediaId: string
+    videoType: string
+    picMediaId: string
+  }
+}
+
+export * from '../api/oauth2'
+export * from '../api/oapi'
+export * from '../api/contact'
+export * from '../api/swform'
+export * from '../api/hrm'
+export * from '../api/todo'
+export * from '../api/attendance'
+export * from '../api/calendar'
+export * from '../api/blackboard'
+export * from '../api/microApp'
+export * from '../api/im'
+export * from '../api/connector'
+export * from '../api/exclusive'
+export * from '../api/alitrip'
+export * from '../api/project'
+export * from '../api/edu'
+export * from '../api/crm'
+export * from '../api/yida'
+export * from '../api/drive'
+export * from '../api/workbench'
+export * from '../api/robot'
+export * from '../api/conference'
+export * from '../api/serviceGroup'
+export * from '../api/customerService'
+export * from '../api/esign'
+export * from '../api/jzcrm'
+export * from '../api/badge'
+export * from '../api/datacenter'
+export * from '../api/resident'
+export * from '../api/wiki'
+export * from '../api/storage'
+export * from '../api/doc'
+export * from '../api/diot'
+export * from '../api/h3yun'
+export * from '../api/link'
+export * from '../api/pedia'
+export * from '../api/devicemng'
+export * from '../api/convFile'
+export * from '../api/industry'
+export * from '../api/live'
+export * from '../api/card'
+export * from '../api/rooms'

package/src/utils.ts

@@ -0,0 +1,53 @@
+import { Context, h } from '@satorijs/satori'
+import { Message } from './types'
+import { DingtalkBot } from './bot'
+
+export async function decodeMessage<C extends Context>(bot: DingtalkBot<C>, body: Message) {
+  const session = bot.session()
+  session.type = 'message'
+  session.messageId = body.msgId
+  session.guildId = body.chatbotCorpId
+
+  if (body.conversationType === '1') {
+    session.channelId = session.userId
+    session.isDirect = true
+  } else {
+    const atUsers = body.atUsers.filter(v => v.dingtalkId !== body.chatbotUserId).map(v => h.at(v.staffId))
+    session.elements = [h.at(body.robotCode), ...atUsers]
+    session.channelId = body.conversationId
+    session.isDirect = false
+  }
+  if (body.conversationTitle) {
+    session.event.channel.name = body.conversationTitle
+  }
+
+  session.event.user = {
+    id: body.senderStaffId,
+    name: body.senderNick,
+  }
+  session.event.member = {
+    roles: body.isAdmin ? ['admin'] : [],
+  }
+  session.timestamp = +body.createAt
+  if (body.msgtype === 'text') {
+    session.elements = [h.text(body.text.content)]
+  } else if (body.msgtype === 'richText') {
+    const elements: h[] = []
+    for (const item of body.content.richText) {
+      if (item.text) elements.push(h.text(item.text))
+      if (item.downloadCode) {
+        const url = await bot.downloadFile(item.downloadCode)
+        elements.push(h.image(url))
+      }
+    }
+    session.elements = elements
+  } else if (body.msgtype === 'picture') {
+    session.elements = [h.image(await bot.downloadFile(body.content.downloadCode))]
+  } else if (body.msgtype === 'file') {
+    session.elements = [h.file(await bot.downloadFile(body.content.downloadCode))]
+  } else {
+    return
+  }
+  session.content = session.elements.join('')
+  return session
+}

package/src/ws.ts

@@ -0,0 +1,55 @@
+import { Adapter, Context, Schema } from '@satorijs/satori'
+import { DingtalkBot } from './bot'
+import { decodeMessage } from './utils'
+
+export class WsClient<C extends Context = Context> extends Adapter.WsClient<C, DingtalkBot<C>> {
+  async prepare() {
+    await this.bot.refreshToken()
+    await this.bot.getLogin()
+    const { endpoint, ticket } = await this.bot.http.post<{
+      endpoint: string
+      ticket: string
+    }>('/gateway/connections/open', {
+      clientId: this.bot.config.appkey,
+      clientSecret: this.bot.config.secret,
+      subscriptions: [
+        {
+          type: 'CALLBACK',
+          topic: '/v1.0/im/bot/messages/get',
+        },
+      ],
+    })
+    return this.bot.http.ws(`${endpoint}?ticket=${ticket}`)
+  }
+
+  accept() {
+    this.bot.online()
+    this.socket.addEventListener('message', async ({ data }) => {
+      const parsed = JSON.parse(data.toString())
+      this.bot.logger.debug(parsed)
+      if (parsed.type === 'SYSTEM') {
+        if (parsed.headers.topic === 'ping') {
+          this.socket.send(JSON.stringify({
+            code: 200,
+            headers: parsed.headers,
+            message: 'OK',
+            data: parsed.data,
+          }))
+        }
+      } else if (parsed.type === 'CALLBACK') {
+        this.bot.logger.debug(JSON.parse(parsed.data))
+        const session = await decodeMessage(this.bot, JSON.parse(parsed.data))
+        if (session) this.bot.dispatch(session)
+        this.bot.logger.debug(session)
+      }
+    })
+  }
+}
+
+export namespace WsClient {
+  export interface Config extends Adapter.WsClientConfig {}
+
+  export const Config: Schema<Config> = Schema.intersect([
+    Adapter.WsClientConfig,
+  ] as const)
+}