@satorijs/adapter-lark 3.6.0 → 3.6.2

package/lib/http.d.ts

@@ -1,13 +1,13 @@
 import { Adapter, Context, Schema } from '@satorijs/core';
-import { FeishuBot } from './bot';
+import { LarkBot } from './bot';
 import { EventPayload } from './types';
-export declare class HttpServer<C extends Context = Context> extends Adapter<C, FeishuBot<C>> {
+export declare class HttpServer<C extends Context = Context> extends Adapter<C, LarkBot<C>> {
     static inject: string[];
     private logger;
     private ciphers;
-    constructor(ctx: C, bot: FeishuBot<C>);
-    fork(ctx: C, bot: FeishuBot<C>): Promise<void>;
-    connect(bot: FeishuBot): Promise<void>;
+    constructor(ctx: C, bot: LarkBot<C>);
+    fork(ctx: C, bot: LarkBot<C>): Promise<void>;
+    connect(bot: LarkBot): Promise<void>;
     dispatchSession(body: EventPayload): Promise<void>;
     private _tryDecryptBody;
     private _refreshCipher;

package/lib/index.cjs

@@ -116,6 +116,15 @@ async function adaptSession(bot, body) {
       adaptSender(body.event.sender, session);
       await adaptMessage(bot, body.event, session);
       break;
+    case "application.bot.menu_v6":
+      if (body.event.event_key.startsWith("command:")) {
+        session.type = "interaction/command";
+        session.content = body.event.event_key.slice(8);
+        session.channelId = body.event.operator.operator_id.open_id;
+        session.userId = body.event.operator.operator_id.open_id;
+        session.isDirect = true;
+      }
+      break;
     case "card.action.trigger":
       if (body.event.action.value?._satori_type === "command") {
         session.type = "interaction/command";
@@ -138,11 +147,16 @@ async function adaptSession(bot, body) {
         for (const [key, value] of Object.entries(options)) {
           content += ` --${key} ${value}`;
         }
+        if (body.event.action.input_value) {
+          content += ` ${body.event.action.input_value}`;
+        }
         session.content = content;
         session.messageId = body.event.context.open_message_id;
         session.channelId = body.event.context.open_chat_id;
         session.guildId = body.event.context.open_chat_id;
         session.userId = body.event.operator.open_id;
+        const { data } = await bot.internal.getImChat(session.channelId);
+        session.isDirect = data.chat_mode === "p2p";
       }
       break;
   }
@@ -314,6 +328,7 @@ var HttpServer = class extends import_core2.Adapter {
       }
       bot.logger.debug("received decryped event: %o", body);
       this.dispatchSession(body);
+      ctx.body = {};
       return ctx.status = 200;
     });
     bot.ctx.server.get(path + "/assets/:type/:message_id/:key", async (ctx) => {
@@ -385,18 +400,22 @@ var LarkMessageEncoder = class extends import_core3.MessageEncoder {
     __name(this, "LarkMessageEncoder");
   }
   quote;
-  content = "";
-  addition;
-  // TODO: currently not used, would be supported in the future
-  richText;
+  textContent = "";
+  richContent = [];
+  card;
+  noteElements;
+  actionElements = [];
   async post(data) {
     try {
       let resp;
-      if (this.quote) {
-        resp = await this.bot.internal.replyImMessage(this.quote, data);
+      if (this.quote?.id) {
+        resp = await this.bot.internal.replyImMessage(this.quote.id, {
+          ...data,
+          reply_in_thread: this.quote.replyInThread
+        });
       } else {
         data.receive_id = this.channelId;
-        resp = await this.bot.internal?.createImMessage(data, {
+        resp = await this.bot.internal.createImMessage(data, {
           receive_id_type: extractIdType(this.channelId)
         });
       }
@@ -418,121 +437,264 @@ var LarkMessageEncoder = class extends import_core3.MessageEncoder {
       this.errors.push(e);
     }
   }
-  async flush() {
-    if (this.content === "" && !this.addition && !this.richText) return;
-    let message;
-    if (this.addition) {
-      message = {
-        ...message,
-        ...this.addition.file
-      };
+  flushText(button = false) {
+    if ((this.textContent || !button) && this.actionElements.length) {
+      this.card.elements.push({ tag: "action", actions: this.actionElements, layout: "flow" });
+      this.actionElements = [];
     }
-    if (this.richText) {
-      message = { zh_cn: this.richText };
+    if (this.textContent) {
+      this.richContent.push([{ tag: "md", text: this.textContent }]);
+      if (this.noteElements) {
+        this.noteElements.push({ tag: "plain_text", content: this.textContent });
+      } else if (this.card) {
+        this.card.elements.push({ tag: "markdown", content: this.textContent });
+      }
+      this.textContent = "";
     }
-    if (this.content) {
-      message = { text: this.content };
+  }
+  async flush() {
+    this.flushText();
+    if (!this.card && !this.richContent.length) return;
+    if (this.card) {
+      this.bot.logger.debug("card", JSON.stringify(this.card.elements));
+      await this.post({
+        msg_type: "interactive",
+        content: JSON.stringify({
+          elements: this.card.elements
+        })
+      });
+    } else {
+      await this.post({
+        msg_type: "post",
+        content: JSON.stringify({
+          zh_cn: {
+            content: this.richContent
+          }
+        })
+      });
     }
-    await this.post({
-      msg_type: this.richText ? "post" : this.addition ? this.addition.type : "text",
-      content: JSON.stringify(message)
-    });
     this.quote = void 0;
-    this.content = "";
-    this.addition = void 0;
-    this.richText = void 0;
+    this.textContent = "";
+    this.richContent = [];
+    this.card = void 0;
   }
-  async sendFile(type, url) {
+  async createImage(url) {
+    const { filename, type, data } = await this.bot.assetsQuester.file(url);
     const payload = new FormData();
-    const assetKey = type === "img" || type === "image" ? "image" : "file";
-    const { filename, mime, data } = await this.bot.assetsQuester.file(url);
-    payload.append(assetKey, new Blob([data], { type: mime }), filename);
-    if (type === "img" || type === "image") {
-      payload.append("image_type", "message");
-      const { data: data2 } = await this.bot.internal.createImImage(payload);
-      return {
-        type: "image",
-        file: {
-          image_key: data2.image_key
-        }
-      };
+    payload.append("image", new Blob([data], { type }), filename);
+    payload.append("image_type", "message");
+    const { data: { image_key } } = await this.bot.internal.createImImage(payload);
+    return image_key;
+  }
+  async sendFile(_type, attrs) {
+    const url = attrs.src || attrs.url;
+    const payload = new FormData();
+    const { filename, type, data } = await this.bot.assetsQuester.file(url);
+    payload.append("file", new Blob([data], { type }), filename);
+    payload.append("file_name", filename);
+    if (attrs.duration) {
+      payload.append("duration", attrs.duration);
+    }
+    if (_type === "audio") {
+      payload.append("file_type", "opus");
+    } else if (_type === "video") {
+      payload.append("file_type", "mp4");
     } else {
-      let msgType = "file";
-      if (type === "audio") {
-        payload.append("file_type", "opus");
-        msgType = "audio";
-      } else if (type === "video") {
-        payload.append("file_type", "mp4");
-        msgType = "media";
+      const ext = filename.split(".").pop();
+      if (["doc", "xls", "ppt", "pdf"].includes(ext)) {
+        payload.append("file_type", ext);
       } else {
-        const ext = filename.split(".").pop();
-        if (["xls", "ppt", "pdf"].includes(ext)) {
-          payload.append("file_type", ext);
-        } else {
-          payload.append("file_type", "stream");
-        }
+        payload.append("file_type", "stream");
       }
-      payload.append("file_name", filename);
-      const { data: data2 } = await this.bot.internal.createImFile(payload);
-      return {
-        type: msgType,
-        file: {
-          file_key: data2.file_key
+    }
+    const { data: { file_key } } = await this.bot.internal.createImFile(payload);
+    await this.post({
+      msg_type: _type === "video" ? "media" : _type,
+      content: JSON.stringify({ file_key })
+    });
+  }
+  createBehavior(attrs) {
+    const behaviors = [];
+    if (attrs.type === "link") {
+      behaviors.push({
+        type: "open_url",
+        default_url: attrs.href
+      });
+    } else if (attrs.type === "input") {
+      behaviors.push({
+        type: "callback",
+        value: {
+          _satori_type: "command",
+          content: attrs.text
         }
-      };
+      });
+    } else if (attrs.type === "action") {
     }
+    return behaviors.length ? behaviors : void 0;
   }
   async visit(element) {
     const { type, attrs, children } = element;
-    switch (type) {
-      case "text":
-        this.content += attrs.content;
-        break;
-      case "at": {
-        if (attrs.type === "all") {
-          this.content += `<at user_id="all">${attrs.name ?? "所有人"}</at>`;
-        } else {
-          this.content += `<at user_id="${attrs.id}">${attrs.name}</at>`;
-        }
-        break;
+    if (type === "text") {
+      this.textContent += attrs.content;
+    } else if (type === "at") {
+      if (attrs.type === "all") {
+        this.textContent += `<at user_id="all">${attrs.name ?? "所有人"}</at>`;
+      } else {
+        this.textContent += `<at user_id="${attrs.id}">${attrs.name}</at>`;
       }
-      case "a":
-        await this.render(children);
-        if (attrs.href) this.content += ` (${attrs.href})`;
-        break;
-      case "p":
-        if (!this.content.endsWith("\n")) this.content += "\n";
-        await this.render(children);
-        if (!this.content.endsWith("\n")) this.content += "\n";
-        break;
-      case "br":
-        this.content += "\n";
-        break;
-      case "sharp":
-        break;
-      case "quote":
+    } else if (type === "a") {
+      await this.render(children);
+      if (attrs.href) this.textContent += ` (${attrs.href})`;
+    } else if (type === "p") {
+      if (!this.textContent.endsWith("\n")) this.textContent += "\n";
+      await this.render(children);
+      if (!this.textContent.endsWith("\n")) this.textContent += "\n";
+    } else if (type === "br") {
+      this.textContent += "\n";
+    } else if (type === "sharp") {
+    } else if (type === "quote") {
+      await this.flush();
+      this.quote = attrs;
+    } else if (type === "img" || type === "image") {
+      const image_key = await this.createImage(attrs.src || attrs.url);
+      this.textContent += `![${attrs.alt ?? "图片"}](${image_key})`;
+      this.flushText();
+      this.richContent.push([{ tag: "img", image_key }]);
+    } else if (["video", "audio", "file"].includes(type)) {
+      await this.flush();
+      await this.sendFile(type, attrs);
+    } else if (type === "figure" || type === "message") {
+      await this.flush();
+      await this.render(children, true);
+    } else if (type === "hr") {
+      this.flushText();
+      this.richContent.push([{ tag: "hr" }]);
+      this.card?.elements.push({ tag: "hr" });
+    } else if (type === "form") {
+      this.flushText();
+      const length = this.card?.elements.length;
+      await this.render(children);
+      if (this.card?.elements.length > length) {
+        const elements = this.card?.elements.slice(length);
+        this.card.elements.push({
+          tag: "form",
+          name: attrs.name || "Form",
+          elements
+        });
+      }
+    } else if (type === "input") {
+      this.flushText();
+      this.card?.elements.push({
+        tag: "action",
+        actions: [{
+          tag: "input",
+          name: attrs.name,
+          width: attrs.width,
+          label: attrs.label && {
+            tag: "plain_text",
+            content: attrs.label
+          },
+          placeholder: attrs.placeholder && {
+            tag: "plain_text",
+            content: attrs.placeholder
+          },
+          behaviors: this.createBehavior(attrs)
+        }]
+      });
+    } else if (type === "button") {
+      this.card ??= { elements: [] };
+      this.flushText(true);
+      await this.render(children);
+      this.actionElements.push({
+        tag: "button",
+        text: {
+          tag: "plain_text",
+          content: this.textContent
+        },
+        disabled: attrs.disabled,
+        behaviors: this.createBehavior(attrs)
+      });
+      this.textContent = "";
+    } else if (type === "button-group") {
+      this.flushText();
+      await this.render(children);
+      this.flushText();
+    } else if (type.startsWith("lark:") || type.startsWith("feishu:")) {
+      const tag = type.slice(type.split(":", 1)[0].length + 1);
+      if (tag === "share-chat") {
         await this.flush();
-        this.quote = attrs.id;
-        break;
-      case "img":
-      case "image":
-      case "video":
-      case "audio":
-      case "file":
-        if (attrs.src || attrs.url) {
-          await this.flush();
-          this.addition = await this.sendFile(type, attrs.src || attrs.url);
-          await this.flush();
-        }
-        break;
-      case "figure":
-      // FIXME: treat as message element for now
-      case "message":
+        await this.post({
+          msg_type: "share_chat",
+          content: JSON.stringify({ chat_id: attrs.chatId })
+        });
+      } else if (tag === "share-user") {
+        await this.flush();
+        await this.post({
+          msg_type: "share_user",
+          content: JSON.stringify({ user_id: attrs.userId })
+        });
+      } else if (tag === "system") {
+        await this.flush();
+        await this.render(children);
+        await this.post({
+          msg_type: "system",
+          content: JSON.stringify({
+            type: "divider",
+            params: { divider_text: { text: this.textContent } },
+            options: { need_rollup: attrs.needRollup }
+          })
+        });
+        this.textContent = "";
+      } else if (tag === "card") {
         await this.flush();
+        this.card = {
+          elements: [],
+          header: attrs.title && {
+            template: attrs.color,
+            ud_icon: attrs.icon && {
+              tag: "standard_icon",
+              token: attrs.icon
+            },
+            title: {
+              tag: "plain_text",
+              content: attrs.title
+            },
+            subtitle: attrs.subtitle && {
+              tag: "plain_text",
+              content: attrs.subtitle
+            }
+          }
+        };
         await this.render(children, true);
-        break;
-      default:
+      } else if (tag === "div") {
+        this.flushText();
+        await this.render(children);
+        this.card?.elements.push({
+          tag: "markdown",
+          text_align: attrs.align,
+          text_size: attrs.size,
+          content: this.textContent
+        });
+        this.textContent = "";
+      } else if (tag === "note") {
+        this.flushText();
+        this.noteElements = [];
         await this.render(children);
+        this.flushText();
+        this.card?.elements.push({
+          tag: "note",
+          elements: this.noteElements
+        });
+        this.noteElements = void 0;
+      } else if (tag === "icon") {
+        this.flushText();
+        this.noteElements?.push({
+          tag: "standard_icon",
+          token: attrs.token
+        });
+      }
+    } else {
+      await this.render(children);
     }
   }
 };