libp2p-mesh 2026.5.14 → 2026.5.16

package/dist/index.d.ts

@@ -1,9 +1,3 @@
-import type { OpenClawPluginConfigSchema } from "openclaw/plugin-sdk/core";
-declare const _default: {
-    id: string;
-    name: string;
-    description: string;
-    configSchema: OpenClawPluginConfigSchema;
-    register: NonNullable<import("openclaw/plugin-sdk/core").OpenClawPluginDefinition["register"]>;
-} & Pick<import("openclaw/plugin-sdk/core").OpenClawPluginDefinition, "reload" | "kind" | "nodeHostCommands" | "securityAuditCollectors">;
+import { definePluginEntry } from "openclaw/plugin-sdk/core";
+declare const _default: ReturnType<typeof definePluginEntry>;
 export default _default;

package/index.ts

@@ -122,4 +122,4 @@ export default definePluginEntry({
   description: "P2P network for cross-instance agent communication via libp2p.",
   configSchema: createLibp2pMeshConfigSchema(),
   register: registerLibp2pMesh,
-});
+}) as ReturnType<typeof definePluginEntry>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "libp2p-mesh",
-  "version": "2026.5.14",
+  "version": "2026.5.16",
   "description": "OpenClaw libp2p P2P mesh network plugin for cross-instance agent communication",
   "type": "module",
   "main": "dist/index.js",

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

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

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

@@ -1,57 +0,0 @@
-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/config-schema.test.d.ts

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

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

@@ -1,55 +0,0 @@
-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

@@ -1,19 +0,0 @@
-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

@@ -1,202 +0,0 @@
-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

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

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

@@ -1,166 +0,0 @@
-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

@@ -1,27 +0,0 @@
-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;
-}