libp2p-mesh 2026.5.12 → 2026.5.13

package/dist/src/feishu-channel.test.js

@@ -0,0 +1,166 @@
+import { describe, it, expect, vi } from "vitest";
+import { createFeishuChannel, handleFeishuWebhook } from "./feishu-channel.js";
+const MOCK_CONFIG = {
+    appId: "test-app-id",
+    appSecret: "test-app-secret",
+    webhookPort: 9222,
+    webhookPath: "/webhook/feishu",
+};
+const MOCK_CLIENT = {
+    isConfigured: () => true,
+    getTenantAccessToken: vi.fn().mockResolvedValue("t-valid"),
+    sendMessage: vi.fn().mockResolvedValue({ success: true, messageId: "msg-123" }),
+};
+describe("createFeishuChannel", () => {
+    it("should return a ChannelPlugin with correct base properties", () => {
+        const channel = createFeishuChannel(MOCK_CONFIG, {}, MOCK_CLIENT);
+        expect(channel.base.id).toBe("feishu");
+        expect(channel.base.meta.label).toBe("Feishu");
+        expect(channel.base.capabilities.chatTypes).toEqual(["direct"]);
+    });
+    it("should set targetResolver hint to openId", () => {
+        const channel = createFeishuChannel(MOCK_CONFIG, {}, MOCK_CLIENT);
+        const messaging = channel.base.messaging;
+        const resolver = messaging.targetResolver;
+        expect(resolver.hint).toBe("openId");
+    });
+    it("should set deliveryMode to gateway", () => {
+        const channel = createFeishuChannel(MOCK_CONFIG, {}, MOCK_CLIENT);
+        const outbound = channel.base.outbound;
+        expect(outbound?.deliveryMode).toBe("gateway");
+    });
+    it("should delegate sendText to feishuClient", async () => {
+        const channel = createFeishuChannel(MOCK_CONFIG, {}, MOCK_CLIENT);
+        const outbound = channel.base.outbound;
+        const result = await outbound.sendText({ to: "ou-user", text: "hello" });
+        expect(result.channel).toBe("feishu");
+        expect(result.messageId).toBe("msg-123");
+        expect(MOCK_CLIENT.sendMessage).toHaveBeenCalledWith("ou-user", "hello");
+    });
+    it("should return error meta when sendMessage fails", async () => {
+        const failClient = {
+            ...MOCK_CLIENT,
+            sendMessage: vi.fn().mockResolvedValue({ success: false, error: "API error" }),
+        };
+        const channel = createFeishuChannel(MOCK_CONFIG, {}, failClient);
+        const outbound = channel.base.outbound;
+        const result = await outbound.sendText({ to: "ou-user", text: "hello" });
+        expect("meta" in result && result.meta?.error).toBe("API error");
+    });
+    it("should reflect configured status from feishuClient", () => {
+        const channel = createFeishuChannel(MOCK_CONFIG, {}, MOCK_CLIENT);
+        const config = channel.base.config;
+        expect(config.isConfigured()).toBe(true);
+    });
+});
+describe("handleFeishuWebhook", () => {
+    it("should respond to challenge verification", async () => {
+        const { handler } = handleFeishuWebhook(MOCK_CONFIG, MOCK_CLIENT, {});
+        const req = new Request("http://localhost:9222/webhook/feishu?challenge=abc123");
+        const resp = await handler(req);
+        const body = (await resp.json());
+        expect(body.challenge).toBe("abc123");
+    });
+    it("should reject request with invalid signature", async () => {
+        const { handler } = handleFeishuWebhook(MOCK_CONFIG, MOCK_CLIENT, {});
+        const req = new Request("http://localhost:9222/webhook/feishu", {
+            method: "POST",
+            headers: { "x-lark-signature": "invalid-sig" },
+            body: JSON.stringify({ type: "url_verification" }),
+        });
+        const resp = await handler(req);
+        expect(resp.status).toBe(400);
+    });
+    it("should extract openId and message from im.message.receive_v1 event", async () => {
+        const { handler } = handleFeishuWebhook(MOCK_CONFIG, MOCK_CLIENT, {});
+        const eventBody = {
+            schema: "2.0",
+            header: {
+                eventId: "evt-1",
+                eventType: "im.message.receive_v1",
+                createTime: "1234567890000",
+                token: "v-token",
+                appId: "app-123",
+                tenantKey: "tk-123",
+            },
+            event: {
+                sender: { senderId: { openId: "ou-sender-1" } },
+                message: {
+                    messageId: "msg-1",
+                    msgType: "text",
+                    createTime: "1234567890000",
+                    chatId: "chat-1",
+                    chatType: "p2p",
+                    content: '{"text":"hello from feishu"}',
+                },
+            },
+        };
+        const body = JSON.stringify(eventBody);
+        const sig = 'Tk4MriFS/RRZ9zfM0EHVMKk45vyHMPqTNwc6stjTOxo=';
+        const req = new Request("http://localhost:9222/webhook/feishu", {
+            method: "POST",
+            headers: { "content-type": "application/json", "x-lark-signature": sig },
+            body,
+        });
+        const resp = await handler(req);
+        expect(resp.status).toBe(200);
+    });
+    it("should ignore non-im.message.receive_v1 events", async () => {
+        const { handler } = handleFeishuWebhook(MOCK_CONFIG, MOCK_CLIENT, {});
+        const eventBody = {
+            schema: "2.0",
+            header: {
+                eventId: "evt-2",
+                eventType: "im.chat.member.bot.added_v1",
+                createTime: "1234567890000",
+                token: "v-token",
+                appId: "app-123",
+                tenantKey: "tk-123",
+            },
+            event: {},
+        };
+        const body = JSON.stringify(eventBody);
+        const sig = 'fS/7P4Dm1/UjN5vIolDq4Vgc8welngorAiRmo6tk4H8=';
+        const req = new Request("http://localhost:9222/webhook/feishu", {
+            method: "POST",
+            headers: { "content-type": "application/json", "x-lark-signature": sig },
+            body,
+        });
+        const resp = await handler(req);
+        expect(resp.status).toBe(200);
+    });
+    it("should extract plain text from JSON content field", async () => {
+        const { handler } = handleFeishuWebhook(MOCK_CONFIG, MOCK_CLIENT, {});
+        const eventBody = {
+            schema: "2.0",
+            header: {
+                eventId: "evt-3",
+                eventType: "im.message.receive_v1",
+                createTime: "1234567890000",
+                token: "v-token",
+                appId: "app-123",
+                tenantKey: "tk-123",
+            },
+            event: {
+                sender: { senderId: { openId: "ou-sender" } },
+                message: {
+                    messageId: "msg-3",
+                    msgType: "text",
+                    createTime: "1234567890000",
+                    chatId: "chat-1",
+                    chatType: "p2p",
+                    content: '{"text":"邀请用户B吃饭"}',
+                },
+            },
+        };
+        const body = JSON.stringify(eventBody);
+        const sig = 'cV4wR/Bd4TkU7oaZJis9LNpBTFWEjRRkGdpkNeljEi8=';
+        const req = new Request("http://localhost:9222/webhook/feishu", {
+            method: "POST",
+            headers: { "content-type": "application/json", "x-lark-signature": sig },
+            body,
+        });
+        const resp = await handler(req);
+        expect(resp.status).toBe(200);
+    });
+});

package/dist/src/feishu-client.d.ts

@@ -0,0 +1,27 @@
+import type { FeishuChannelConfig } from "./feishu-types.js";
+export interface FeishuApiClientDeps {
+    logger?: {
+        info?: (msg: string) => void;
+        warn?: (msg: string) => void;
+        error?: (msg: string) => void;
+    };
+}
+export interface SendResult {
+    success: boolean;
+    messageId?: string;
+    error?: string;
+}
+export declare class FeishuApiClient {
+    private config;
+    private logger?;
+    private cachedToken;
+    private cachedExpiresAt;
+    private tokenPromise;
+    constructor(config: FeishuChannelConfig, deps?: FeishuApiClientDeps);
+    isConfigured(): boolean;
+    getTenantAccessToken(): Promise<string>;
+    sendMessage(openId: string, text: string): Promise<SendResult>;
+    private fetchTenantAccessToken;
+    private doSendMessage;
+    private callSendApi;
+}

package/dist/src/feishu-client.js

@@ -0,0 +1,141 @@
+const TOKEN_URL = "https://open.feishu.cn/open-apis/auth/v3/tenant_access_token/internal";
+const SEND_URL = "https://open.feishu.cn/open-apis/im/v1/messages?receive_id_type=openId";
+const REFRESH_MARGIN_MS = 5 * 60 * 1000; // 5 minutes
+const REQUEST_TIMEOUT_MS = 10_000;
+export class FeishuApiClient {
+    config;
+    logger;
+    cachedToken = null;
+    cachedExpiresAt = 0;
+    tokenPromise = null;
+    constructor(config, deps) {
+        this.config = config;
+        this.logger = deps?.logger;
+    }
+    isConfigured() {
+        return Boolean(this.config.appId && this.config.appSecret);
+    }
+    async getTenantAccessToken() {
+        if (!this.isConfigured()) {
+            throw new Error("Feishu client not configured: appId and appSecret required");
+        }
+        // Return cached token if still valid (with 5-minute margin)
+        if (this.cachedToken && Date.now() < this.cachedExpiresAt - REFRESH_MARGIN_MS) {
+            return this.cachedToken;
+        }
+        // Dedup concurrent requests
+        if (this.tokenPromise) {
+            return this.tokenPromise;
+        }
+        this.tokenPromise = this.fetchTenantAccessToken();
+        try {
+            return await this.tokenPromise;
+        }
+        finally {
+            this.tokenPromise = null;
+        }
+    }
+    async sendMessage(openId, text) {
+        if (!this.isConfigured()) {
+            return { success: false, error: "Feishu client not configured" };
+        }
+        try {
+            const token = await this.getTenantAccessToken();
+            return await this.doSendMessage(token, openId, text);
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            this.logger?.error?.(`sendMessage error: ${message}`);
+            return { success: false, error: message };
+        }
+    }
+    async fetchTenantAccessToken() {
+        try {
+            const response = await fetch(TOKEN_URL, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    app_id: this.config.appId,
+                    app_secret: this.config.appSecret,
+                }),
+                signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+            });
+            if (!response.ok) {
+                throw new Error(`Token API returned status ${response.status}`);
+            }
+            const data = (await response.json());
+            if (data.code !== 0 || !data.tenant_access_token) {
+                throw new Error(`Token API error: code=${data.code}, msg=${data.msg}`);
+            }
+            this.cachedToken = data.tenant_access_token;
+            // expire is in seconds; convert to ms and set absolute expiry time
+            this.cachedExpiresAt = Date.now() + data.expire * 1000;
+            this.logger?.info?.(`Fetched new tenant_access_token, expires in ${data.expire}s`);
+            return this.cachedToken;
+        }
+        catch (err) {
+            // Clear stale cache on failure
+            this.cachedToken = null;
+            this.cachedExpiresAt = 0;
+            throw err;
+        }
+    }
+    async doSendMessage(token, openId, text) {
+        try {
+            const result = await this.callSendApi(token, openId, text);
+            // 99991663 = token invalid/expired — refresh and retry once
+            if (result.code === 99991663) {
+                this.logger?.warn?.("sendMessage got 99991663, refreshing token and retrying");
+                // Force token refresh by clearing cache
+                this.cachedToken = null;
+                this.cachedExpiresAt = 0;
+                const newToken = await this.getTenantAccessToken();
+                const retryResult = await this.callSendApi(newToken, openId, text);
+                if (retryResult.code !== 0) {
+                    return {
+                        success: false,
+                        error: `Feishu API error after retry: code=${retryResult.code}, msg=${retryResult.msg}`,
+                    };
+                }
+                return {
+                    success: true,
+                    messageId: retryResult.data?.messageId,
+                };
+            }
+            if (result.code !== 0) {
+                return {
+                    success: false,
+                    error: `Feishu API error: code=${result.code}, msg=${result.msg}`,
+                };
+            }
+            return {
+                success: true,
+                messageId: result.data?.messageId,
+            };
+        }
+        catch (err) {
+            const message = err instanceof Error ? err.message : String(err);
+            this.logger?.error?.(`sendMessage API call failed: ${message}`);
+            return { success: false, error: message };
+        }
+    }
+    async callSendApi(token, openId, text) {
+        const response = await fetch(SEND_URL, {
+            method: "POST",
+            headers: {
+                "Content-Type": "application/json",
+                Authorization: `Bearer ${token}`,
+            },
+            body: JSON.stringify({
+                receive_id: openId,
+                msg_type: "text",
+                content: JSON.stringify({ text }),
+            }),
+            signal: AbortSignal.timeout(REQUEST_TIMEOUT_MS),
+        });
+        if (!response.ok) {
+            throw new Error(`Send message API returned status ${response.status}`);
+        }
+        return (await response.json());
+    }
+}

package/dist/src/feishu-client.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/feishu-client.test.js

@@ -0,0 +1,271 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { FeishuApiClient } from "./feishu-client.js";
+const MOCK_CONFIG = {
+    appId: "test-app-id",
+    appSecret: "test-app-secret",
+    webhookPort: 9222,
+    webhookPath: "/webhook/feishu",
+};
+describe("FeishuApiClient", () => {
+    let client;
+    beforeEach(() => {
+        client = new FeishuApiClient(MOCK_CONFIG);
+    });
+    describe("isConfigured", () => {
+        it("should return true when appId and appSecret are set", () => {
+            expect(client.isConfigured()).toBe(true);
+        });
+        it("should return false when appId is empty", () => {
+            const unconfigured = new FeishuApiClient({
+                ...MOCK_CONFIG,
+                appId: "",
+            });
+            expect(unconfigured.isConfigured()).toBe(false);
+        });
+        it("should return false when appSecret is empty", () => {
+            const unconfigured = new FeishuApiClient({
+                ...MOCK_CONFIG,
+                appSecret: "",
+            });
+            expect(unconfigured.isConfigured()).toBe(false);
+        });
+    });
+    describe("getTenantAccessToken", () => {
+        it("should fetch and cache tenant_access_token", async () => {
+            global.fetch = vi.fn().mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({
+                    code: 0,
+                    tenant_access_token: "t-cached-token",
+                    expire: 7200,
+                }),
+            });
+            const token = await client.getTenantAccessToken();
+            expect(token).toBe("t-cached-token");
+            expect(global.fetch).toHaveBeenCalledTimes(1);
+        });
+        it("should return cached token on second call without new API request", async () => {
+            global.fetch = vi.fn().mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({
+                    code: 0,
+                    tenant_access_token: "t-cached-token",
+                    expire: 7200,
+                }),
+            });
+            await client.getTenantAccessToken();
+            await client.getTenantAccessToken();
+            expect(global.fetch).toHaveBeenCalledTimes(1);
+        });
+        it("should refresh token when expired", async () => {
+            global.fetch = vi.fn()
+                .mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve({
+                    code: 0,
+                    tenant_access_token: "t-first-token",
+                    expire: 1,
+                }),
+            })
+                .mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve({
+                    code: 0,
+                    tenant_access_token: "t-refreshed-token",
+                    expire: 7200,
+                }),
+            });
+            const first = await client.getTenantAccessToken();
+            await new Promise((r) => setTimeout(r, 1100));
+            const second = await client.getTenantAccessToken();
+            expect(first).toBe("t-first-token");
+            expect(second).toBe("t-refreshed-token");
+            expect(global.fetch).toHaveBeenCalledTimes(2);
+        });
+        it("should refresh token when expiring within 5 minutes", async () => {
+            const now = Date.now();
+            global.fetch = vi.fn()
+                .mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve({
+                    code: 0,
+                    tenant_access_token: "t-near-expiry",
+                    expire: 300,
+                }),
+            })
+                .mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve({
+                    code: 0,
+                    tenant_access_token: "t-refreshed-early",
+                    expire: 7200,
+                }),
+            });
+            const first = await client.getTenantAccessToken();
+            // expire=300 means expiresAt = now + 300000ms.
+            // Since expiresAt - now = 300000 < 5*60*1000, next call should refresh.
+            const second = await client.getTenantAccessToken();
+            expect(first).toBe("t-near-expiry");
+            expect(second).toBe("t-refreshed-early");
+            expect(global.fetch).toHaveBeenCalledTimes(2);
+        });
+        it("should handle token API failure gracefully", async () => {
+            global.fetch = vi.fn().mockResolvedValue({
+                ok: false,
+                status: 500,
+            });
+            await expect(client.getTenantAccessToken()).rejects.toThrow();
+        });
+        it("should deduplicate concurrent token requests", async () => {
+            global.fetch = vi.fn().mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({
+                    code: 0,
+                    tenant_access_token: "t-dedup-token",
+                    expire: 7200,
+                }),
+            });
+            const [t1, t2] = await Promise.all([
+                client.getTenantAccessToken(),
+                client.getTenantAccessToken(),
+            ]);
+            expect(t1).toBe("t-dedup-token");
+            expect(t2).toBe("t-dedup-token");
+            expect(global.fetch).toHaveBeenCalledTimes(1);
+        });
+    });
+    describe("sendMessage", () => {
+        it("should send message and return messageId", async () => {
+            global.fetch = vi.fn()
+                .mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve({
+                    code: 0,
+                    tenant_access_token: "t-valid",
+                    expire: 7200,
+                }),
+            })
+                .mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve({
+                    code: 0,
+                    data: { messageId: "msg-sent-456" },
+                }),
+            });
+            const result = await client.sendMessage("ou-recipient", "hello world");
+            expect(result.success).toBe(true);
+            expect(result.messageId).toBe("msg-sent-456");
+        });
+        it("should return error result on API failure", async () => {
+            global.fetch = vi.fn().mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({
+                    code: 99991663,
+                    msg: "token invalid",
+                }),
+            });
+            const result = await client.sendMessage("ou-recipient", "hello");
+            expect(result.success).toBe(false);
+            expect(result.error).toBeDefined();
+        });
+        it("should retry once after token refresh on 99991663 error", async () => {
+            global.fetch = vi.fn()
+                .mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve({
+                    code: 0,
+                    tenant_access_token: "t-expired",
+                    expire: 7200,
+                }),
+            })
+                .mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve({
+                    code: 99991663,
+                    msg: "token invalid",
+                    data: { messageId: "" },
+                }),
+            })
+                .mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve({
+                    code: 0,
+                    tenant_access_token: "t-new-token",
+                    expire: 7200,
+                }),
+            })
+                .mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve({
+                    code: 0,
+                    data: { messageId: "msg-retry-success" },
+                }),
+            });
+            const result = await client.sendMessage("ou-recipient", "hello");
+            expect(result.success).toBe(true);
+            expect(result.messageId).toBe("msg-retry-success");
+        });
+        it("should handle network errors gracefully", async () => {
+            global.fetch = vi.fn().mockRejectedValue(new Error("ECONNREFUSED"));
+            const result = await client.sendMessage("ou-recipient", "hello");
+            expect(result.success).toBe(false);
+            expect(result.error).toContain("ECONNREFUSED");
+        });
+        it("should serialize content as JSON string", async () => {
+            global.fetch = vi.fn()
+                .mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve({
+                    code: 0,
+                    tenant_access_token: "t-valid",
+                    expire: 7200,
+                }),
+            })
+                .mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve({
+                    code: 0,
+                    data: { message_id: "msg-json-test" },
+                }),
+            });
+            await client.sendMessage("ou-recipient", "plain text");
+            const secondCall = global.fetch.mock.calls[1];
+            const body = JSON.parse(secondCall[1].body);
+            expect(body.content).toBe(JSON.stringify({ text: "plain text" }));
+        });
+        it("should use Authorization Bearer header with token", async () => {
+            global.fetch = vi.fn()
+                .mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve({
+                    code: 0,
+                    tenant_access_token: "t-header-test",
+                    expire: 7200,
+                }),
+            })
+                .mockResolvedValueOnce({
+                ok: true,
+                json: () => Promise.resolve({
+                    code: 0,
+                    data: { message_id: "msg-header-test" },
+                }),
+            });
+            await client.sendMessage("ou-recipient", "hello");
+            const secondCall = global.fetch.mock.calls[1];
+            expect(secondCall[1].headers.Authorization).toBe("Bearer t-header-test");
+        });
+        it("should not retry on non-99991663 API error", async () => {
+            global.fetch = vi.fn().mockResolvedValue({
+                ok: true,
+                json: () => Promise.resolve({
+                    code: 99991400,
+                    msg: "invalid parameter",
+                }),
+            });
+            const result = await client.sendMessage("ou-recipient", "hello");
+            expect(result.success).toBe(false);
+            expect(result.error).toContain("invalid parameter");
+            expect(global.fetch).toHaveBeenCalledTimes(1);
+        });
+    });
+});

package/dist/src/feishu-e2e.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/src/feishu-e2e.test.js

@@ -0,0 +1,69 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { createFeishuChannel } from "./feishu-channel.js";
+import { buildFeishuTools } from "./agent-tools.js";
+import { handleP2PInbound } from "./inbound.js";
+const MOCK_CONFIG = {
+    appId: "cli-e2e-test",
+    appSecret: "secret-e2e",
+    webhookPort: 9222,
+    webhookPath: "/webhook/feishu",
+};
+describe("Feishu E2E integration", () => {
+    let mockClient;
+    beforeEach(() => {
+        mockClient = {
+            isConfigured: () => true,
+            getTenantAccessToken: vi.fn().mockResolvedValue("t-e2e"),
+            sendMessage: vi.fn(),
+        };
+    });
+    it("should handle full flow: channel -> agent tool -> Feishu API", async () => {
+        mockClient.sendMessage.mockResolvedValueOnce({
+            success: true,
+            messageId: "msg-agent-sent",
+        });
+        // 1. Create channel and verify it is configured
+        const channel = createFeishuChannel(MOCK_CONFIG, {}, mockClient);
+        expect(channel.base.config.isConfigured()).toBe(true);
+        // 2. Agent tool is available
+        const tools = buildFeishuTools(mockClient);
+        expect(tools).toHaveLength(1);
+        // 3. Agent sends message via tool
+        const toolResult = await tools[0].execute("call-1", {
+            openId: "ou-e2e-recipient",
+            message: "hello from agent",
+        });
+        expect(toolResult.isError).toBeUndefined();
+        expect(toolResult.details.sent).toBe(true);
+        expect(mockClient.sendMessage).toHaveBeenCalledWith("ou-e2e-recipient", "hello from agent");
+    });
+    it("should forward P2P message to Feishu via inbound handler", async () => {
+        mockClient.sendMessage.mockResolvedValue({ success: true });
+        const deps = {
+            feishuClient: mockClient,
+        };
+        const p2pMsg = {
+            id: "p2p-msg-1",
+            type: "direct",
+            from: "peer-x",
+            payload: "用户A邀请你吃饭",
+            timestamp: Date.now(),
+        };
+        handleP2PInbound(p2pMsg, deps);
+        await vi.waitFor(() => expect(mockClient.sendMessage).toHaveBeenCalledTimes(1));
+        expect(mockClient.sendMessage).toHaveBeenCalledWith(expect.any(String), "用户A邀请你吃饭");
+    });
+    it("should handle broadcast messages in inbound forwarding", async () => {
+        mockClient.sendMessage.mockResolvedValue({ success: true });
+        handleP2PInbound({
+            id: "bc-1",
+            type: "broadcast",
+            from: "peer-y",
+            topic: "announcements",
+            payload: "系统维护通知",
+            timestamp: Date.now(),
+        }, { feishuClient: mockClient });
+        await vi.waitFor(() => expect(mockClient.sendMessage).toHaveBeenCalledTimes(1));
+        expect(mockClient.sendMessage).toHaveBeenCalledWith(expect.any(String), "系统维护通知");
+    });
+});