libp2p-mesh 2026.5.12 → 2026.5.13

package/src/config-schema.test.ts

@@ -0,0 +1,63 @@
+import { describe, it, expect } from "vitest";
+import { createLibp2pMeshConfigSchema } from "./index.js";
+
+describe("createLibp2pMeshConfigSchema - Feishu config", () => {
+  const schema = createLibp2pMeshConfigSchema()!;
+
+  it("should include feishu in jsonSchema properties", () => {
+    const props = (schema as any).jsonSchema.properties as Record<string, any>;
+    expect(props).toHaveProperty("feishu");
+  });
+
+  it("feishu should be an object type with correct properties", () => {
+    const props = (schema as any).jsonSchema.properties as Record<string, any>;
+    const feishu = props.feishu;
+    expect(feishu.type).toBe("object");
+    expect(feishu.properties).toHaveProperty("appId");
+    expect(feishu.properties).toHaveProperty("appSecret");
+    expect(feishu.properties).toHaveProperty("webhookPort");
+    expect(feishu.properties).toHaveProperty("webhookPath");
+  });
+
+  it("feishu.webhookPort should default to 9222", () => {
+    const props = (schema as any).jsonSchema.properties as Record<string, any>;
+    expect(props.feishu.properties.webhookPort.default).toBe(9222);
+  });
+
+  it("feishu.webhookPath should default to /webhook/feishu", () => {
+    const props = (schema as any).jsonSchema.properties as Record<string, any>;
+    expect(props.feishu.properties.webhookPath.default).toBe("/webhook/feishu");
+  });
+
+  it("feishu.appId and appSecret should be string type without default", () => {
+    const props = (schema as any).jsonSchema.properties as Record<string, any>;
+    expect(props.feishu.properties.appId.type).toBe("string");
+    expect(props.feishu.properties.appSecret.type).toBe("string");
+    expect(props.feishu.properties.appId.default).toBeUndefined();
+    expect(props.feishu.properties.appSecret.default).toBeUndefined();
+  });
+
+  it("should parse config with feishu fields", () => {
+    const result = (schema as any).safeParse({
+      listenAddrs: ["/ip4/0.0.0.0/tcp/0"],
+      feishu: {
+        appId: "cli-123",
+        appSecret: "secret-456",
+        webhookPort: 9999,
+        webhookPath: "/custom/path",
+      },
+    });
+    expect(result.success).toBe(true);
+    if (result.success) {
+      expect(result.data.feishu.appId).toBe("cli-123");
+      expect(result.data.feishu.webhookPort).toBe(9999);
+    }
+  });
+
+  it("should parse config without feishu (feishu is optional)", () => {
+    const result = (schema as any).safeParse({
+      listenAddrs: ["/ip4/0.0.0.0/tcp/0"],
+    });
+    expect(result.success).toBe(true);
+  });
+});

package/src/feishu-channel.test.ts

@@ -0,0 +1,191 @@
+import { describe, it, expect, vi } from "vitest";
+import { createFeishuChannel, handleFeishuWebhook } from "./feishu-channel.js";
+import type { FeishuChannelConfig } from "./feishu-types.js";
+import type { FeishuApiClient, SendResult } from "./feishu-client.js";
+
+const MOCK_CONFIG: FeishuChannelConfig = {
+  appId: "test-app-id",
+  appSecret: "test-app-secret",
+  webhookPort: 9222,
+  webhookPath: "/webhook/feishu",
+};
+
+const MOCK_CLIENT: FeishuApiClient = {
+  isConfigured: () => true,
+  getTenantAccessToken: vi.fn().mockResolvedValue("t-valid"),
+  sendMessage: vi.fn().mockResolvedValue({ success: true, messageId: "msg-123" }),
+} as unknown as FeishuApiClient;
+
+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 as Record<string, string>).label).toBe("Feishu");
+    expect((channel.base.capabilities as Record<string, unknown>).chatTypes).toEqual(["direct"]);
+  });
+
+  it("should set targetResolver hint to openId", () => {
+    const channel = createFeishuChannel(MOCK_CONFIG, {}, MOCK_CLIENT);
+    const messaging = channel.base.messaging as Record<string, unknown>;
+    const resolver = messaging.targetResolver as Record<string, unknown>;
+    expect(resolver.hint).toBe("openId");
+  });
+
+  it("should set deliveryMode to gateway", () => {
+    const channel = createFeishuChannel(MOCK_CONFIG, {}, MOCK_CLIENT);
+    const outbound = channel.base.outbound as Record<string, string> | undefined;
+    expect(outbound?.deliveryMode).toBe("gateway");
+  });
+
+  it("should delegate sendText to feishuClient", async () => {
+    const channel = createFeishuChannel(MOCK_CONFIG, {}, MOCK_CLIENT);
+    const outbound = channel.base.outbound as {
+      sendText: (params: { to: string; text: string }) => Promise<
+        { channel: string; messageId: string } |
+        { channel: string; messageId: string; meta: { error: string } }
+      >;
+    };
+    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" }),
+    } as unknown as FeishuApiClient;
+    const channel = createFeishuChannel(MOCK_CONFIG, {}, failClient);
+    const outbound = channel.base.outbound as {
+      sendText: (params: { to: string; text: string }) => Promise<
+        { channel: string; messageId: string } |
+        { channel: string; messageId: string; meta: { error: string } }
+      >;
+    };
+    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 as { isConfigured: () => boolean };
+    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()) as { challenge: string };
+    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/src/feishu-channel.ts

@@ -0,0 +1,253 @@
+import { createChatChannelPlugin } from "openclaw/plugin-sdk/core";
+import type { ChannelPlugin } from "openclaw/plugin-sdk/core";
+import { createHmac } from "node:crypto";
+import { FeishuApiClient } from "./feishu-client.js";
+import type { FeishuChannelConfig } from "./feishu-types.js";
+
+export interface FeishuChannelDeps {
+  logger?: {
+    info?: (msg: string) => void;
+    warn?: (msg: string) => void;
+    error?: (msg: string) => void;
+  };
+}
+
+/** Plugin type with a base wrapper for test compatibility */
+export interface FeishuChannelPlugin extends ChannelPlugin {
+  base: Record<string, unknown>;
+}
+
+export function createFeishuChannel(
+  config: FeishuChannelConfig,
+  deps?: FeishuChannelDeps,
+  feishuClient?: FeishuApiClient,
+): FeishuChannelPlugin {
+  const client = feishuClient ?? new FeishuApiClient(config, deps);
+
+  const raw = createChatChannelPlugin<{ accountId?: string }>({
+    base: {
+      id: "feishu",
+      meta: {
+        id: "feishu",
+        label: "Feishu",
+        selectionLabel: "Feishu",
+        docsPath: "/channels/feishu",
+        docsLabel: "feishu",
+        blurb: "Feishu integration for user interaction.",
+        systemImage: "message" as string | undefined,
+      },
+      capabilities: {
+        chatTypes: ["direct"],
+        media: false,
+        blockStreaming: true,
+      },
+      configSchema: {
+        schema: {
+          type: "object",
+          additionalProperties: false,
+          properties: {
+            appId: { type: "string" },
+            appSecret: { type: "string" },
+            webhookPort: { type: "number" },
+            webhookPath: { type: "string" },
+          },
+        },
+      },
+      config: {
+        listAccountIds: () => ["default"],
+        resolveAccount: () => ({
+          accountId: "default",
+          configured: client.isConfigured(),
+          enabled: true,
+        }),
+        isConfigured: () => client.isConfigured(),
+        isEnabled: () => true,
+        describeAccount: () => ({
+          accountId: "default",
+          name: "default",
+          configured: client.isConfigured(),
+          enabled: true,
+        }),
+      },
+      messaging: {
+        normalizeTarget: (raw: string) => raw.trim(),
+        targetResolver: {
+          looksLikeId: () => true,
+          hint: "openId",
+        },
+      },
+    },
+    outbound: {
+      deliveryMode: "gateway",
+      sendText: async ({ to, text }) => {
+        try {
+          const result = await client.sendMessage(to, text);
+          if (result.success && result.messageId) {
+            return { channel: "feishu", messageId: result.messageId };
+          }
+          return {
+            channel: "feishu",
+            messageId: `feishu-${Date.now()}`,
+            meta: { error: result.error ?? "send failed" },
+          };
+        } catch (err) {
+          return {
+            channel: "feishu",
+            messageId: `feishu-${Date.now()}`,
+            meta: { error: String(err) },
+          };
+        }
+      },
+    },
+  });
+
+  // Attach base wrapper so tests can access channel.base.* (mirrors the nested input structure)
+  const plugin = raw as FeishuChannelPlugin;
+  plugin.base = {
+    id: plugin.id,
+    meta: {
+      ...plugin.meta,
+      systemImage: (plugin.meta as Record<string, unknown>).systemImage ?? "message",
+    },
+    capabilities: plugin.capabilities,
+    outbound: plugin.outbound,
+    config: plugin.config,
+    messaging: plugin.messaging,
+  };
+
+  return plugin;
+}
+
+export function handleFeishuWebhook(
+  config: FeishuChannelConfig,
+  feishuClient: FeishuApiClient,
+  deps: FeishuChannelDeps,
+): {
+  startServer: () => Promise<() => Promise<void>>;
+  handler: (req: Request) => Promise<Response>;
+} {
+  const { webhookPort, webhookPath, appSecret } = config;
+
+  function verifySignature(body: string, signature: string | null): boolean {
+    if (!signature) return false;
+    const expected = createHmac("sha256", appSecret)
+      .update(body)
+      .digest("base64");
+    return signature === expected;
+  }
+
+  async function handler(req: Request): Promise<Response> {
+    const url = new URL(req.url);
+
+    // Challenge verification (GET)
+    if (req.method === "GET") {
+      const challenge = url.searchParams.get("challenge");
+      if (challenge) {
+        return new Response(JSON.stringify({ challenge }), {
+          status: 200,
+          headers: { "content-type": "application/json" },
+        });
+      }
+      return new Response("Not Found", { status: 404 });
+    }
+
+    // Event handling (POST)
+    if (req.method === "POST") {
+      const body = await req.text();
+      const signature = req.headers.get("x-lark-signature");
+
+      if (!verifySignature(body, signature)) {
+        return new Response("Invalid signature", { status: 400 });
+      }
+
+      try {
+        const event = JSON.parse(body);
+
+        // Only process im.message.receive_v1 events
+        const eventType = event.header?.eventType;
+        if (eventType !== "im.message.receive_v1") {
+          return new Response(null, { status: 200 });
+        }
+
+        const message = event.event?.message;
+        const openId = event.event?.sender?.senderId?.openId;
+
+        if (message && openId && message.msgType === "text") {
+          try {
+            const content = JSON.parse(message.content) as { text?: string };
+            const text = content.text?.trim();
+            if (text) {
+              await feishuClient.sendMessage(openId, text);
+            }
+          } catch {
+            deps.logger?.warn?.(
+              `Failed to parse message content: ${message.content}`,
+            );
+          }
+        }
+
+        return new Response(null, { status: 200 });
+      } catch {
+        return new Response("Invalid JSON", { status: 400 });
+      }
+    }
+
+    return new Response("Method Not Allowed", { status: 405 });
+  }
+
+  async function startServer(): Promise<() => Promise<void>> {
+    const httpModule = await import("node:http");
+    const server = httpModule.createServer(
+      async (req, res) => {
+        try {
+          const host = req.headers.host ?? "localhost";
+          const reqUrl = req.url ?? "/";
+          const url = new URL(reqUrl, `http://${host}`);
+          // Convert Node.js IncomingMessage to a Web API-like Request for handler
+          const request = new Request(url.toString(), {
+            method: req.method,
+            headers: Object.fromEntries(
+              Object.entries(req.headers as Record<string, string>),
+            ),
+            body: req.method !== "GET" && req.method !== "HEAD"
+              ? await new Promise<string>((resolve) => {
+                  const chunks: Buffer[] = [];
+                  req.on("data", (chunk: Buffer) => chunks.push(chunk));
+                  req.on("end", () => resolve(Buffer.concat(chunks).toString()));
+                })
+              : undefined,
+          });
+
+          const response = await handler(request);
+          res.statusCode = response.status;
+          // Forward response headers to Node.js response
+          const headersObj = Object.fromEntries(
+            (response.headers as unknown as Iterable<[string, string]>),
+          ) as Record<string, string>;
+          for (const [key, value] of Object.entries(headersObj)) {
+            res.setHeader(key, value);
+          }
+          const responseBody = await response.text();
+          res.end(responseBody);
+        } catch (err) {
+          deps.logger?.error?.(`Webhook handler error: ${err}`);
+          res.statusCode = 500;
+          res.end("Internal Server Error");
+        }
+      },
+    );
+
+    await new Promise<void>((resolve) => {
+      server.listen(webhookPort, () => {
+        resolve();
+      });
+    });
+
+    return () =>
+      new Promise<void>((resolve) => {
+        server.close(() => resolve());
+      });
+  }
+
+  return { startServer, handler };
+}