@nextclaw/channel-plugin-feishu 0.2.20 → 0.2.22

package/package.json

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

package/src/channel.test.ts

@@ -2,11 +2,18 @@ import type { OpenClawConfig } from "./nextclaw-sdk/feishu.js";
 import { describe, expect, it, vi } from "vitest";
 
 const probeFeishuMock = vi.hoisted(() => vi.fn());
+const monitorFeishuProviderMock = vi.hoisted(() => vi.fn());
+const stopFeishuMonitorMock = vi.hoisted(() => vi.fn());
 
 vi.mock("./probe.js", () => ({
   probeFeishu: probeFeishuMock,
 }));
 
+vi.mock("./monitor.js", () => ({
+  monitorFeishuProvider: monitorFeishuProviderMock,
+  stopFeishuMonitor: stopFeishuMonitorMock,
+}));
+
 import { feishuPlugin } from "./channel.js";
 
 describe("feishuPlugin.status.probeAccount", () => {
@@ -45,4 +52,62 @@ describe("feishuPlugin.status.probeAccount", () => {
     );
     expect(result).toMatchObject({ ok: true, appId: "cli_main" });
   });
+
+  it("starts gateway monitor without blocking service startup", async () => {
+    let resolveMonitor!: () => void;
+    const monitorDone = new Promise<void>((resolve) => {
+      resolveMonitor = resolve;
+    });
+    monitorFeishuProviderMock.mockReturnValueOnce(monitorDone);
+
+    const abortController = new AbortController();
+    const ctx = {
+      cfg: {
+        channels: {
+          feishu: {
+            enabled: true,
+            appId: "cli_default",
+            appSecret: "secret_default",
+            connectionMode: "websocket",
+          },
+        },
+      } as OpenClawConfig,
+      accountId: "default",
+      abortSignal: abortController.signal,
+      setStatus: vi.fn(),
+      log: {
+        info: vi.fn(),
+        error: vi.fn(),
+      },
+      runtime: {
+        log: vi.fn(),
+        info: vi.fn(),
+        warn: vi.fn(),
+        error: vi.fn(),
+        debug: vi.fn(),
+      },
+    };
+
+    const timeoutToken = Symbol("timeout");
+    const started = await Promise.race([
+      feishuPlugin.gateway?.startAccount?.(ctx),
+      new Promise<symbol>((resolve) => setTimeout(() => resolve(timeoutToken), 20)),
+    ]);
+
+    expect(started).not.toBe(timeoutToken);
+    expect(monitorFeishuProviderMock).toHaveBeenCalledWith({
+      config: ctx.cfg,
+      runtime: ctx.runtime,
+      abortSignal: ctx.abortSignal,
+      accountId: "default",
+    });
+    expect(ctx.setStatus).toHaveBeenCalledWith({ accountId: "default", port: null });
+    expect(typeof (started as { stop?: () => Promise<void> }).stop).toBe("function");
+
+    abortController.abort();
+    resolveMonitor();
+    await (started as { stop?: () => Promise<void> }).stop?.();
+
+    expect(stopFeishuMonitorMock).toHaveBeenCalledWith("default");
+  });
 });

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.",
     ],
   },
@@ -351,19 +352,40 @@ export const feishuPlugin: ChannelPlugin<ResolvedFeishuAccount> = {
   },
   gateway: {
     startAccount: async (ctx) => {
-      const { monitorFeishuProvider } = await import("./monitor.js");
+      const { monitorFeishuProvider, stopFeishuMonitor } = await import("./monitor.js");
       const account = resolveFeishuAccount({ cfg: ctx.cfg, accountId: ctx.accountId });
+      const accountId = account.accountId;
       const port = account.config?.webhookPort ?? null;
-      ctx.setStatus({ accountId: ctx.accountId, port });
+      ctx.setStatus({ accountId, port });
       ctx.log?.info(
-        `starting feishu[${ctx.accountId}] (mode: ${account.config?.connectionMode ?? "websocket"})`,
+        `starting feishu[${accountId}] (mode: ${account.config?.connectionMode ?? "websocket"})`,
       );
-      return monitorFeishuProvider({
-        config: ctx.cfg,
-        runtime: ctx.runtime,
-        abortSignal: ctx.abortSignal,
-        accountId: ctx.accountId,
-      });
+
+      // Start the long-running monitor in the background so service startup can continue
+      // into ChannelManager.startAll() for other channels.
+      const monitorTask = (async () => {
+        try {
+          await monitorFeishuProvider({
+            config: ctx.cfg,
+            runtime: ctx.runtime,
+            abortSignal: ctx.abortSignal,
+            accountId,
+          });
+        } catch (error) {
+          if (ctx.abortSignal?.aborted) {
+            return;
+          }
+          const message = error instanceof Error ? error.stack ?? error.message : String(error);
+          ctx.log?.error?.(`feishu[${accountId}]: gateway monitor stopped unexpectedly: ${message}`);
+        }
+      })();
+
+      return {
+        stop: async () => {
+          stopFeishuMonitor(accountId);
+          await monitorTask;
+        },
+      };
     },
   },
 };