@nextclaw/channel-plugin-feishu 0.2.21 → 0.2.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nextclaw/channel-plugin-feishu",
-  "version": "0.2.21",
+  "version": "0.2.23",
   "private": false,
   "description": "NextClaw Feishu/Lark channel plugin with doc/wiki/drive tools.",
   "type": "module",

package/src/bot.test.ts

@@ -342,6 +342,51 @@ describe("handleFeishuMessage command authorization", () => {
     expect(mockCreateFeishuClient).not.toHaveBeenCalled();
   });
 
+  it("does not block reply dispatch when sender-name lookup hangs", async () => {
+    vi.useFakeTimers();
+    try {
+      mockCreateFeishuClient.mockReturnValue({
+        contact: {
+          user: {
+            get: vi.fn(() => new Promise(() => undefined)),
+          },
+        },
+      });
+
+      const cfg: ClawdbotConfig = {
+        channels: {
+          feishu: {
+            dmPolicy: "open",
+            allowFrom: ["*"],
+          },
+        },
+      } as ClawdbotConfig;
+
+      const event: FeishuMessageEvent = {
+        sender: {
+          sender_id: {
+            open_id: "ou-attacker",
+          },
+        },
+        message: {
+          message_id: "msg-slow-sender-lookup",
+          chat_id: "oc-dm",
+          chat_type: "p2p",
+          message_type: "text",
+          content: JSON.stringify({ text: "hello" }),
+        },
+      };
+
+      const dispatchPromise = dispatchMessage({ cfg, event });
+      await vi.advanceTimersByTimeAsync(1_500);
+      await dispatchPromise;
+
+      expect(mockDispatchReplyFromConfig).toHaveBeenCalledTimes(1);
+    } finally {
+      vi.useRealTimers();
+    }
+  });
+
   it("propagates parent/root message ids into inbound context for reply reconstruction", async () => {
     mockGetMessageFeishu.mockResolvedValueOnce({
       messageId: "om_parent_001",

package/src/bot.ts

@@ -14,6 +14,7 @@ import {
   warnMissingProviderGroupPolicyFallbackOnce,
 } from "./nextclaw-sdk/feishu.js";
 import { resolveFeishuAccount } from "./accounts.js";
+import { raceWithTimeoutAndAbort } from "./async.js";
 import { createFeishuClient } from "./client.js";
 import { finalizeFeishuMessageProcessing, tryRecordMessagePersistent } from "./dedup.js";
 import { maybeCreateDynamicAgent } from "./dynamic-agent.js";
@@ -96,6 +97,7 @@ function extractPermissionError(err: unknown): PermissionError | null {
 // --- Sender name resolution (so the agent can distinguish who is speaking in group chats) ---
 // Cache display names by sender id (open_id/user_id) to avoid an API call on every message.
 const SENDER_NAME_TTL_MS = 10 * 60 * 1000;
+const SENDER_NAME_LOOKUP_BUDGET_MS = 1_500;
 const senderNameCache = new Map<string, { name: string; expireAt: number }>();
 
 // Cache permission errors to avoid spamming the user with repeated notifications.
@@ -108,6 +110,20 @@ type SenderNameResult = {
   permissionError?: PermissionError;
 };
 
+function getCachedSenderName(senderId: string): string | undefined {
+  const normalizedSenderId = senderId.trim();
+  if (!normalizedSenderId) {
+    return undefined;
+  }
+
+  const cached = senderNameCache.get(normalizedSenderId);
+  const now = Date.now();
+  if (!cached || cached.expireAt <= now) {
+    return undefined;
+  }
+  return cached.name;
+}
+
 function resolveSenderLookupIdType(senderId: string): "open_id" | "user_id" | "union_id" {
   const trimmed = senderId.trim();
   if (trimmed.startsWith("ou_")) {
@@ -174,6 +190,32 @@ async function resolveFeishuSenderName(params: {
   }
 }
 
+async function resolveFeishuSenderNameWithinBudget(params: {
+  account: ResolvedFeishuAccount;
+  senderId: string;
+  log: (...args: any[]) => void;
+  timeoutMs?: number;
+}): Promise<SenderNameResult> {
+  const cachedName = getCachedSenderName(params.senderId);
+  if (cachedName) {
+    return { name: cachedName };
+  }
+
+  const timeoutMs = params.timeoutMs ?? SENDER_NAME_LOOKUP_BUDGET_MS;
+  const lookupPromise = resolveFeishuSenderName(params);
+  const lookupResult = await raceWithTimeoutAndAbort(lookupPromise, { timeoutMs });
+  if (lookupResult.status === "resolved") {
+    return lookupResult.value;
+  }
+
+  params.log(
+    `feishu[${params.account.accountId}]: sender-name lookup exceeded ${timeoutMs}ms; ` +
+      "continuing without blocking reply",
+  );
+  void lookupPromise.catch(() => undefined);
+  return {};
+}
+
 export type FeishuMessageEvent = {
   sender: {
     sender_id: {
@@ -941,7 +983,7 @@ export async function handleFeishuMessage(params: {
   // Optimization: skip if disabled to save API quota (Feishu free tier limit).
   let permissionErrorForAgent: PermissionError | undefined;
   if (feishuCfg?.resolveSenderNames ?? true) {
-    const senderResult = await resolveFeishuSenderName({
+    const senderResult = await resolveFeishuSenderNameWithinBudget({
       account,
       senderId: ctx.senderOpenId,
       log,

package/src/channel.ts

@@ -109,7 +109,8 @@ export const feishuPlugin: ChannelPlugin<ResolvedFeishuAccount> = {
   },
   agentPrompt: {
     messageToolHints: () => [
-      "- Feishu targeting: omit `target` to reply to the current conversation (auto-inferred). Explicit targets: `user:open_id` or `chat:chat_id`.",
+      "- Feishu targeting: omit `target` only when replying in the current Feishu conversation. For proactive sends from UI/CLI/another channel, pass an explicit target such as `user:open_id` or `chat:chat_id`.",
+      "- If the current session is not Feishu, never rely on `channel=feishu` alone; resolve the route first (for example from an existing Feishu session) and then send to that explicit target.",
       "- Feishu supports interactive cards for rich messages.",
     ],
   },