libp2p-mesh 2026.5.12 → 2026.5.13

package/README.md

@@ -9,6 +9,7 @@ P2P mesh network plugin for OpenClaw. Enables direct peer-to-peer communication
 - **Broadcast** — Publish messages to a shared topic, flood-fill forwarded across the mesh
 - **Bootstrap Mode** — Optional static bootstrap peer list for non-LAN scenarios
 - **WebSocket Transport** — Optional WebSocket support for NAT/firewall-friendly connections
+- **Feishu Integration (Beta)** — Receive and send messages via Feishu (Lark) IM, with automatic P2P forwarding
 
 ## Requirements
 
@@ -21,7 +22,7 @@ P2P mesh network plugin for OpenClaw. Enables direct peer-to-peer communication
 ### Method 1: Via OpenClaw CLI (Recommended)
 
 ```bash
-openclaw install openclaw-libp2p-mesh
+openclaw plugins install libp2p-mesh-v1
 ```
 
 ### Method 2: Manual (npm)
@@ -30,7 +31,7 @@ openclaw install openclaw-libp2p-mesh
 
 ```bash
 cd ~/.openclaw/npm
-npm install openclaw-libp2p-mesh
+npm install libp2p-mesh-v1
 ```
 
 然后刷新插件注册表：
@@ -146,6 +147,34 @@ If peers are on different networks, use a bootstrap node:
 | `meshTopic` | `string` | `"openclaw-mesh"` | Default broadcast topic |
 | `enableAgentSync` | `boolean` | `true` | Enable agent state synchronization over the mesh |
 
+## Feishu 集成（Beta）
+
+OpenClaw 可以通过飞书与用户交互。配置后，你的 OpenClaw 实例会：
+- 接收你在飞书中的消息
+- 通过 P2P mesh 与其他 OpenClaw 实例通信
+- 将 P2P 消息自动转发到你的飞书
+
+### 配置步骤
+
+1. 在[飞书开放平台](https://open.feishu.cn/)创建企业自建应用
+2. 开启"机器人"能力，获取 App ID 和 App Secret
+3. 配置事件订阅：请求地址填 `http://<your-host>:9222/webhook/feishu`
+4. 订阅事件类型：`im.message.receive_v1`
+5. 在 OpenClaw 配置中添加：
+
+```yaml
+feishu:
+  appId: "cli-xxxxxxxxxx"
+  appSecret: "xxxxxxxxxxxxxxxx"
+  webhookPort: 9222
+  webhookPath: "/webhook/feishu"
+```
+
+### 部署要求
+
+- webhook 端口必须对飞书服务器可达（公网 IP 或端口映射）
+- 本地开发可以使用 ngrok: `ngrok http 9222`
+
 ## Usage: Two Computers on the Same LAN
 
 ### Step 1 — Start both gateways

package/dist/index.d.ts

@@ -1,4 +1,5 @@
 import type { OpenClawPluginConfigSchema } from "openclaw/plugin-sdk/core";
+export declare function createLibp2pMeshConfigSchema(): OpenClawPluginConfigSchema;
 declare const _default: {
     id: string;
     name: string;

package/dist/index.js

@@ -1,6 +1,6 @@
 import { definePluginEntry } from "openclaw/plugin-sdk/core";
 import { registerLibp2pMesh } from "./src/plugin.js";
-function createLibp2pMeshConfigSchema() {
+export function createLibp2pMeshConfigSchema() {
     return {
         safeParse(value) {
             if (value === undefined) {
@@ -49,6 +49,30 @@ function createLibp2pMeshConfigSchema() {
                     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/dist/src/agent-tools-feishu.test.d.ts

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

package/dist/src/agent-tools-feishu.test.js

@@ -0,0 +1,57 @@
+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(),
+        };
+        const tools = buildFeishuTools(mockClient);
+        expect(tools).toHaveLength(1);
+        expect(tools[0].name).toBe("feishu_send_message");
+    });
+    describe("feishu_send_message tool", () => {
+        let tools;
+        let mockClient;
+        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/dist/src/agent-tools.d.ts

@@ -1,4 +1,5 @@
 import type { MeshNetwork } from "./types.js";
+import type { FeishuApiClient } from "./feishu-client.js";
 export declare function buildP2PTools(mesh: MeshNetwork): ({
     name: string;
     label: string;
@@ -128,3 +129,50 @@ export declare function buildP2PTools(mesh: MeshNetwork): ({
         isError: boolean;
     }>;
 })[];
+export declare function buildFeishuTools(feishuClient: FeishuApiClient | null): {
+    name: string;
+    label: string;
+    description: string;
+    parameters: {
+        type: "object";
+        properties: {
+            openId: {
+                type: "string";
+                description: string;
+            };
+            message: {
+                type: "string";
+                description: string;
+            };
+        };
+        required: string[];
+    };
+    execute(_toolCallId: string, params: {
+        openId: string;
+        message: string;
+    }): Promise<{
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: {
+            sent: boolean;
+            openId: string;
+            messageId: string | undefined;
+            error?: undefined;
+        };
+        isError?: undefined;
+    } | {
+        content: {
+            type: "text";
+            text: string;
+        }[];
+        details: {
+            sent: boolean;
+            openId: string;
+            error: string | undefined;
+            messageId?: undefined;
+        };
+        isError: boolean;
+    }>;
+}[];

package/dist/src/agent-tools.js

@@ -114,3 +114,47 @@ export function buildP2PTools(mesh) {
         },
     ];
 }
+export function buildFeishuTools(feishuClient) {
+    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",
+                properties: {
+                    openId: {
+                        type: "string",
+                        description: "Feishu openId of the recipient",
+                    },
+                    message: {
+                        type: "string",
+                        description: "Text message content to send",
+                    },
+                },
+                required: ["openId", "message"],
+            },
+            async execute(_toolCallId, params) {
+                const result = await feishuClient.sendMessage(params.openId, params.message);
+                if (result.success) {
+                    return {
+                        content: [{ type: "text", text: `Message sent to Feishu user ${params.openId}` }],
+                        details: { sent: true, openId: params.openId, messageId: result.messageId },
+                    };
+                }
+                return {
+                    content: [
+                        {
+                            type: "text",
+                            text: `Failed to send Feishu message to ${params.openId}: ${result.error}`,
+                        },
+                    ],
+                    details: { sent: false, openId: params.openId, error: result.error },
+                    isError: true,
+                };
+            },
+        },
+    ];
+}

package/dist/src/config-schema.test.d.ts

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

package/dist/src/config-schema.test.js

@@ -0,0 +1,55 @@
+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.jsonSchema.properties;
+        expect(props).toHaveProperty("feishu");
+    });
+    it("feishu should be an object type with correct properties", () => {
+        const props = schema.jsonSchema.properties;
+        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.jsonSchema.properties;
+        expect(props.feishu.properties.webhookPort.default).toBe(9222);
+    });
+    it("feishu.webhookPath should default to /webhook/feishu", () => {
+        const props = schema.jsonSchema.properties;
+        expect(props.feishu.properties.webhookPath.default).toBe("/webhook/feishu");
+    });
+    it("feishu.appId and appSecret should be string type without default", () => {
+        const props = schema.jsonSchema.properties;
+        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.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.safeParse({
+            listenAddrs: ["/ip4/0.0.0.0/tcp/0"],
+        });
+        expect(result.success).toBe(true);
+    });
+});

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

@@ -0,0 +1,19 @@
+import type { ChannelPlugin } from "openclaw/plugin-sdk/core";
+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 declare function createFeishuChannel(config: FeishuChannelConfig, deps?: FeishuChannelDeps, feishuClient?: FeishuApiClient): FeishuChannelPlugin;
+export declare function handleFeishuWebhook(config: FeishuChannelConfig, feishuClient: FeishuApiClient, deps: FeishuChannelDeps): {
+    startServer: () => Promise<() => Promise<void>>;
+    handler: (req: Request) => Promise<Response>;
+};

package/dist/src/feishu-channel.js

@@ -0,0 +1,202 @@
+import { createChatChannelPlugin } from "openclaw/plugin-sdk/core";
+import { createHmac } from "node:crypto";
+import { FeishuApiClient } from "./feishu-client.js";
+export function createFeishuChannel(config, deps, feishuClient) {
+    const client = feishuClient ?? new FeishuApiClient(config, deps);
+    const raw = createChatChannelPlugin({
+        base: {
+            id: "feishu",
+            meta: {
+                id: "feishu",
+                label: "Feishu",
+                selectionLabel: "Feishu",
+                docsPath: "/channels/feishu",
+                docsLabel: "feishu",
+                blurb: "Feishu integration for user interaction.",
+                systemImage: "message",
+            },
+            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) => 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;
+    plugin.base = {
+        id: plugin.id,
+        meta: {
+            ...plugin.meta,
+            systemImage: plugin.meta.systemImage ?? "message",
+        },
+        capabilities: plugin.capabilities,
+        outbound: plugin.outbound,
+        config: plugin.config,
+        messaging: plugin.messaging,
+    };
+    return plugin;
+}
+export function handleFeishuWebhook(config, feishuClient, deps) {
+    const { webhookPort, webhookPath, appSecret } = config;
+    function verifySignature(body, signature) {
+        if (!signature)
+            return false;
+        const expected = createHmac("sha256", appSecret)
+            .update(body)
+            .digest("base64");
+        return signature === expected;
+    }
+    async function handler(req) {
+        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);
+                        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() {
+        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)),
+                    body: req.method !== "GET" && req.method !== "HEAD"
+                        ? await new Promise((resolve) => {
+                            const chunks = [];
+                            req.on("data", (chunk) => 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);
+                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((resolve) => {
+            server.listen(webhookPort, () => {
+                resolve();
+            });
+        });
+        return () => new Promise((resolve) => {
+            server.close(() => resolve());
+        });
+    }
+    return { startServer, handler };
+}

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

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