@dobby.ai/dobby 0.1.0

package/plugins/connector-feishu/src/connector.ts

@@ -0,0 +1,343 @@
+import { randomUUID } from "node:crypto";
+import * as Lark from "@larksuiteoapi/node-sdk";
+import type {
+  ConnectorCapabilities,
+  ConnectorContext,
+  ConnectorPlugin,
+  ConnectorSendResult,
+  GatewayLogger,
+  OutboundEnvelope,
+} from "@dobby.ai/plugin-sdk";
+import { mapFeishuMessageEvent, type FeishuMessageEvent } from "./mapper.js";
+
+export interface FeishuConnectorConfig {
+  appId: string;
+  appSecret: string;
+  domain?: "feishu" | "lark";
+  botName?: string;
+  botOpenId?: string;
+  messageFormat?: "text" | "card_markdown";
+  replyMode?: "direct" | "reply";
+  cardTitle?: string;
+  downloadAttachments?: boolean;
+}
+
+const FEISHU_CARD_MAX_TEXT_LENGTH = 8_000;
+const FEISHU_TEXT_MAX_TEXT_LENGTH = 12_000;
+
+function resolveDomain(domain?: "feishu" | "lark"): string {
+  return domain === "lark" ? "https://open.larksuite.com" : "https://open.feishu.cn";
+}
+
+function textContent(text: string): string {
+  return JSON.stringify({ text });
+}
+
+function cardContent(text: string, title: string): string {
+  return JSON.stringify({
+    schema: "2.0",
+    config: {
+      wide_screen_mode: true,
+      update_multi: true,
+    },
+    header: {
+      template: "blue",
+      title: {
+        tag: "plain_text",
+        content: title,
+      },
+    },
+    body: {
+      direction: "vertical",
+      padding: "12px 12px 12px 12px",
+      elements: [
+        {
+          tag: "markdown",
+          content: text.trim().length > 0 ? text : "(empty response)",
+        },
+      ],
+    },
+  });
+}
+
+function toSendResult(messageId?: string): ConnectorSendResult {
+  return messageId ? { messageId } : {};
+}
+
+export class FeishuConnector implements ConnectorPlugin {
+  readonly id: string;
+  readonly platform = "feishu" as const;
+  readonly name = "feishu";
+  readonly capabilities: ConnectorCapabilities;
+
+  private ctx: ConnectorContext | null = null;
+  private client: Lark.Client | null = null;
+  private wsClient: Lark.WSClient | null = null;
+
+  constructor(
+    id: string,
+    private readonly config: FeishuConnectorConfig,
+    private readonly attachmentsRoot: string,
+    private readonly logger: GatewayLogger,
+  ) {
+    this.id = id;
+    this.capabilities = {
+      updateStrategy: this.messageFormat === "card_markdown" ? "final_only" : "edit",
+      supportedSources: ["chat"],
+      supportsThread: this.replyMode === "reply",
+      supportsTyping: false,
+      supportsFileUpload: false,
+      maxTextLength: this.messageFormat === "card_markdown" ? FEISHU_CARD_MAX_TEXT_LENGTH : FEISHU_TEXT_MAX_TEXT_LENGTH,
+    };
+  }
+
+  async start(ctx: ConnectorContext): Promise<void> {
+    if (this.wsClient) {
+      this.logger.warn({ connectorId: this.id }, "Feishu connector start called while already started");
+      return;
+    }
+
+    const baseConfig = {
+      appId: this.config.appId,
+      appSecret: this.config.appSecret,
+      domain: resolveDomain(this.config.domain),
+    };
+
+    this.ctx = ctx;
+    this.client = new Lark.Client(baseConfig);
+    this.wsClient = new Lark.WSClient(baseConfig);
+    await this.logAppSubscriptionState();
+
+    const dispatcher = new Lark.EventDispatcher({}).register({
+      "im.message.receive_v1": async (event: FeishuMessageEvent) => {
+        if (!this.ctx || !this.client) {
+          return;
+        }
+
+        this.logger.info(
+          {
+            connectorId: this.id,
+            chatId: event.message.chat_id,
+            messageId: event.message.message_id,
+            chatType: event.message.chat_type,
+            messageType: event.message.message_type,
+            mentionCount: event.message.mentions?.length ?? 0,
+          },
+          "Feishu inbound event received",
+        );
+
+        const inbound = await mapFeishuMessageEvent({
+          event,
+          connectorId: this.id,
+          attachmentsRoot: this.attachmentsRoot,
+          client: this.client,
+          logger: this.logger,
+          downloadAttachments: this.config.downloadAttachments !== false,
+          ...(this.config.botOpenId ? { botOpenId: this.config.botOpenId } : {}),
+          ...(this.config.botName ? { botName: this.config.botName } : {}),
+        });
+        if (!inbound) {
+          return;
+        }
+
+        this.logger.info(
+          {
+            connectorId: this.id,
+            chatId: inbound.chatId,
+            messageId: inbound.messageId,
+            isDirectMessage: inbound.isDirectMessage,
+            mentionedBot: inbound.mentionedBot,
+            textLength: inbound.text.length,
+            attachmentCount: inbound.attachments.length,
+          },
+          "Feishu inbound event mapped",
+        );
+
+        await this.ctx.emitInbound(inbound);
+      },
+    });
+
+    await this.wsClient.start({
+      eventDispatcher: dispatcher,
+    });
+
+    this.logger.info(
+      {
+        connectorId: this.id,
+        domain: this.config.domain ?? "feishu",
+        messageFormat: this.messageFormat,
+        replyMode: this.replyMode,
+      },
+      "Feishu connector ready",
+    );
+  }
+
+  async send(message: OutboundEnvelope): Promise<ConnectorSendResult> {
+    if (!this.client) {
+      throw new Error("Feishu connector is not started");
+    }
+
+    if (message.attachments && message.attachments.length > 0) {
+      this.logger.warn(
+        {
+          connectorId: this.id,
+          chatId: message.chatId,
+          attachmentCount: message.attachments.length,
+        },
+        "Outbound Feishu attachments are not supported yet; sending text only",
+      );
+    }
+
+    if (message.mode === "update") {
+      if (!message.targetMessageId) {
+        throw new Error("targetMessageId is required for update mode");
+      }
+
+      if (this.messageFormat === "card_markdown") {
+        await this.client.im.v1.message.patch({
+          path: {
+            message_id: message.targetMessageId,
+          },
+          data: {
+            content: this.renderContent(message.text),
+          },
+        });
+        return { messageId: message.targetMessageId };
+      }
+
+      const response = await this.client.im.v1.message.update({
+        path: {
+          message_id: message.targetMessageId,
+        },
+        data: {
+          msg_type: "text",
+          content: this.renderContent(message.text),
+        },
+      });
+      return { messageId: response.data?.message_id ?? message.targetMessageId };
+    }
+
+    if (this.replyMode === "reply" && message.replyToMessageId) {
+      const response = await this.client.im.v1.message.reply({
+        path: {
+          message_id: message.replyToMessageId,
+        },
+        data: {
+          msg_type: this.renderMessageType(),
+          content: this.renderContent(message.text),
+          reply_in_thread: Boolean(message.threadId),
+          uuid: randomUUID(),
+        },
+      });
+      return toSendResult(response.data?.message_id);
+    }
+
+    if (this.replyMode === "reply" && message.threadId) {
+      const response = await this.client.im.v1.message.reply({
+        path: {
+          message_id: message.threadId,
+        },
+        data: {
+          msg_type: this.renderMessageType(),
+          content: this.renderContent(message.text),
+          reply_in_thread: true,
+          uuid: randomUUID(),
+        },
+      });
+      return toSendResult(response.data?.message_id);
+    }
+
+    const response = await this.client.im.v1.message.create({
+      params: {
+        receive_id_type: "chat_id",
+      },
+      data: {
+        receive_id: message.chatId,
+        msg_type: this.renderMessageType(),
+        content: this.renderContent(message.text),
+        uuid: randomUUID(),
+      },
+    });
+    return toSendResult(response.data?.message_id);
+  }
+
+  async stop(): Promise<void> {
+    const wsClient = this.wsClient;
+    this.wsClient = null;
+    this.client = null;
+    this.ctx = null;
+    wsClient?.close({ force: true });
+  }
+
+  private async logAppSubscriptionState(): Promise<void> {
+    if (!this.client) {
+      return;
+    }
+
+    try {
+      const response = await this.client.application.v6.application.get({
+        path: {
+          app_id: this.config.appId,
+        },
+        params: {
+          lang: "zh_cn",
+        },
+      });
+
+      const subscribedEvents = response.data?.app?.event?.subscribed_events ?? [];
+      this.logger.info(
+        {
+          connectorId: this.id,
+          appId: this.config.appId,
+          appName: response.data?.app?.app_name ?? this.config.botName ?? null,
+          onlineVersionId: response.data?.app?.online_version_id ?? null,
+          draftVersionId: response.data?.app?.unaudit_version_id ?? null,
+          subscriptionType: response.data?.app?.event?.subscription_type ?? null,
+          subscribedEvents,
+        },
+        "Feishu published application info loaded",
+      );
+
+      if (!subscribedEvents.includes("im.message.receive_v1")) {
+        this.logger.warn(
+          {
+            connectorId: this.id,
+            appId: this.config.appId,
+            onlineVersionId: response.data?.app?.online_version_id ?? null,
+            draftVersionId: response.data?.app?.unaudit_version_id ?? null,
+            subscribedEvents,
+          },
+          "Published Feishu app config does not show im.message.receive_v1",
+        );
+      }
+    } catch (error) {
+      this.logger.warn(
+        {
+          err: error,
+          connectorId: this.id,
+          appId: this.config.appId,
+        },
+        "Failed to load Feishu application info",
+      );
+    }
+  }
+
+  private get messageFormat(): "text" | "card_markdown" {
+    return this.config.messageFormat ?? "card_markdown";
+  }
+
+  private get replyMode(): "direct" | "reply" {
+    return this.config.replyMode ?? "direct";
+  }
+
+  private renderMessageType(): "text" | "interactive" {
+    return this.messageFormat === "card_markdown" ? "interactive" : "text";
+  }
+
+  private renderContent(text: string): string {
+    if (this.messageFormat === "card_markdown") {
+      return cardContent(text, this.config.cardTitle ?? this.config.botName ?? "dobby");
+    }
+    return textContent(text);
+  }
+}

package/plugins/connector-feishu/src/contribution.ts

@@ -0,0 +1,26 @@
+import { z } from "zod";
+import type { ConnectorContributionModule } from "@dobby.ai/plugin-sdk";
+import { FeishuConnector, type FeishuConnectorConfig } from "./connector.js";
+
+const feishuConnectorConfigSchema = z.object({
+  appId: z.string().min(1),
+  appSecret: z.string().min(1),
+  domain: z.enum(["feishu", "lark"]).default("feishu"),
+  botName: z.string().min(1).optional(),
+  botOpenId: z.string().min(1).optional(),
+  messageFormat: z.enum(["text", "card_markdown"]).default("card_markdown"),
+  replyMode: z.enum(["direct", "reply"]).default("direct"),
+  cardTitle: z.string().min(1).optional(),
+  downloadAttachments: z.boolean().default(true),
+});
+
+export const connectorFeishuContribution: ConnectorContributionModule = {
+  kind: "connector",
+  configSchema: z.toJSONSchema(feishuConnectorConfigSchema),
+  createInstance(options) {
+    const config = feishuConnectorConfigSchema.parse(options.config) as FeishuConnectorConfig;
+    return new FeishuConnector(options.instanceId, config, options.attachmentsRoot, options.host.logger);
+  },
+};
+
+export default connectorFeishuContribution;