moltbot-channel-feishu 0.0.8

package/src/core/gateway.ts

@@ -0,0 +1,202 @@
+/**
+ * WebSocket gateway for real-time Feishu events.
+ */
+
+import * as Lark from "@larksuiteoapi/node-sdk";
+import type { ClawdbotConfig, RuntimeEnv, HistoryEntry } from "clawdbot/plugin-sdk";
+import type { Config } from "../config/schema.js";
+import type { MessageReceivedEvent, BotAddedEvent, BotRemovedEvent } from "../types/index.js";
+import { createWsClient, probeConnection } from "../api/client.js";
+import { handleMessage } from "./handler.js";
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export interface GatewayOptions {
+  cfg: ClawdbotConfig;
+  runtime?: RuntimeEnv;
+  abortSignal?: AbortSignal;
+}
+
+export interface GatewayState {
+  botOpenId: string | undefined;
+  wsClient: Lark.WSClient | null;
+  chatHistories: Map<string, HistoryEntry[]>;
+  /** Message ID deduplication cache to prevent duplicate event processing */
+  processedMessages: Set<string>;
+}
+
+// ============================================================================
+// Gateway State
+// ============================================================================
+
+/** Max processed messages to cache (LRU-style) */
+const MAX_PROCESSED_MESSAGES = 5000;
+
+const state: GatewayState = {
+  botOpenId: undefined,
+  wsClient: null,
+  chatHistories: new Map(),
+  processedMessages: new Set(),
+};
+
+/**
+ * Get the current bot's open_id.
+ */
+export function getBotOpenId(): string | undefined {
+  return state.botOpenId;
+}
+
+// ============================================================================
+// Gateway Lifecycle
+// ============================================================================
+
+/**
+ * Start the WebSocket gateway.
+ * Connects to Feishu and begins processing events.
+ */
+export async function startGateway(options: GatewayOptions): Promise<void> {
+  const { cfg, runtime, abortSignal } = options;
+  const feishuCfg = cfg.channels?.feishu as Config | undefined;
+  const log = (msg: string) => runtime?.log?.(msg);
+  const error = (msg: string) => runtime?.error?.(msg);
+
+  if (!feishuCfg) {
+    throw new Error("Feishu not configured");
+  }
+
+  // Probe to get bot info
+  const probeResult = await probeConnection(feishuCfg);
+  if (probeResult.ok) {
+    state.botOpenId = probeResult.botOpenId;
+    log(`Gateway: bot open_id resolved: ${state.botOpenId ?? "unknown"}`);
+  }
+
+  // Only websocket mode is supported
+  log("Gateway: starting WebSocket connection...");
+
+  const wsClient = createWsClient(feishuCfg);
+  state.wsClient = wsClient;
+
+  const eventDispatcher = new Lark.EventDispatcher({});
+
+  // Register event handlers
+  eventDispatcher.register({
+    "im.message.receive_v1": async (data: unknown) => {
+      try {
+        const event = data as MessageReceivedEvent;
+        const messageId = event.message?.message_id;
+
+        // Dedupe: skip if already processed (Feishu SDK may push duplicates)
+        if (messageId && state.processedMessages.has(messageId)) {
+          log(`Gateway: skipping duplicate message ${messageId}`);
+          return;
+        }
+
+        // Track processed message
+        if (messageId) {
+          state.processedMessages.add(messageId);
+          // LRU-style cleanup: remove oldest entries when cache is full
+          if (state.processedMessages.size > MAX_PROCESSED_MESSAGES) {
+            const oldest = state.processedMessages.values().next().value;
+            if (oldest) state.processedMessages.delete(oldest);
+          }
+        }
+
+        await handleMessage({
+          cfg,
+          event,
+          botOpenId: state.botOpenId,
+          runtime,
+          chatHistories: state.chatHistories,
+        });
+      } catch (err) {
+        error(`Gateway: error handling message: ${String(err)}`);
+      }
+    },
+
+    "im.message.message_read_v1": async () => {
+      // Ignore read receipts
+    },
+
+    "im.chat.member.bot.added_v1": async (data: unknown) => {
+      try {
+        const event = data as BotAddedEvent;
+        log(`Gateway: bot added to chat ${event.chat_id}`);
+      } catch (err) {
+        error(`Gateway: error handling bot added: ${String(err)}`);
+      }
+    },
+
+    "im.chat.member.bot.deleted_v1": async (data: unknown) => {
+      try {
+        const event = data as BotRemovedEvent;
+        log(`Gateway: bot removed from chat ${event.chat_id}`);
+      } catch (err) {
+        error(`Gateway: error handling bot removed: ${String(err)}`);
+      }
+    },
+  });
+
+  // Track reconnection attempts via polling (SDK handles reconnection internally)
+  let reconnectCheckInterval: ReturnType<typeof setInterval> | null = null;
+
+  return new Promise((resolve, reject) => {
+    const cleanup = () => {
+      if (reconnectCheckInterval) {
+        clearInterval(reconnectCheckInterval);
+        reconnectCheckInterval = null;
+      }
+      if (state.wsClient === wsClient) {
+        state.wsClient = null;
+      }
+    };
+
+    const handleAbort = () => {
+      log("Gateway: abort signal received, stopping...");
+      cleanup();
+      resolve();
+    };
+
+    if (abortSignal?.aborted) {
+      cleanup();
+      resolve();
+      return;
+    }
+
+    abortSignal?.addEventListener("abort", handleAbort, { once: true });
+
+    try {
+      wsClient.start({ eventDispatcher });
+      log("Gateway: WebSocket client started");
+
+      // Monitor reconnection status (SDK handles reconnection internally)
+      reconnectCheckInterval = setInterval(() => {
+        try {
+          const reconnectInfo = wsClient.getReconnectInfo?.();
+          if (reconnectInfo && reconnectInfo.nextConnectTime > 0) {
+            const nextConnect = new Date(reconnectInfo.nextConnectTime).toISOString();
+            log(`Gateway: reconnection scheduled at ${nextConnect}`);
+          }
+        } catch {
+          // getReconnectInfo may not be available in all SDK versions
+        }
+      }, 30000); // Check every 30 seconds
+    } catch (err) {
+      cleanup();
+      abortSignal?.removeEventListener("abort", handleAbort);
+      reject(err);
+    }
+  });
+}
+
+/**
+ * Stop the WebSocket gateway.
+ */
+export function stopGateway(): void {
+  state.wsClient = null;
+  state.botOpenId = undefined;
+  state.chatHistories.clear();
+  state.processedMessages.clear();
+}

package/src/core/handler.ts

@@ -0,0 +1,231 @@
+/**
+ * Message handler for Feishu events.
+ * Integrates with Clawdbot runtime for routing and agent execution.
+ */
+
+import type { ClawdbotConfig, RuntimeEnv, HistoryEntry, PluginRuntime } from "clawdbot/plugin-sdk";
+import {
+  buildPendingHistoryContextFromMap,
+  recordPendingHistoryEntryIfEnabled,
+  clearHistoryEntriesIfEnabled,
+  DEFAULT_GROUP_HISTORY_LIMIT,
+} from "clawdbot/plugin-sdk";
+
+import type { Config } from "../config/schema.js";
+import type { MessageReceivedEvent } from "../types/index.js";
+import { parseMessageEvent } from "./parser.js";
+import { checkGroupPolicy, shouldRequireMention, matchAllowlist } from "./policy.js";
+import { createReplyDispatcher } from "./reply-dispatcher.js";
+import { getMessage } from "../api/messages.js";
+import { getRuntime } from "./runtime.js";
+
+// ============================================================================
+// Types
+// ============================================================================
+
+export interface MessageHandlerParams {
+  cfg: ClawdbotConfig;
+  event: MessageReceivedEvent;
+  botOpenId?: string;
+  runtime?: RuntimeEnv;
+  chatHistories?: Map<string, HistoryEntry[]>;
+}
+
+// ============================================================================
+// Message Handler
+// ============================================================================
+
+export async function handleMessage(params: MessageHandlerParams): Promise<void> {
+  const { cfg, event, botOpenId, runtime, chatHistories } = params;
+  const feishuCfg = cfg.channels?.feishu as Config | undefined;
+  const log = runtime?.log ?? console.log;
+  const error = runtime?.error ?? console.error;
+
+  // Early guard: require feishu config
+  if (!feishuCfg) {
+    log("Feishu config not found, skipping message");
+    return;
+  }
+
+  // Parse the event
+  const parsed = parseMessageEvent(event, botOpenId);
+  const isGroup = parsed.chatType === "group";
+
+  log(`Received message from ${parsed.senderOpenId} in ${parsed.chatId} (${parsed.chatType})`);
+
+  const historyLimit = Math.max(
+    0,
+    feishuCfg.historyLimit ?? cfg.messages?.groupChat?.historyLimit ?? DEFAULT_GROUP_HISTORY_LIMIT
+  );
+
+  // Check policies
+  if (isGroup) {
+    const result = checkGroupPolicy(feishuCfg, parsed.chatId, parsed.senderOpenId);
+
+    if (!result.allowed) {
+      log(`Sender ${parsed.senderOpenId} not in group allowlist`);
+      return;
+    }
+
+    const requireMention = shouldRequireMention(feishuCfg, parsed.chatType, parsed.chatId);
+
+    if (requireMention && !parsed.mentionedBot) {
+      log(`Message in group ${parsed.chatId} did not mention bot, recording to history`);
+      if (chatHistories) {
+        recordPendingHistoryEntryIfEnabled({
+          historyMap: chatHistories,
+          historyKey: parsed.chatId,
+          limit: historyLimit,
+          entry: {
+            sender: parsed.senderOpenId,
+            body: parsed.content,
+            timestamp: Date.now(),
+            messageId: parsed.messageId,
+          },
+        });
+      }
+      return;
+    }
+  } else {
+    const dmPolicy = feishuCfg?.dmPolicy ?? "pairing";
+    const allowFrom = feishuCfg?.allowFrom ?? [];
+
+    if (dmPolicy === "allowlist") {
+      const match = matchAllowlist(allowFrom as (string | number)[], parsed.senderOpenId);
+      if (!match) {
+        log(`Sender ${parsed.senderOpenId} not in DM allowlist`);
+        return;
+      }
+    }
+  }
+
+  // Dispatch to agent
+  try {
+    const core = getRuntime() as PluginRuntime;
+
+    const feishuFrom = isGroup ? `feishu:group:${parsed.chatId}` : `feishu:${parsed.senderOpenId}`;
+    const feishuTo = isGroup ? `chat:${parsed.chatId}` : `user:${parsed.senderOpenId}`;
+
+    const route = core.channel.routing.resolveAgentRoute({
+      cfg,
+      channel: "feishu",
+      peer: {
+        kind: isGroup ? "group" : "dm",
+        id: isGroup ? parsed.chatId : parsed.senderOpenId,
+      },
+    });
+
+    const preview = parsed.content.replace(/\s+/g, " ").slice(0, 160);
+    const inboundLabel = isGroup
+      ? `Feishu message in group ${parsed.chatId}`
+      : `Feishu DM from ${parsed.senderOpenId}`;
+
+    core.system.enqueueSystemEvent(`${inboundLabel}: ${preview}`, {
+      sessionKey: route.sessionKey,
+      contextKey: `feishu:message:${parsed.chatId}:${parsed.messageId}`,
+    });
+
+    // Fetch quoted message if replying
+    let quotedContent: string | undefined;
+    if (parsed.parentId) {
+      try {
+        const quotedMsg = await getMessage(feishuCfg, parsed.parentId);
+        if (quotedMsg) {
+          quotedContent = quotedMsg.content;
+          log(`Fetched quoted message: ${quotedContent?.slice(0, 100)}`);
+        }
+      } catch (err) {
+        log(`Failed to fetch quoted message: ${String(err)}`);
+      }
+    }
+
+    const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(cfg);
+
+    // Build message body
+    let messageBody = parsed.content;
+    if (quotedContent) {
+      messageBody = `[Replying to: "${quotedContent}"]\n\n${parsed.content}`;
+    }
+
+    const body = core.channel.reply.formatAgentEnvelope({
+      channel: "Feishu",
+      from: isGroup ? parsed.chatId : parsed.senderOpenId,
+      timestamp: new Date(),
+      envelope: envelopeOptions,
+      body: messageBody,
+    });
+
+    let combinedBody = body;
+    const historyKey = isGroup ? parsed.chatId : undefined;
+
+    if (isGroup && historyKey && chatHistories) {
+      combinedBody = buildPendingHistoryContextFromMap({
+        historyMap: chatHistories,
+        historyKey,
+        limit: historyLimit,
+        currentMessage: combinedBody,
+        formatEntry: (entry: HistoryEntry) =>
+          core.channel.reply.formatAgentEnvelope({
+            channel: "Feishu",
+            from: parsed.chatId,
+            timestamp: entry.timestamp,
+            body: `${entry.sender}: ${entry.body}`,
+            envelope: envelopeOptions,
+          }),
+      });
+    }
+
+    const ctxPayload = core.channel.reply.finalizeInboundContext({
+      Body: combinedBody,
+      RawBody: parsed.content,
+      CommandBody: parsed.content,
+      From: feishuFrom,
+      To: feishuTo,
+      SessionKey: route.sessionKey,
+      AccountId: route.accountId,
+      ChatType: isGroup ? "group" : "direct",
+      GroupSubject: isGroup ? parsed.chatId : undefined,
+      SenderName: parsed.senderOpenId,
+      SenderId: parsed.senderOpenId,
+      Provider: "feishu" as const,
+      Surface: "feishu" as const,
+      MessageSid: parsed.messageId,
+      Timestamp: Date.now(),
+      WasMentioned: parsed.mentionedBot,
+      CommandAuthorized: true,
+      OriginatingChannel: "feishu" as const,
+      OriginatingTo: feishuTo,
+    });
+
+    const { dispatcher, replyOptions, markDispatchIdle } = createReplyDispatcher({
+      cfg,
+      agentId: route.agentId,
+      runtime: runtime as RuntimeEnv,
+      chatId: parsed.chatId,
+      replyToMessageId: parsed.messageId,
+    });
+
+    log(`Dispatching to agent (session=${route.sessionKey})`);
+
+    const { queuedFinal, counts } = await core.channel.reply.dispatchReplyFromConfig({
+      ctx: ctxPayload,
+      cfg,
+      dispatcher,
+      replyOptions,
+    });
+
+    markDispatchIdle();
+
+    if (isGroup && historyKey && chatHistories) {
+      clearHistoryEntriesIfEnabled({
+        historyMap: chatHistories,
+        historyKey,
+        limit: historyLimit,
+      });
+    }
+
+    log(`Dispatch complete (queuedFinal=${queuedFinal}, replies=${counts.final})`);
+  } catch (err) {
+    error(`Failed to dispatch message: ${String(err)}`);
+  }
+}

package/src/core/parser.ts

@@ -0,0 +1,112 @@
+/**
+ * Message event parsing utilities.
+ */
+
+import type { MessageReceivedEvent, MessageMention, ParsedMessage } from "../types/index.js";
+
+// ============================================================================
+// Content Parsing
+// ============================================================================
+
+/**
+ * Parse message content based on message type.
+ * Extracts text from JSON-wrapped content.
+ */
+export function parseMessageContent(content: string, messageType: string): string {
+  try {
+    const parsed: unknown = JSON.parse(content);
+    if (
+      messageType === "text" &&
+      typeof parsed === "object" &&
+      parsed !== null &&
+      "text" in parsed
+    ) {
+      return String((parsed as { text: unknown }).text);
+    }
+    return content;
+  } catch {
+    return content;
+  }
+}
+
+// ============================================================================
+// Mention Detection
+// ============================================================================
+
+/**
+ * Check if the bot was mentioned in a message.
+ */
+export function isBotMentioned(
+  mentions: MessageMention[] | undefined,
+  botOpenId: string | undefined
+): boolean {
+  if (!mentions || mentions.length === 0) {
+    return false;
+  }
+
+  // If we don't know our bot's open_id, assume any mention is us
+  if (!botOpenId) {
+    return mentions.length > 0;
+  }
+
+  return mentions.some((m) => m.id.open_id === botOpenId);
+}
+
+/**
+ * Remove bot mention text from message content.
+ * Cleans up both @name and mention keys.
+ */
+export function stripMentions(text: string, mentions: MessageMention[] | undefined): string {
+  if (!mentions || mentions.length === 0) {
+    return text;
+  }
+
+  let result = text;
+  for (const mention of mentions) {
+    // Remove @name format
+    const namePattern = new RegExp(`@${escapeRegex(mention.name)}\\s*`, "g");
+    result = result.replace(namePattern, "").trim();
+
+    // Remove mention key format (e.g., @_user_xxx)
+    result = result.replace(new RegExp(escapeRegex(mention.key), "g"), "").trim();
+  }
+
+  return result;
+}
+
+/**
+ * Escape special regex characters in a string.
+ */
+function escapeRegex(str: string): string {
+  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+
+// ============================================================================
+// Event Parsing
+// ============================================================================
+
+/**
+ * Parse a raw message event into a standardized format.
+ */
+export function parseMessageEvent(event: MessageReceivedEvent, botOpenId?: string): ParsedMessage {
+  const message = event.message;
+  const sender = event.sender;
+
+  const rawContent = parseMessageContent(message.content, message.message_type);
+  const mentionedBot = isBotMentioned(message.mentions, botOpenId);
+  const content = stripMentions(rawContent, message.mentions);
+
+  return {
+    chatId: message.chat_id,
+    messageId: message.message_id,
+    senderId: sender.sender_id.user_id ?? sender.sender_id.open_id ?? "",
+    senderOpenId: sender.sender_id.open_id ?? "",
+    senderName: undefined, // Not available in event, would need API lookup
+    chatType: message.chat_type,
+    mentionedBot,
+    rootId: message.root_id ?? undefined,
+    parentId: message.parent_id ?? undefined,
+    content,
+    contentType: message.message_type,
+  };
+}