@satorijs/adapter-lark 2.0.0

package/lib/bot.d.ts

@@ -0,0 +1,29 @@
+/// <reference types="node" />
+import { Bot, Context, Quester, Schema, SendOptions } from '@satorijs/satori';
+import { HttpServer } from './http';
+import { Internal } from './types';
+export declare class LarkBot extends Bot<LarkBot.Config> {
+    _token?: string;
+    _refresher?: NodeJS.Timeout;
+    http: Quester;
+    assetsQuester: Quester;
+    internal: Internal;
+    constructor(ctx: Context, config: LarkBot.Config);
+    initialize(): Promise<void>;
+    private refreshToken;
+    get token(): string;
+    set token(v: string);
+    sendMessage(channelId: string, content: string, guildId?: string, options?: SendOptions): Promise<string[]>;
+    sendPrivateMessage(userId: string, content: string, options?: SendOptions): Promise<string[]>;
+    deleteMessage(channelId: string, messageId: string): Promise<void>;
+}
+export declare namespace LarkBot {
+    interface Config extends Bot.Config, HttpServer.Config, Quester.Config {
+        appId: string;
+        appSecret: string;
+        encryptKey?: string;
+        verificationToken?: string;
+    }
+    const Config: Schema<Config>;
+}
+export { LarkBot as FeishuBot };

package/lib/http.d.ts

@@ -0,0 +1,21 @@
+import { Adapter, Context, Schema } from '@satorijs/satori';
+import { FeishuBot } from './bot';
+import { AllEvents } from './types';
+export declare class HttpServer extends Adapter.Server<FeishuBot> {
+    private ciphers;
+    fork(ctx: Context, bot: FeishuBot): Promise<void>;
+    start(bot: FeishuBot): Promise<void>;
+    stop(): Promise<void>;
+    dispatchSession(body: AllEvents): void;
+    private _tryDecryptBody;
+    private _refreshCipher;
+}
+export declare namespace HttpServer {
+    interface Config {
+        selfUrl?: string;
+        path?: string;
+        verifyToken?: boolean;
+        verifySignature?: boolean;
+    }
+    const createConfig: (path: string) => Schema<Config>;
+}

package/lib/index.d.ts

@@ -0,0 +1,11 @@
+import { FeishuBot } from './bot';
+import * as Lark from './types';
+export * from './bot';
+export { Lark, Lark as Feishu };
+export default FeishuBot;
+declare module '@satorijs/core' {
+    interface Session {
+        feishu: Lark.Internal;
+        lark: Lark.Internal;
+    }
+}

package/lib/index.js

@@ -0,0 +1,635 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// satori/adapters/lark/src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  Feishu: () => types_exports,
+  FeishuBot: () => LarkBot,
+  Lark: () => types_exports,
+  LarkBot: () => LarkBot,
+  default: () => src_default
+});
+module.exports = __toCommonJS(src_exports);
+
+// satori/adapters/lark/src/bot.ts
+var import_satori5 = require("@satorijs/satori");
+
+// satori/adapters/lark/src/http.ts
+var import_satori2 = require("@satorijs/satori");
+
+// satori/adapters/lark/src/utils.ts
+var import_crypto = __toESM(require("crypto"));
+var import_satori = require("@satorijs/satori");
+function adaptSender(sender, session) {
+  var _a;
+  let userId;
+  if ("sender_id" in sender) {
+    userId = sender.sender_id.open_id;
+  } else {
+    userId = sender.id;
+  }
+  (_a = session.author) != null ? _a : session.author = { userId };
+  session.author.userId = userId;
+  session.userId = userId;
+  return session;
+}
+__name(adaptSender, "adaptSender");
+function adaptMessage(bot, data, session) {
+  var _a, _b;
+  const json = JSON.parse(data.message.content);
+  const assetEndpoint = (0, import_satori.trimSlash)((_a = bot.config.selfUrl) != null ? _a : bot.ctx.root.config.selfUrl) + bot.config.path + "/assets";
+  const content = [];
+  switch (data.message.message_type) {
+    case "text": {
+      const text = json.text;
+      if (!((_b = data.message.mentions) == null ? void 0 : _b.length)) {
+        content.push(text);
+        break;
+      }
+      text.split(" ").forEach((word) => {
+        if (word.startsWith("@")) {
+          const mention = data.message.mentions.find((mention2) => mention2.key === word);
+          content.push(import_satori.h.at(mention.id.open_id, { name: mention.name }));
+        } else {
+          content.push(word);
+        }
+      });
+      break;
+    }
+    case "image":
+      content.push(import_satori.h.image(`${assetEndpoint}/image/${data.message.message_id}/${json.image_key}?self_id=${bot.selfId}`));
+      break;
+    case "audio":
+      content.push(import_satori.h.audio(`${assetEndpoint}/file/${data.message.message_id}/${json.file_key}?self_id=${bot.selfId}`));
+      break;
+    case "media":
+      content.push(import_satori.h.video(`${assetEndpoint}/file/${data.message.message_id}/${json.file_key}?self_id=${bot.selfId}`, json.image_key));
+      break;
+    case "file":
+      content.push(import_satori.h.file(`${assetEndpoint}/file/${data.message.message_id}/${json.file_key}?self_id=${bot.selfId}`));
+      break;
+  }
+  session.timestamp = +data.message.create_time;
+  session.messageId = data.message.message_id;
+  session.channelId = data.message.chat_id;
+  session.content = content.map((c) => c.toString()).join(" ");
+  return session;
+}
+__name(adaptMessage, "adaptMessage");
+function adaptSession(bot, body) {
+  const session = bot.session();
+  session.selfId = bot.selfId;
+  const internal = Object.create(bot.internal);
+  Object.assign(internal, body);
+  (0, import_satori.defineProperty)(session, "feishu", internal);
+  (0, import_satori.defineProperty)(session, "lark", internal);
+  switch (body.type) {
+    case "im.message.receive_v1":
+      session.type = "message";
+      session.subtype = body.event.message.chat_type;
+      adaptSender(body.event.sender, session);
+      adaptMessage(bot, body.event, session);
+      break;
+  }
+  return session;
+}
+__name(adaptSession, "adaptSession");
+function extractIdType(id) {
+  if (id.startsWith("ou"))
+    return "open_id";
+  if (id.startsWith("on"))
+    return "union_id";
+  if (id.startsWith("oc"))
+    return "chat_id";
+  if (id.includes("@"))
+    return "email";
+  return "user_id";
+}
+__name(extractIdType, "extractIdType");
+var Cipher = class {
+  constructor(key) {
+    this.encryptKey = key;
+    const hash = import_crypto.default.createHash("sha256");
+    hash.update(key);
+    this.key = hash.digest();
+  }
+  decrypt(encrypt) {
+    const encryptBuffer = Buffer.from(encrypt, "base64");
+    const decipher = import_crypto.default.createDecipheriv("aes-256-cbc", this.key, encryptBuffer.slice(0, 16));
+    let decrypted = decipher.update(encryptBuffer.slice(16).toString("hex"), "hex", "utf8");
+    decrypted += decipher.final("utf8");
+    return decrypted;
+  }
+  calculateSignature(timestamp, nonce, body) {
+    const content = timestamp + nonce + this.encryptKey + body;
+    const sign = import_crypto.default.createHash("sha256").update(content).digest("hex");
+    return sign;
+  }
+};
+__name(Cipher, "Cipher");
+
+// satori/adapters/lark/src/http.ts
+var logger = new import_satori2.Logger("lark");
+var HttpServer = class extends import_satori2.Adapter.Server {
+  constructor() {
+    super(...arguments);
+    this.ciphers = {};
+  }
+  fork(ctx, bot) {
+    super.fork(ctx, bot);
+    this._refreshCipher();
+    return bot.initialize();
+  }
+  async start(bot) {
+    const { path } = bot.config;
+    bot.ctx.router.post(path, (ctx) => {
+      this._refreshCipher();
+      const signature = ctx.get("X-Lark-Signature");
+      const enabledSignatureVerify = this.bots.filter((bot2) => bot2.config.verifySignature);
+      if (signature && enabledSignatureVerify.length) {
+        const result = enabledSignatureVerify.some((bot2) => {
+          var _a;
+          const timestamp = ctx.get("X-Lark-Request-Timestamp");
+          const nonce = ctx.get("X-Lark-Request-Nonce");
+          const body2 = ctx.request.rawBody;
+          const actualSignature = (_a = this.ciphers[bot2.config.appId]) == null ? void 0 : _a.calculateSignature(timestamp, nonce, body2);
+          if (actualSignature === signature)
+            return true;
+          else
+            return false;
+        });
+        if (!result)
+          return ctx.status = 403;
+      }
+      const body = this._tryDecryptBody(ctx.request.body);
+      if ((body == null ? void 0 : body.type) === "url_verification" && (body == null ? void 0 : body.challenge) && typeof body.challenge === "string") {
+        ctx.response.body = { challenge: body.challenge };
+        return;
+      }
+      const enabledVeirfyTokenVerify = this.bots.filter((bot2) => bot2.config.verifyToken && bot2.config.verificationToken);
+      if (enabledVeirfyTokenVerify.length) {
+        const result = enabledVeirfyTokenVerify.some((bot2) => {
+          var _a;
+          const token = (_a = ctx.request.body) == null ? void 0 : _a.token;
+          if (token === bot2.config.verificationToken)
+            return true;
+          else
+            return false;
+        });
+        if (!result)
+          return ctx.status = 403;
+      }
+      logger.debug("received decryped event: %o", body);
+      this.dispatchSession(body);
+      return ctx.status = 200;
+    });
+    bot.ctx.router.get(path + "/assets/:type/:message_id/:key", async (ctx) => {
+      const type = ctx.params.type === "image" ? "image" : "file";
+      const key = ctx.params.key;
+      const messageId = ctx.params.message_id;
+      const selfId = ctx.request.query.self_id;
+      const bot2 = this.bots.find((bot3) => bot3.selfId === selfId);
+      if (!bot2)
+        return ctx.status = 404;
+      const resp = await bot2.http.axios(`/im/v1/messages/${messageId}/resources/${key}`, {
+        method: "GET",
+        params: { type },
+        responseType: "stream"
+      });
+      ctx.status = 200;
+      ctx.response.headers["Content-Type"] = resp.headers["content-type"];
+      ctx.response.body = resp.data;
+    });
+  }
+  async stop() {
+    logger.debug("http server stopped");
+  }
+  dispatchSession(body) {
+    const { header } = body;
+    const { app_id, event_type } = header;
+    body.type = event_type;
+    const bot = this.bots.find((bot2) => bot2.selfId === app_id);
+    const session = adaptSession(bot, body);
+    bot.dispatch(session);
+  }
+  _tryDecryptBody(body) {
+    this._refreshCipher();
+    const ciphers = Object.values(this.ciphers);
+    if (ciphers.length && typeof body.encrypt === "string") {
+      for (const cipher of ciphers) {
+        try {
+          return JSON.parse(cipher.decrypt(body.encrypt));
+        } catch {
+        }
+      }
+      logger.warn("failed to decrypt message: %o", body);
+    }
+    if (typeof body.encrypt === "string" && !ciphers.length) {
+      logger.warn("encryptKey is not set, but received encrypted message: %o", body);
+    }
+    return body;
+  }
+  _refreshCipher() {
+    const ciphers = Object.keys(this.ciphers);
+    const bots = this.bots.map((bot) => bot.config.appId);
+    if (bots.length === ciphers.length && bots.every((bot) => ciphers.includes(bot)))
+      return;
+    this.ciphers = {};
+    for (const bot of this.bots) {
+      this.ciphers[bot.config.appId] = new Cipher(bot.config.encryptKey);
+    }
+  }
+};
+__name(HttpServer, "HttpServer");
+((HttpServer2) => {
+  HttpServer2.createConfig = /* @__PURE__ */ __name((path) => import_satori2.Schema.object({
+    path: import_satori2.Schema.string().role("url").description("要连接的服务器地址。").default(path),
+    selfUrl: import_satori2.Schema.string().role("link").description("服务器暴露在公网的地址。缺省时将使用全局配置。"),
+    verifyToken: import_satori2.Schema.boolean().description("是否验证令牌。"),
+    verifySignature: import_satori2.Schema.boolean().description("是否验证签名。")
+  }).description("服务端设置"), "createConfig");
+})(HttpServer || (HttpServer = {}));
+
+// satori/adapters/lark/src/message.ts
+var import_fs = require("fs");
+var import_satori3 = require("@satorijs/satori");
+var import_form_data = __toESM(require("form-data"));
+var LarkMessenger = class extends import_satori3.Messenger {
+  constructor() {
+    super(...arguments);
+    this.content = "";
+  }
+  async post(data) {
+    var _a, _b, _c, _d, _e;
+    try {
+      let resp;
+      if (this.quote) {
+        resp = await ((_a = this.bot.internal) == null ? void 0 : _a.replyMessage(this.quote, data));
+      } else {
+        data.receive_id = this.channelId;
+        resp = await ((_b = this.bot.internal) == null ? void 0 : _b.sendMessage(extractIdType(this.channelId), data));
+      }
+      const session = this.bot.session();
+      session.messageId = resp.data.message_id;
+      session.timestamp = Number(resp.data.create_time) * 1e3;
+      session.userId = resp.data.sender.id;
+      session.app.emit(session, "send", session);
+      this.results.push(session);
+    } catch (e) {
+      if (import_satori3.Quester.isAxiosError(e)) {
+        if ((_d = (_c = e.response) == null ? void 0 : _c.data) == null ? void 0 : _d.code) {
+          const generalErrorMsg = `Check error code at https://open.larksuite.com/document/ukTMukTMukTM/ugjM14COyUjL4ITN`;
+          e.message += ` (Feishu error code ${e.response.data.code}: ${(_e = e.response.data.msg) != null ? _e : generalErrorMsg})`;
+        }
+      }
+      this.errors.push(e);
+    }
+  }
+  async flush() {
+    if (this.content === "" && !this.addition && !this.richText)
+      return;
+    let message;
+    if (this.addition) {
+      message = {
+        ...message,
+        ...this.addition.file
+      };
+    }
+    if (this.richText) {
+      message = { zh_cn: this.richText };
+    }
+    if (this.content) {
+      message = { text: this.content };
+    }
+    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;
+  }
+  async sendFile(type, url) {
+    const payload = new import_form_data.default();
+    const assetKey = type === "image" ? "image" : "file";
+    const [schema, file] = url.split("://");
+    const filename = schema === "base64" ? "unknown" : new URL(url).pathname.split("/").pop();
+    if (schema === "file") {
+      payload.append(assetKey, (0, import_fs.createReadStream)(file));
+    } else if (schema === "base64") {
+      payload.append(assetKey, Buffer.from(file, "base64"));
+    } else {
+      const resp = await this.bot.assetsQuester.get(url, { responseType: "stream" });
+      payload.append(assetKey, resp);
+    }
+    if (type === "image") {
+      payload.append("image_type", "message");
+      const { data } = await this.bot.internal.uploadImage(payload);
+      return {
+        type: "image",
+        file: {
+          image_key: data.image_key
+        }
+      };
+    } 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";
+      } 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_name", filename);
+      const { data } = await this.bot.internal.uploadFile(payload);
+      return {
+        type: msgType,
+        file: {
+          file_key: data.file_key
+        }
+      };
+    }
+  }
+  async visit(element) {
+    var _a;
+    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">${(_a = attrs.name) != null ? _a : "所有人"}</at>`;
+        } else {
+          this.content += `<at user_id="${attrs.id}">${attrs.name}</at>`;
+        }
+        break;
+      }
+      case "a":
+        await this.render(children);
+        if (attrs.href)
+          this.content += ` (${attrs.href})`;
+        break;
+      case "sharp":
+        break;
+      case "quote":
+        await this.flush();
+        this.quote = attrs.id;
+        break;
+      case "image":
+      case "video":
+      case "audio":
+      case "file":
+        if (attrs.url) {
+          await this.flush();
+          this.addition = await this.sendFile(type, attrs.url);
+        }
+        break;
+      case "figure":
+      case "message":
+        await this.flush();
+        await this.render(children, true);
+        break;
+      default:
+        await this.render(children);
+    }
+  }
+};
+__name(LarkMessenger, "LarkMessenger");
+
+// satori/adapters/lark/src/types/index.ts
+var types_exports = {};
+__export(types_exports, {
+  Internal: () => Internal
+});
+
+// satori/adapters/lark/src/types/internal.ts
+var import_form_data2 = __toESM(require("form-data"));
+var import_satori4 = require("@satorijs/satori");
+var logger2 = new import_satori4.Logger("lark");
+var Internal = class {
+  constructor(http) {
+    this.http = http;
+  }
+  processReponse(response) {
+    const { code, msg } = response;
+    if (code === 0) {
+      return response;
+    } else {
+      logger2.debug("response: %o", response);
+      throw new Error(`HTTP response with non-zero status (${code}) with message "${msg}"`);
+    }
+  }
+  static define(routes) {
+    for (const path in routes) {
+      for (const key in routes[path]) {
+        const method = key;
+        for (const name of (0, import_satori4.makeArray)(routes[path][method])) {
+          Internal.prototype[name] = async function(...args) {
+            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 = {};
+            if (args.length === 1) {
+              if (method === "GET" || method === "DELETE") {
+                config.params = args[0];
+              } else {
+                if (method === "POST" && args[0] instanceof import_form_data2.default) {
+                  config.headers = args[0].getHeaders();
+                }
+                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}`);
+            }
+            return this.processReponse(await this.http(method, url, config));
+          };
+        }
+      }
+    }
+  }
+};
+__name(Internal, "Internal");
+
+// satori/adapters/lark/src/types/auth.ts
+Internal.define({
+  "/auth/v3/app_access_token/internal": {
+    POST: "getAppAccessToken"
+  },
+  "/auth/v3/tenant_access_token/internal": {
+    POST: "getTenantAccessToken"
+  }
+});
+
+// satori/adapters/lark/src/types/guild.ts
+Internal.define({
+  "/im/v1/chats": {
+    GET: "getCurrentUserGuilds"
+  },
+  "/im/v1/chats/{chat_id}": {
+    GET: "getGuildInfo"
+  },
+  "/im/v1/chats/{chat_id}/members": {
+    GET: "getGuildMembers"
+  }
+});
+
+// satori/adapters/lark/src/types/message/asset.ts
+Internal.define({
+  "/im/v1/images": {
+    POST: "uploadImage"
+  },
+  "/im/v1/files": {
+    POST: "uploadFile"
+  }
+});
+
+// satori/adapters/lark/src/types/message/index.ts
+Internal.define({
+  "/im/v1/messages?receive_id_type={receive_id_type}": {
+    POST: "sendMessage"
+  },
+  "/im/v1/messages/{message_id}/reply": {
+    POST: "replyMessage"
+  },
+  "/im/v1/messages/{message_id}": {
+    GET: "getMessage",
+    DELETE: "deleteMessage"
+  },
+  "/im/v1/messages/{message_id}/read_users": {
+    GET: "getMessageReadUsers"
+  }
+});
+
+// satori/adapters/lark/src/bot.ts
+var logger3 = new import_satori5.Logger("lark");
+var LarkBot = class extends import_satori5.Bot {
+  constructor(ctx, config) {
+    super(ctx, config);
+    if (!config.selfUrl && !ctx.root.config.selfUrl) {
+      logger3.warn("selfUrl is not set, some features may not work");
+    }
+    this.selfId = config.appId;
+    this.http = ctx.http.extend({
+      endpoint: config.endpoint,
+      headers: {
+        "Content-Type": "application/json; charset=utf-8"
+      }
+    });
+    this.assetsQuester = import_satori5.Quester.create();
+    this.internal = new Internal(this.http);
+    ctx.plugin(HttpServer, this);
+  }
+  async initialize() {
+    await this.refreshToken();
+    this.online();
+  }
+  async refreshToken() {
+    const { tenant_access_token: token } = await this.internal.getTenantAccessToken({
+      app_id: this.config.appId,
+      app_secret: this.config.appSecret
+    });
+    logger3.debug("refreshed token %s", token);
+    this.token = token;
+    if (this._refresher)
+      clearTimeout(this._refresher);
+    this._refresher = setTimeout(() => this.refreshToken(), 3600 * 1e3);
+    this.online();
+  }
+  get token() {
+    return this._token;
+  }
+  set token(v) {
+    this._token = v;
+    this.http.config.headers.Authorization = `Bearer ${v}`;
+  }
+  async sendMessage(channelId, content, guildId, options) {
+    return new LarkMessenger(this, channelId, guildId, options).send(content);
+  }
+  async sendPrivateMessage(userId, content, options) {
+    return this.sendMessage(userId, content, null, options);
+  }
+  async deleteMessage(channelId, messageId) {
+    await this.internal.deleteMessage(messageId);
+  }
+};
+__name(LarkBot, "LarkBot");
+((LarkBot2) => {
+  LarkBot2.Config = import_satori5.Schema.intersect([
+    import_satori5.Schema.object({
+      protocol: import_satori5.Schema.union(["feishu", "lark"]).required().description("平台名称。"),
+      appId: import_satori5.Schema.string().required().description("机器人的应用 ID。"),
+      appSecret: import_satori5.Schema.string().role("secret").required().description("机器人的应用密钥。"),
+      encryptKey: import_satori5.Schema.string().role("secret").description("机器人的 Encrypt Key。"),
+      verificationToken: import_satori5.Schema.string().description("事件推送的验证令牌。")
+    }),
+    import_satori5.Schema.union([
+      import_satori5.Schema.intersect([
+        import_satori5.Schema.object({
+          protocol: import_satori5.Schema.const("feishu").required()
+        }),
+        import_satori5.Quester.createConfig("https://open.feishu.cn/open-apis/"),
+        HttpServer.createConfig("/feishu")
+      ]),
+      import_satori5.Schema.intersect([
+        import_satori5.Schema.object({
+          protocol: import_satori5.Schema.const("lark").required()
+        }),
+        import_satori5.Quester.createConfig("https://open.larksuite.com/open-apis/"),
+        HttpServer.createConfig("/lark")
+      ])
+    ])
+  ]);
+})(LarkBot || (LarkBot = {}));
+
+// satori/adapters/lark/src/index.ts
+var src_default = LarkBot;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  Feishu,
+  FeishuBot,
+  Lark,
+  LarkBot
+});
+//# sourceMappingURL=index.js.map