libp2p-mesh 2026.5.12 → 2026.5.13

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

@@ -0,0 +1,53 @@
+export interface FeishuChannelConfig {
+    appId: string;
+    appSecret: string;
+    webhookPort: number;
+    webhookPath: string;
+}
+export interface FeishuWebhookEvent {
+    schema: string;
+    header: {
+        eventId: string;
+        eventType: string;
+        createTime: string;
+        token: string;
+        appId: string;
+        tenantKey: string;
+    };
+    event: {
+        sender: {
+            senderId: {
+                openId: string;
+            };
+        };
+        message: {
+            messageId: string;
+            rootId?: string;
+            parentId?: string;
+            msgType: "text" | "post" | "image" | "interactive";
+            createTime: string;
+            chatId: string;
+            chatType: "p2p" | "group";
+            content: string;
+        };
+    };
+}
+export interface FeishuSendMessageRequest {
+    receiveId: string;
+    receiveIdType: "openId" | "chatId";
+    msgType: "text";
+    content: string;
+}
+export interface FeishuSendMessageResponse {
+    code: number;
+    msg: string;
+    data: {
+        messageId: string;
+    };
+}
+export interface FeishuTokenResponse {
+    code: number;
+    msg: string;
+    tenant_access_token: string;
+    expire: number;
+}

package/dist/src/feishu-types.js

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

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

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

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

@@ -0,0 +1,108 @@
+import { describe, it, expect } from "vitest";
+describe("FeishuChannelConfig", () => {
+    it("should have correct default values", () => {
+        const config = {
+            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 = {
+        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 = {
+            ...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 = {
+            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 = {
+            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 = {
+            code: 99991663,
+            msg: "token invalid",
+            data: { messageId: "" },
+        };
+        expect(resp.code).toBe(99991663);
+    });
+});
+describe("FeishuTokenResponse", () => {
+    it("should parse token response", () => {
+        const resp = {
+            code: 0,
+            msg: "ok",
+            tenant_access_token: "t-abc123",
+            expire: 7200,
+        };
+        expect(resp.tenant_access_token).toBe("t-abc123");
+        expect(resp.expire).toBe(7200);
+    });
+});

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

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

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

@@ -0,0 +1,70 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { handleP2PInbound } from "./inbound.js";
+const makeMsg = (overrides = {}) => ({
+    id: "msg-1",
+    type: "direct",
+    from: "peer-abc",
+    payload: "hello from p2p",
+    timestamp: Date.now(),
+    ...overrides,
+});
+describe("handleP2PInbound with Feishu forwarding", () => {
+    let logger;
+    beforeEach(() => {
+        logger = {
+            info: vi.fn(),
+            debug: vi.fn(),
+            warn: vi.fn(),
+            error: vi.fn(),
+        };
+    });
+    it("should call feishuClient.sendMessage when feishuClient is provided", async () => {
+        const sendMessage = vi.fn().mockResolvedValue({ success: true });
+        const deps = {
+            logger,
+            feishuClient: { sendMessage },
+        };
+        handleP2PInbound(makeMsg(), deps);
+        await Promise.resolve();
+        expect(sendMessage).toHaveBeenCalledTimes(1);
+        expect(sendMessage).toHaveBeenCalledWith(expect.any(String), "hello from p2p");
+    });
+    it("should not call feishuClient when feishuClient is not provided", () => {
+        const sendMessage = vi.fn();
+        const deps = { logger };
+        handleP2PInbound(makeMsg(), deps);
+        expect(sendMessage).not.toHaveBeenCalled();
+    });
+    it("should log warning when feishu forwarding fails", async () => {
+        const sendMessage = vi.fn().mockRejectedValue(new Error("network error"));
+        const deps = {
+            logger,
+            feishuClient: { sendMessage },
+        };
+        handleP2PInbound(makeMsg(), deps);
+        await Promise.resolve();
+        expect(logger.warn).toHaveBeenCalled();
+        const warnCalls = logger.warn.mock.calls;
+        expect(warnCalls.some((c) => c.some((s) => s.includes("Failed to forward")))).toBe(true);
+    });
+    it("should forward broadcast messages to Feishu", async () => {
+        const sendMessage = vi.fn().mockResolvedValue({ success: true });
+        const deps = {
+            logger,
+            feishuClient: { sendMessage },
+        };
+        handleP2PInbound(makeMsg({ type: "broadcast", topic: "general", payload: "broadcast msg" }), deps);
+        await Promise.resolve();
+        expect(sendMessage).toHaveBeenCalledTimes(1);
+        expect(sendMessage).toHaveBeenCalledWith(expect.any(String), "broadcast msg");
+    });
+    it("should not break existing logging when feishuClient fails", async () => {
+        const sendMessage = vi.fn().mockRejectedValue(new Error("fail"));
+        const deps = {
+            logger,
+            feishuClient: { sendMessage },
+        };
+        expect(() => handleP2PInbound(makeMsg(), deps)).not.toThrow();
+        expect(logger.info).toHaveBeenCalled();
+    });
+});

package/dist/src/inbound.d.ts

@@ -1,4 +1,5 @@
 import type { P2PMessage } from "./types.js";
+import type { FeishuApiClient } from "./feishu-client.js";
 export type InboundHandlerDeps = {
     logger?: {
         info?: (msg: string) => void;
@@ -7,5 +8,6 @@ export type InboundHandlerDeps = {
         error?: (msg: string) => void;
     };
     sendToChannel?: (channelId: string, target: string, text: string) => Promise<void>;
+    feishuClient?: FeishuApiClient;
 };
 export declare function handleP2PInbound(msg: P2PMessage, deps: InboundHandlerDeps): void;

package/dist/src/inbound.js

@@ -1,16 +1,20 @@
 export function handleP2PInbound(msg, deps) {
-    const { logger, sendToChannel } = deps;
+    const { logger, sendToChannel, feishuClient } = deps;
     if (msg.type === "broadcast") {
         logger?.info?.(`[libp2p-mesh] Broadcast from ${msg.from} on topic ${msg.topic ?? "(none)"}: ${msg.payload}`);
-        return;
     }
-    // Direct message — log and forward to local channel
-    logger?.info?.(`[libp2p-mesh] Direct message from ${msg.from}: ${msg.payload}`);
-    if (!sendToChannel || !msg.payload) {
-        return;
+    else {
+        logger?.info?.(`[libp2p-mesh] Direct message from ${msg.from}: ${msg.payload}`);
+    }
+    if (msg.type !== "broadcast" && sendToChannel && msg.payload) {
+        const text = `[来自 ${msg.from}]\n${msg.payload}`;
+        sendToChannel("libp2p-mesh", msg.from, text).catch((err) => {
+            logger?.error?.(`[libp2p-mesh] Failed to forward direct message from ${msg.from}: ${err}`);
+        });
+    }
+    if (feishuClient && msg.payload) {
+        feishuClient.sendMessage(msg.from, msg.payload).catch(() => {
+            logger?.warn?.("[libp2p-mesh] Failed to forward P2P message to Feishu");
+        });
     }
-    const text = `[来自 ${msg.from}]\n${msg.payload}`;
-    sendToChannel("libp2p-mesh", msg.from, text).catch((err) => {
-        logger?.error?.(`[libp2p-mesh] Failed to forward direct message from ${msg.from}: ${err}`);
-    });
 }

package/dist/src/index.d.ts

@@ -0,0 +1 @@
+export { createLibp2pMeshConfigSchema } from "../index.js";

package/dist/src/index.js

@@ -0,0 +1 @@
+export { createLibp2pMeshConfigSchema } from "../index.js";

package/dist/src/plugin-registration.test.d.ts

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

package/dist/src/plugin-registration.test.js

@@ -0,0 +1,42 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { registerLibp2pMesh } from "./plugin.js";
+describe("registerLibp2pMesh Feishu registration", () => {
+    let mockApi;
+    beforeEach(() => {
+        mockApi = {
+            registerService: vi.fn(),
+            registerChannel: vi.fn(),
+            registerTool: vi.fn(),
+            registerHook: vi.fn(),
+            logger: {
+                info: vi.fn(),
+                warn: vi.fn(),
+                error: vi.fn(),
+                debug: vi.fn(),
+            },
+            pluginConfig: undefined,
+        };
+    });
+    it("should always register P2P mesh service and channel", () => {
+        registerLibp2pMesh(mockApi);
+        expect(mockApi.registerService).toHaveBeenCalledTimes(1);
+        expect(mockApi.registerChannel).toHaveBeenCalledTimes(1);
+    });
+    it("should register Feishu channel when feishu config is provided", () => {
+        registerLibp2pMesh(mockApi, {
+            appId: "cli-123",
+            appSecret: "secret-456",
+            webhookPort: 9222,
+            webhookPath: "/webhook/feishu",
+        });
+        expect(mockApi.registerChannel).toHaveBeenCalledTimes(2);
+    });
+    it("should not register Feishu channel when no feishu config", () => {
+        registerLibp2pMesh(mockApi);
+        expect(mockApi.registerChannel).toHaveBeenCalledTimes(1);
+    });
+    it("should register 3 P2P agent tools", () => {
+        registerLibp2pMesh(mockApi);
+        expect(mockApi.registerTool).toHaveBeenCalledTimes(3);
+    });
+});

package/dist/src/plugin.d.ts

@@ -1,2 +1,3 @@
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk/core";
-export declare function registerLibp2pMesh(api: OpenClawPluginApi): void;
+import type { FeishuChannelConfig } from "./feishu-types.js";
+export declare function registerLibp2pMesh(api: OpenClawPluginApi, feishuConfig?: FeishuChannelConfig): void;

package/dist/src/plugin.js

@@ -1,23 +1,25 @@
 import { createLibp2pMeshChannel } from "./channel.js";
 import { handleP2PInbound } from "./inbound.js";
 import { createMeshNetwork } from "./mesh.js";
-import { buildP2PTools } from "./agent-tools.js";
+import { buildP2PTools, buildFeishuTools } from "./agent-tools.js";
 import { sendViaMesh } from "./send.js";
-export function registerLibp2pMesh(api) {
+import { FeishuApiClient } from "./feishu-client.js";
+import { createFeishuChannel } from "./feishu-channel.js";
+export function registerLibp2pMesh(api, feishuConfig) {
     const mesh = createMeshNetwork({
         config: api.pluginConfig,
         logger: api.logger,
     });
     const channel = createLibp2pMeshChannel(mesh);
+    const feishuClient = feishuConfig?.appId
+        ? new FeishuApiClient(feishuConfig, { logger: api.logger })
+        : undefined;
     // 1. Register Service (manages libp2p node lifecycle)
     api.registerService({
         id: "libp2p-mesh",
         start: async () => {
-            api.logger.info?.("[libp2p-mesh] >>> Service start called");
             await mesh.start();
-            api.logger.info?.(`[libp2p-mesh] >>> mesh.start() done, Peer ID: ${mesh.getLocalPeerId()}`);
             mesh.onMessage((msg) => {
-                api.logger.info?.("[libp2p-mesh] >>> onMessage handler registered");
                 const sendToChannel = async (_channelId, target, text) => {
                     try {
                         await sendViaMesh(mesh, target, text);
@@ -26,7 +28,7 @@ export function registerLibp2pMesh(api) {
                         api.logger.error?.(`[libp2p-mesh] sendToChannel error: ${err}`);
                     }
                 };
-                handleP2PInbound(msg, { logger: api.logger, sendToChannel });
+                handleP2PInbound(msg, { logger: api.logger, sendToChannel, feishuClient });
             });
             api.logger.info?.(`[libp2p-mesh] Service started. Peer ID: ${mesh.getLocalPeerId()}`);
         },
@@ -44,41 +46,20 @@ export function registerLibp2pMesh(api) {
     for (const tool of tools) {
         api.registerTool(tool);
     }
-    // 4. Register Command (injects agent prompt guidance so the LLM knows to use
-    //    p2p_list_peers / p2p_send_message / p2p_broadcast for P2P mesh operations
-    //    instead of the built-in `nodes` tool, which only manages OpenClaw paired nodes.)
-    api.registerCommand({
-        name: "p2p",
-        description: "P2P mesh network operations (list peers, send messages, broadcast).",
-        agentPromptGuidance: [
-            "When the user asks to list, show, or discover P2P mesh peers or connected agents, use the p2p_list_peers tool. Do NOT use the built-in `nodes` tool for this — `nodes` lists OpenClaw paired nodes, not P2P mesh peers.",
-            "When the user asks to send a direct message to another peer/agent, use p2p_send_message.",
-            "When the user asks to broadcast a message to all peers on a topic, use p2p_broadcast.",
-        ],
-        handler: (_ctx) => {
-            return { text: "P2P mesh tools are available. Use p2p_list_peers, p2p_send_message, or p2p_broadcast." };
-        },
-    });
-    // 5. Register CLI commands for operator access
-    api.registerCli((ctx) => {
-        ctx.program
-            .command("status")
-            .description("Show local peer ID and connected peers")
-            .action(async () => {
-            const peers = mesh.getConnectedPeers();
-            ctx.logger.info?.(`Local Peer ID: ${mesh.getLocalPeerId()}\nConnected peers (${peers.length}): ${peers.join(", ") || "none"}`);
-        });
-        ctx.program
-            .command("peers")
-            .description("Alias for mesh status — list connected peers")
-            .action(async () => {
-            const peers = mesh.getConnectedPeers();
-            ctx.logger.info?.(`Connected peers (${peers.length}): ${peers.join(", ") || "none"}`);
-        });
-    }, { parentPath: ["p2p"] });
-    // 6. Register Hook (log received messages for observability)
+    const feishuTools = buildFeishuTools(feishuClient ?? null);
+    for (const tool of feishuTools) {
+        api.registerTool(tool);
+    }
+    // 4. Register Hook (log received messages for observability)
     api.registerHook("message:received", async (event) => {
         const ctx = event.context;
         api.logger.debug?.(`[libp2p-mesh] message received on channel ${ctx?.channelId ?? "unknown"}`);
     }, { name: "libp2p-mesh-message-received" });
+    // 5. Conditionally register Feishu channel
+    if (feishuClient && feishuConfig) {
+        const feishuChannel = createFeishuChannel(feishuConfig, { logger: api.logger }, feishuClient);
+        api.registerChannel({
+            plugin: feishuChannel,
+        });
+    }
 }

package/index.ts

@@ -2,7 +2,7 @@ import { definePluginEntry } from "openclaw/plugin-sdk/core";
 import type { OpenClawPluginConfigSchema } from "openclaw/plugin-sdk/core";
 import { registerLibp2pMesh } from "./src/plugin.js";
 
-function createLibp2pMeshConfigSchema(): OpenClawPluginConfigSchema {
+export function createLibp2pMeshConfigSchema(): OpenClawPluginConfigSchema {
   return {
     safeParse(value: unknown) {
       if (value === undefined) {
@@ -51,6 +51,30 @@ function createLibp2pMeshConfigSchema(): OpenClawPluginConfigSchema {
           type: "boolean",
           default: true,
         },
+        feishu: {
+          type: "object",
+          description: "Feishu integration configuration",
+          properties: {
+            appId: {
+              type: "string",
+              description: "Feishu app App ID",
+            },
+            appSecret: {
+              type: "string",
+              description: "Feishu app App Secret",
+            },
+            webhookPort: {
+              type: "number",
+              default: 9222,
+              description: "Port for Feishu webhook callback (default: 9222)",
+            },
+            webhookPath: {
+              type: "string",
+              default: "/webhook/feishu",
+              description: "Path for Feishu webhook callback",
+            },
+          },
+        },
       },
     },
   };

package/openclaw.plugin.json

@@ -39,7 +39,7 @@
       }
     }
   },
-  "channels": ["libp2p-mesh"],
+  "channels": ["libp2p-mesh", "feishu"],
   "channelConfigs": {
     "libp2p-mesh": {
       "schema": {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libp2p-mesh",
-  "version": "2026.5.12",
+  "version": "2026.5.13",
   "description": "OpenClaw libp2p P2P mesh network plugin for cross-instance agent communication",
   "type": "module",
   "main": "dist/index.js",
@@ -35,7 +35,8 @@
   "devDependencies": {
     "openclaw": "^2026.5.7",
     "tsx": "^4.0.0",
-    "typescript": "^5.9.3"
+    "typescript": "^5.9.3",
+    "vitest": "^4.1.8"
   },
   "peerDependencies": {
     "openclaw": ">=2026.3.24"

package/src/agent-tools-feishu.test.ts

@@ -0,0 +1,68 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { buildFeishuTools } from "./agent-tools.js";
+
+describe("buildFeishuTools", () => {
+  it("should return empty array when feishuClient is null", () => {
+    const tools = buildFeishuTools(null);
+    expect(tools).toEqual([]);
+  });
+
+  it("should return array with one tool when feishuClient is provided", () => {
+    const mockClient = {
+      sendMessage: vi.fn(),
+    } as any;
+    const tools = buildFeishuTools(mockClient);
+    expect(tools).toHaveLength(1);
+    expect(tools[0].name).toBe("feishu_send_message");
+  });
+
+  describe("feishu_send_message tool", () => {
+    let tools: ReturnType<typeof buildFeishuTools>;
+    let mockClient: any;
+
+    beforeEach(() => {
+      mockClient = {
+        sendMessage: vi.fn(),
+      };
+      tools = buildFeishuTools(mockClient);
+    });
+
+    it("should require openId and message parameters", () => {
+      const tool = tools[0];
+      expect(tool.parameters.required).toEqual(["openId", "message"]);
+    });
+
+    it("should return success result on successful send", async () => {
+      mockClient.sendMessage.mockResolvedValue({
+        success: true,
+        messageId: "msg-789",
+      });
+
+      const result = await tools[0].execute("call-1", {
+        openId: "ou-test",
+        message: "hello",
+      });
+
+      expect(result.isError).toBeUndefined();
+      expect(result.details.sent).toBe(true);
+      expect(result.details.openId).toBe("ou-test");
+      expect(mockClient.sendMessage).toHaveBeenCalledWith("ou-test", "hello");
+    });
+
+    it("should return error result on failed send", async () => {
+      mockClient.sendMessage.mockResolvedValue({
+        success: false,
+        error: "rate limited",
+      });
+
+      const result = await tools[0].execute("call-1", {
+        openId: "ou-test",
+        message: "hello",
+      });
+
+      expect(result.isError).toBe(true);
+      expect(result.details.sent).toBe(false);
+      expect(result.details.error).toBe("rate limited");
+    });
+  });
+});

package/src/agent-tools.ts

@@ -1,4 +1,5 @@
 import type { MeshNetwork } from "./types.js";
+import type { FeishuApiClient } from "./feishu-client.js";
 
 export function buildP2PTools(mesh: MeshNetwork) {
   return [
@@ -114,3 +115,47 @@ export function buildP2PTools(mesh: MeshNetwork) {
     },
   ];
 }
+
+export function buildFeishuTools(feishuClient: FeishuApiClient | null) {
+  if (!feishuClient) return [];
+  return [
+    {
+      name: "feishu_send_message",
+      label: "Feishu Send Message",
+      description: "Send a text message to a Feishu user by their openId. Use this to notify users through Feishu.",
+      parameters: {
+        type: "object" as const,
+        properties: {
+          openId: {
+            type: "string" as const,
+            description: "Feishu openId of the recipient",
+          },
+          message: {
+            type: "string" as const,
+            description: "Text message content to send",
+          },
+        },
+        required: ["openId", "message"],
+      },
+      async execute(_toolCallId: string, params: { openId: string; message: string }) {
+        const result = await feishuClient.sendMessage(params.openId, params.message);
+        if (result.success) {
+          return {
+            content: [{ type: "text" as const, text: `Message sent to Feishu user ${params.openId}` }],
+            details: { sent: true, openId: params.openId, messageId: result.messageId },
+          };
+        }
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: `Failed to send Feishu message to ${params.openId}: ${result.error}`,
+            },
+          ],
+          details: { sent: false, openId: params.openId, error: result.error },
+          isError: true,
+        };
+      },
+    },
+  ];
+}