libp2p-mesh 2026.5.12 → 2026.5.13

package/src/feishu-client.test.ts

@@ -0,0 +1,303 @@
+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: FeishuApiClient;
+
+  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 as ReturnType<typeof vi.fn>).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 as ReturnType<typeof vi.fn>).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/src/feishu-client.ts

@@ -0,0 +1,178 @@
+import type { FeishuChannelConfig, FeishuTokenResponse, FeishuSendMessageResponse } 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;
+}
+
+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 {
+  private config: FeishuChannelConfig;
+  private logger?: FeishuApiClientDeps["logger"];
+  private cachedToken: string | null = null;
+  private cachedExpiresAt: number = 0;
+  private tokenPromise: Promise<string> | null = null;
+
+  constructor(config: FeishuChannelConfig, deps?: FeishuApiClientDeps) {
+    this.config = config;
+    this.logger = deps?.logger;
+  }
+
+  isConfigured(): boolean {
+    return Boolean(this.config.appId && this.config.appSecret);
+  }
+
+  async getTenantAccessToken(): Promise<string> {
+    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: string, text: string): Promise<SendResult> {
+    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 };
+    }
+  }
+
+  private async fetchTenantAccessToken(): Promise<string> {
+    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()) as FeishuTokenResponse;
+
+      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;
+    }
+  }
+
+  private async doSendMessage(token: string, openId: string, text: string): Promise<SendResult> {
+    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 };
+    }
+  }
+
+  private async callSendApi(token: string, openId: string, text: string): Promise<FeishuSendMessageResponse> {
+    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()) as FeishuSendMessageResponse;
+  }
+}

package/src/feishu-e2e.test.ts

@@ -0,0 +1,90 @@
+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";
+import type { P2PMessage } from "./types.js";
+import { InboundHandlerDeps } from "./inbound.js";
+import { FeishuApiClient } from "./feishu-client.js";
+
+const MOCK_CONFIG = {
+  appId: "cli-e2e-test",
+  appSecret: "secret-e2e",
+  webhookPort: 9222,
+  webhookPath: "/webhook/feishu",
+};
+
+describe("Feishu E2E integration", () => {
+  let mockClient: any;
+
+  beforeEach(() => {
+    mockClient = {
+      isConfigured: () => true,
+      getTenantAccessToken: vi.fn().mockResolvedValue("t-e2e"),
+      sendMessage: vi.fn(),
+    } as unknown as FeishuApiClient;
+  });
+
+  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 as any).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: InboundHandlerDeps = {
+      feishuClient: mockClient as any,
+    };
+
+    const p2pMsg: P2PMessage = {
+      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 as any },
+    );
+
+    await vi.waitFor(() => expect(mockClient.sendMessage).toHaveBeenCalledTimes(1));
+    expect(mockClient.sendMessage).toHaveBeenCalledWith(expect.any(String), "系统维护通知");
+  });
+});

package/src/feishu-types.test.ts

@@ -0,0 +1,125 @@
+import { describe, it, expect } from "vitest";
+import type {
+  FeishuChannelConfig,
+  FeishuWebhookEvent,
+  FeishuSendMessageRequest,
+  FeishuSendMessageResponse,
+  FeishuTokenResponse,
+} from "./feishu-types.js";
+
+describe("FeishuChannelConfig", () => {
+  it("should have correct default values", () => {
+    const config: FeishuChannelConfig = {
+      appId: "test-app-id",
+      appSecret: "test-secret",
+      webhookPort: 9222,
+      webhookPath: "/webhook/feishu",
+    };
+    expect(config.webhookPort).toBe(9222);
+    expect(config.webhookPath).toBe("/webhook/feishu");
+  });
+});
+
+describe("FeishuWebhookEvent", () => {
+  const sampleEvent: FeishuWebhookEvent = {
+    schema: "2.0",
+    header: {
+      eventId: "event-123",
+      eventType: "im.message.receive_v1",
+      createTime: "1234567890000",
+      token: "verification-token",
+      appId: "app-123",
+      tenantKey: "tenant-123",
+    },
+    event: {
+      sender: { senderId: { openId: "ou-abc123" } },
+      message: {
+        messageId: "msg-123",
+        msgType: "text",
+        createTime: "1234567890000",
+        chatId: "chat-123",
+        chatType: "p2p",
+        content: '{"text":"hello"}',
+      },
+    },
+  };
+
+  it("should parse header fields correctly", () => {
+    expect(sampleEvent.header.eventId).toBe("event-123");
+    expect(sampleEvent.header.eventType).toBe("im.message.receive_v1");
+    expect(sampleEvent.header.appId).toBe("app-123");
+  });
+
+  it("should extract openId from sender", () => {
+    expect(sampleEvent.event.sender.senderId.openId).toBe("ou-abc123");
+  });
+
+  it("should parse message fields correctly", () => {
+    expect(sampleEvent.event.message.messageId).toBe("msg-123");
+    expect(sampleEvent.event.message.msgType).toBe("text");
+    expect(sampleEvent.event.message.chatType).toBe("p2p");
+    expect(sampleEvent.event.message.content).toBe('{"text":"hello"}');
+  });
+
+  it("should support optional message fields", () => {
+    const withOptional: FeishuWebhookEvent = {
+      ...sampleEvent,
+      event: {
+        ...sampleEvent.event,
+        message: {
+          ...sampleEvent.event.message,
+          rootId: "msg-root",
+          parentId: "msg-parent",
+        },
+      },
+    };
+    expect(withOptional.event.message.rootId).toBe("msg-root");
+    expect(withOptional.event.message.parentId).toBe("msg-parent");
+  });
+});
+
+describe("FeishuSendMessageRequest", () => {
+  it("should require receiveId, receiveIdType, msgType, content", () => {
+    const req: FeishuSendMessageRequest = {
+      receiveId: "ou-abc123",
+      receiveIdType: "openId",
+      msgType: "text",
+      content: '{"text":"hello"}',
+    };
+    expect(req.receiveId).toBe("ou-abc123");
+  });
+});
+
+describe("FeishuSendMessageResponse", () => {
+  it("should parse success response", () => {
+    const resp: FeishuSendMessageResponse = {
+      code: 0,
+      msg: "success",
+      data: { messageId: "msg-sent-123" },
+    };
+    expect(resp.code).toBe(0);
+    expect(resp.data.messageId).toBe("msg-sent-123");
+  });
+
+  it("should parse error response", () => {
+    const resp: FeishuSendMessageResponse = {
+      code: 99991663,
+      msg: "token invalid",
+      data: { messageId: "" },
+    };
+    expect(resp.code).toBe(99991663);
+  });
+});
+
+describe("FeishuTokenResponse", () => {
+  it("should parse token response", () => {
+    const resp: FeishuTokenResponse = {
+      code: 0,
+      msg: "ok",
+      tenant_access_token: "t-abc123",
+      expire: 7200,
+    };
+    expect(resp.tenant_access_token).toBe("t-abc123");
+    expect(resp.expire).toBe(7200);
+  });
+});