libp2p-mesh 2026.5.12 → 2026.5.13

package/src/feishu-types.ts

@@ -0,0 +1,51 @@
+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/src/inbound-feishu.test.ts

@@ -0,0 +1,91 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { handleP2PInbound, type InboundHandlerDeps } from "./inbound.js";
+import type { P2PMessage } from "./types.js";
+
+const makeMsg = (overrides: Partial<P2PMessage> = {}): P2PMessage => ({
+  id: "msg-1",
+  type: "direct",
+  from: "peer-abc",
+  payload: "hello from p2p",
+  timestamp: Date.now(),
+  ...overrides,
+});
+
+describe("handleP2PInbound with Feishu forwarding", () => {
+  let logger: Record<string, ReturnType<typeof vi.fn>>;
+
+  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: InboundHandlerDeps = {
+      logger,
+      feishuClient: { sendMessage } as any,
+    };
+
+    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: InboundHandlerDeps = { 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: InboundHandlerDeps = {
+      logger,
+      feishuClient: { sendMessage } as any,
+    };
+
+    handleP2PInbound(makeMsg(), deps);
+    await Promise.resolve();
+
+    expect(logger.warn).toHaveBeenCalled();
+    const warnCalls = logger.warn.mock.calls;
+    expect(warnCalls.some((c: string[]) => c.some((s: string) => s.includes("Failed to forward")))).toBe(true);
+  });
+
+  it("should forward broadcast messages to Feishu", async () => {
+    const sendMessage = vi.fn().mockResolvedValue({ success: true });
+    const deps: InboundHandlerDeps = {
+      logger,
+      feishuClient: { sendMessage } as any,
+    };
+
+    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: InboundHandlerDeps = {
+      logger,
+      feishuClient: { sendMessage } as any,
+    };
+
+    expect(() => handleP2PInbound(makeMsg(), deps)).not.toThrow();
+    expect(logger.info).toHaveBeenCalled();
+  });
+});

package/src/inbound.ts

@@ -1,4 +1,5 @@
 import type { P2PMessage } from "./types.js";
+import type { FeishuApiClient } from "./feishu-client.js";
 
 export type InboundHandlerDeps = {
   logger?: {
@@ -8,24 +9,28 @@ export type InboundHandlerDeps = {
     error?: (msg: string) => void;
   };
   sendToChannel?: (channelId: string, target: string, text: string) => Promise<void>;
+  feishuClient?: FeishuApiClient;
 };
 
 export function handleP2PInbound(msg: P2PMessage, deps: InboundHandlerDeps): void {
-  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;
+  } else {
+    logger?.info?.(`[libp2p-mesh] Direct message from ${msg.from}: ${msg.payload}`);
   }
 
-  // Direct message — log and forward to local channel
-  logger?.info?.(`[libp2p-mesh] Direct message from ${msg.from}: ${msg.payload}`);
-
-  if (!sendToChannel || !msg.payload) {
-    return;
+  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}`);
+    });
   }
 
-  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");
+    });
+  }
 }

package/src/index.ts

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

package/src/plugin-registration.test.ts

@@ -0,0 +1,60 @@
+import { describe, it, expect, vi, beforeEach } from "vitest";
+import { registerLibp2pMesh } from "./plugin.js";
+
+describe("registerLibp2pMesh Feishu registration", () => {
+  let mockApi: {
+    registerService: ReturnType<typeof vi.fn>;
+    registerChannel: ReturnType<typeof vi.fn>;
+    registerTool: ReturnType<typeof vi.fn>;
+    registerHook: ReturnType<typeof vi.fn>;
+    logger: {
+      info?: (msg: string) => void;
+      warn?: (msg: string) => void;
+      error?: (msg: string) => void;
+      debug?: (msg: string) => void;
+    };
+    pluginConfig?: unknown;
+  };
+
+  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 as any);
+    expect(mockApi.registerService).toHaveBeenCalledTimes(1);
+    expect(mockApi.registerChannel).toHaveBeenCalledTimes(1);
+  });
+
+  it("should register Feishu channel when feishu config is provided", () => {
+    registerLibp2pMesh(mockApi as any, {
+      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 as any);
+    expect(mockApi.registerChannel).toHaveBeenCalledTimes(1);
+  });
+
+  it("should register 3 P2P agent tools", () => {
+    registerLibp2pMesh(mockApi as any);
+    expect(mockApi.registerTool).toHaveBeenCalledTimes(3);
+  });
+});

package/src/plugin.ts

@@ -1,12 +1,15 @@
-import type { OpenClawPluginApi, PluginCommandContext, PluginCommandResult } from "openclaw/plugin-sdk/core";
+import type { OpenClawPluginApi } from "openclaw/plugin-sdk/core";
 import { createLibp2pMeshChannel } from "./channel.js";
 import { handleP2PInbound, type InboundHandlerDeps } 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";
 import type { ChannelPlugin } from "openclaw/plugin-sdk/core";
+import type { FeishuChannelConfig } from "./feishu-types.js";
+import { FeishuApiClient } from "./feishu-client.js";
+import { createFeishuChannel } from "./feishu-channel.js";
 
-export function registerLibp2pMesh(api: OpenClawPluginApi) {
+export function registerLibp2pMesh(api: OpenClawPluginApi, feishuConfig?: FeishuChannelConfig) {
   const mesh = createMeshNetwork({
     config: api.pluginConfig as { listenAddrs?: string[]; discovery?: "mdns" | "bootstrap" | "dht"; bootstrapList?: string[]; meshTopic?: string; enableAgentSync?: boolean; enableWebSocket?: boolean } | undefined,
     logger: api.logger,
@@ -14,15 +17,16 @@ export function registerLibp2pMesh(api: OpenClawPluginApi) {
 
   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: InboundHandlerDeps["sendToChannel"] = async (_channelId, target, text) => {
           try {
             await sendViaMesh(mesh, target, text);
@@ -30,7 +34,7 @@ export function registerLibp2pMesh(api: OpenClawPluginApi) {
             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()}`);
     },
@@ -51,46 +55,22 @@ export function registerLibp2pMesh(api: OpenClawPluginApi) {
     api.registerTool(tool as never);
   }
 
-  // 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: PluginCommandContext): PluginCommandResult => {
-      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"] },
-  );
+  const feishuTools = buildFeishuTools(feishuClient ?? null);
+  for (const tool of feishuTools) {
+    api.registerTool(tool as never);
+  }
 
-  // 6. Register Hook (log received messages for observability)
+  // 4. Register Hook (log received messages for observability)
   api.registerHook("message:received", async (event) => {
     const ctx = event.context as { channelId?: string } | undefined;
     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 as ChannelPlugin,
+    });
+  }
 }