libp2p-mesh 2026.5.22 → 2026.5.24

package/dist/src/inbound.js

@@ -58,6 +58,29 @@ export async function handleP2PInbound(msg, deps) {
             }
         }
         else if (msg.type === "direct") {
+            // onPeerConnect 通过 sendToPeer 发送 identity 时会被包装成
+            // type=direct 的外壳，真正的 identity 消息藏在 payload 里。
+            // 先检测并处理这种情况，确保双向身份交换能完成。
+            try {
+                const raw = JSON.parse(msg.payload);
+                if (raw && raw.type === "identity") {
+                    await handleIdentityMessage(msg, {
+                        peerIdentityMap: deps.peerIdentityMap,
+                        localPeerId: deps.peerIdentityMap.getLocalIdentity()?.sessionKey ?? "",
+                        localAgentId: "",
+                        localChannel: "",
+                        localAccountId: "",
+                        localInstanceId: deps.peerIdentityMap.getLocalIdentity()?.instanceId,
+                        send: async () => { }, // no-op; 双方都通过 onPeerConnect 主动发送身份
+                        logger,
+                    });
+                    // identity 处理完毕，不再走 direct 消息路由
+                    return;
+                }
+            }
+            catch {
+                // payload 不是 JSON，正常走 direct 消息逻辑
+            }
             if (!msg.to) {
                 logger?.warn?.("[libp2p-mesh] Direct message missing 'to' field");
             }

package/dist/src/plugin.js

@@ -11,26 +11,52 @@ export function registerLibp2pMesh(api) {
         logger: api.logger,
     });
     // Singleton: maps peerId -> { agentId, channel, accountId, sessionKey }
+    // Declared here (not inside start) so tool registration below can attach
+    // it to tool objects via closure.
     const peerIdentityMap = createPeerIdentityMap();
-    // Helper: build the deps object for the relay-aware inbound handler
-    function buildInboundDeps() {
-        return {
-            peerIdentityMap,
-            enqueueNextTurnInjection: (injection) => api.session.workflow.enqueueNextTurnInjection(injection),
-            logger: api.logger,
-        };
-    }
     // 1. Register Service (manages libp2p node lifecycle)
     api.registerService({
         id: "libp2p-mesh",
         start: async () => {
-            await mesh.start();
-            // Load persisted peer identities from disk
-            await peerIdentityMap.load();
-            // Gather local relay identity info
+            // Gather config before starting (needed for onMessage handler)
             const config = api.pluginConfig;
             const relayChannel = config?.relayChannel;
             const relayAccountId = config?.relayAccountId;
+            function buildInboundDeps() {
+                return {
+                    peerIdentityMap,
+                    enqueueNextTurnInjection: (injection) => api.session.workflow.enqueueNextTurnInjection(injection),
+                    logger: api.logger,
+                };
+            }
+            // Wire up relay-aware message handler BEFORE mesh.start() so that
+            // any identity messages arriving during startup are queued by libp2p
+            // and processed as soon as the protocol handler is ready.
+            mesh.onMessage((msg) => {
+                if (msg.type === "identity") {
+                    const localIdentity = peerIdentityMap.getLocalIdentity();
+                    handleIdentityMessage(msg, {
+                        peerIdentityMap,
+                        localPeerId: localIdentity?.sessionKey ?? "",
+                        localAgentId: api.name,
+                        localChannel: relayChannel ?? "",
+                        localAccountId: relayAccountId ?? "",
+                        localInstanceId: localIdentity?.instanceId,
+                        send: async (targetPeerId, replyMsg) => {
+                            mesh.sendToPeer(targetPeerId, JSON.stringify(replyMsg)).catch(() => { });
+                        },
+                        logger: api.logger,
+                    }).catch((err) => {
+                        api.logger.error?.(`[libp2p-mesh] Identity exchange error: ${String(err)}`);
+                    });
+                }
+                else {
+                    handleP2PInbound(msg, buildInboundDeps());
+                }
+            });
+            await mesh.start();
+            // Load persisted peer identities from disk
+            await peerIdentityMap.load();
             const instanceIdentity = mesh.getInstanceIdentity();
             const localInstanceId = instanceIdentity?.id;
             const localPeerId = mesh.getLocalPeerId();
@@ -42,10 +68,6 @@ export function registerLibp2pMesh(api) {
                     channel: relayChannel,
                     accountId: relayAccountId,
                 });
-                // setLocalIdentity stores the local identity separately (not in peers
-                // Map) to avoid duplication.  We also register in peers Map so
-                // direct messages addressed to us (msg.to === localPeerId) can be
-                // resolved by deps.peerIdentityMap.resolve() in handleP2PInbound.
                 peerIdentityMap.setLocalIdentity(localPeerId, {
                     agentId: api.name,
                     channel: relayChannel,
@@ -67,52 +89,48 @@ export function registerLibp2pMesh(api) {
                     try {
                         await mesh.sendToPeer(peerId, JSON.stringify(identityMsg));
                     }
-                    catch {
-                        // Best-effort; peer may be stale in the connection list
+                    catch (err) {
+                        api.logger.warn?.(`[libp2p-mesh] Failed to send initial identity to ${peerId}: ${String(err)}`);
                     }
                 }
-                // When a new peer connects, send our identity to them
-                mesh.onPeerConnect((peerId) => {
-                    api.logger.info?.(`[libp2p-mesh] Peer connected: ${peerId} — sending identity`);
-                    const msg = buildIdentityMessage(localPeerId, api.name, relayChannel, relayAccountId, localInstanceId);
-                    mesh.sendToPeer(peerId, JSON.stringify(msg)).catch(() => {
-                        // Best-effort
-                    });
-                });
-                // When a peer disconnects, clean up the identity map
-                mesh.onPeerDisconnect((peerId) => {
-                    api.logger.info?.(`[libp2p-mesh] Peer disconnected: ${peerId}`);
-                    peerIdentityMap.unregister(peerId);
-                    peerIdentityMap.saveNow().catch(() => { });
-                });
             }
-            // Wire up relay-aware message handler.
-            // Identity messages get special treatment: they register the remote
-            // peer's identity, force immediate persistence via saveNow(), and
-            // automatically send our identity back — ensuring bidirectional
-            // identity exchange even when peer:connect events are one-sided
-            // (e.g. NAT/relay scenarios).
-            mesh.onMessage((msg) => {
-                if (msg.type === "identity") {
-                    const localIdentity = peerIdentityMap.getLocalIdentity();
-                    handleIdentityMessage(msg, {
-                        peerIdentityMap,
-                        localPeerId,
-                        localAgentId: api.name,
-                        localChannel: relayChannel ?? "",
-                        localAccountId: relayAccountId ?? "",
-                        localInstanceId,
-                        send: async (targetPeerId, replyMsg) => {
-                            mesh.sendToPeer(targetPeerId, JSON.stringify(replyMsg)).catch(() => { });
-                        },
-                        logger: api.logger,
-                    }).catch((err) => {
-                        api.logger.error?.(`[libp2p-mesh] Identity exchange error: ${String(err)}`);
-                    });
-                }
-                else {
-                    handleP2PInbound(msg, buildInboundDeps());
-                }
+            // Register peer lifecycle handlers AFTER mesh.start() so that
+            // sendToPeer can establish streams reliably.  Without this deferral,
+            // onPeerConnect can fire during mDNS discovery (before node.start()
+            // completes), causing dialProtocol to fail because the protocol
+            // handler isn't fully wired yet — and the .catch(() => {}) swallows
+            // the error silently, breaking identity exchange entirely.
+            mesh.onPeerConnect((peerId) => {
+                api.logger.info?.(`[libp2p-mesh] Peer connected: ${peerId} — sending identity`);
+                // Only send identity if relay config is set (otherwise there's no
+                // identity to announce).
+                if (!relayChannel || !relayAccountId)
+                    return;
+                const msg = buildIdentityMessage(localPeerId ?? "", api.name, relayChannel, relayAccountId, localInstanceId);
+                // Retry up to 3 times with 500ms间隔, log failures
+                const maxRetries = 3;
+                let attempt = 0;
+                const sendWithRetry = async () => {
+                    try {
+                        await mesh.sendToPeer(peerId, JSON.stringify(msg));
+                    }
+                    catch (err) {
+                        attempt++;
+                        if (attempt < maxRetries) {
+                            api.logger.debug?.(`[libp2p-mesh] Identity send to ${peerId} failed (attempt ${attempt}/${maxRetries}), retrying...`);
+                            setTimeout(sendWithRetry, 500);
+                        }
+                        else {
+                            api.logger.warn?.(`[libp2p-mesh] Failed to send identity to ${peerId} after ${maxRetries} attempts: ${String(err)}`);
+                        }
+                    }
+                };
+                sendWithRetry();
+            });
+            mesh.onPeerDisconnect((peerId) => {
+                api.logger.info?.(`[libp2p-mesh] Peer disconnected: ${peerId}`);
+                peerIdentityMap.unregister(peerId);
+                peerIdentityMap.saveNow().catch(() => { });
             });
             const identity = mesh.getInstanceIdentity();
             api.logger.info?.(`[libp2p-mesh] Service started. Peer ID: ${localPeerId}`);

package/package.json

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

package/src/inbound.ts

@@ -75,6 +75,29 @@ export async function handleP2PInbound(msg: P2PMessage, deps?: InboundHandlerDep
         logger?.error?.(`[libp2p-mesh] Identity message handler error: ${String(err)}`);
       }
     } else if (msg.type === "direct") {
+      // onPeerConnect 通过 sendToPeer 发送 identity 时会被包装成
+      // type=direct 的外壳，真正的 identity 消息藏在 payload 里。
+      // 先检测并处理这种情况，确保双向身份交换能完成。
+      try {
+        const raw = JSON.parse(msg.payload);
+        if (raw && raw.type === "identity") {
+          await handleIdentityMessage(msg, {
+            peerIdentityMap: deps.peerIdentityMap,
+            localPeerId: deps.peerIdentityMap.getLocalIdentity()?.sessionKey ?? "",
+            localAgentId: "",
+            localChannel: "",
+            localAccountId: "",
+            localInstanceId: deps.peerIdentityMap.getLocalIdentity()?.instanceId,
+            send: async () => {}, // no-op; 双方都通过 onPeerConnect 主动发送身份
+            logger,
+          });
+          // identity 处理完毕，不再走 direct 消息路由
+          return;
+        }
+      } catch {
+        // payload 不是 JSON，正常走 direct 消息逻辑
+      }
+
       if (!msg.to) {
         logger?.warn?.("[libp2p-mesh] Direct message missing 'to' field");
       } else {

package/src/plugin.ts

@@ -16,31 +16,58 @@ export function registerLibp2pMesh(api: OpenClawPluginApi) {
   });
 
   // Singleton: maps peerId -> { agentId, channel, accountId, sessionKey }
+  // Declared here (not inside start) so tool registration below can attach
+  // it to tool objects via closure.
   const peerIdentityMap = createPeerIdentityMap();
 
-  // Helper: build the deps object for the relay-aware inbound handler
-  function buildInboundDeps() {
-    return {
-      peerIdentityMap,
-      enqueueNextTurnInjection: (injection: PluginNextTurnInjection) =>
-        api.session.workflow.enqueueNextTurnInjection(injection),
-      logger: api.logger,
-    };
-  }
-
   // 1. Register Service (manages libp2p node lifecycle)
   api.registerService({
     id: "libp2p-mesh",
     start: async () => {
+      // Gather config before starting (needed for onMessage handler)
+      const config = api.pluginConfig as MeshConfig | undefined;
+      const relayChannel = config?.relayChannel;
+      const relayAccountId = config?.relayAccountId;
+
+      function buildInboundDeps() {
+        return {
+          peerIdentityMap,
+          enqueueNextTurnInjection: (injection: PluginNextTurnInjection) =>
+            api.session.workflow.enqueueNextTurnInjection(injection),
+          logger: api.logger,
+        };
+      }
+
+      // Wire up relay-aware message handler BEFORE mesh.start() so that
+      // any identity messages arriving during startup are queued by libp2p
+      // and processed as soon as the protocol handler is ready.
+      mesh.onMessage((msg) => {
+        if (msg.type === "identity") {
+          const localIdentity = peerIdentityMap.getLocalIdentity();
+          handleIdentityMessage(msg, {
+            peerIdentityMap,
+            localPeerId: localIdentity?.sessionKey ?? "",
+            localAgentId: api.name,
+            localChannel: relayChannel ?? "",
+            localAccountId: relayAccountId ?? "",
+            localInstanceId: localIdentity?.instanceId,
+            send: async (targetPeerId: string, replyMsg: any) => {
+              mesh.sendToPeer(targetPeerId, JSON.stringify(replyMsg)).catch(() => {});
+            },
+            logger: api.logger,
+          }).catch((err) => {
+            api.logger.error?.(`[libp2p-mesh] Identity exchange error: ${String(err)}`);
+          });
+        } else {
+          handleP2PInbound(msg, buildInboundDeps());
+        }
+      });
+
       await mesh.start();
 
       // Load persisted peer identities from disk
       await peerIdentityMap.load();
 
-      // Gather local relay identity info
-      const config = api.pluginConfig as MeshConfig | undefined;
-      const relayChannel = config?.relayChannel;
-      const relayAccountId = config?.relayAccountId;
       const instanceIdentity = mesh.getInstanceIdentity();
       const localInstanceId = instanceIdentity?.id;
       const localPeerId = mesh.getLocalPeerId();
@@ -53,10 +80,6 @@ export function registerLibp2pMesh(api: OpenClawPluginApi) {
           channel: relayChannel,
           accountId: relayAccountId,
         });
-        // setLocalIdentity stores the local identity separately (not in peers
-        // Map) to avoid duplication.  We also register in peers Map so
-        // direct messages addressed to us (msg.to === localPeerId) can be
-        // resolved by deps.peerIdentityMap.resolve() in handleP2PInbound.
         peerIdentityMap.setLocalIdentity(localPeerId, {
           agentId: api.name,
           channel: relayChannel,
@@ -86,60 +109,60 @@ export function registerLibp2pMesh(api: OpenClawPluginApi) {
         for (const peerId of mesh.getConnectedPeers()) {
           try {
             await mesh.sendToPeer(peerId, JSON.stringify(identityMsg));
-          } catch {
-            // Best-effort; peer may be stale in the connection list
+          } catch (err) {
+            api.logger.warn?.(
+              `[libp2p-mesh] Failed to send initial identity to ${peerId}: ${String(err)}`,
+            );
           }
         }
+      }
 
-        // When a new peer connects, send our identity to them
-        mesh.onPeerConnect((peerId: string) => {
-          api.logger.info?.(`[libp2p-mesh] Peer connected: ${peerId} — sending identity`);
-          const msg = buildIdentityMessage(
-            localPeerId,
-            api.name,
-            relayChannel,
-            relayAccountId,
-            localInstanceId,
-          );
-          mesh.sendToPeer(peerId, JSON.stringify(msg)).catch(() => {
-            // Best-effort
-          });
-        });
+      // Register peer lifecycle handlers AFTER mesh.start() so that
+      // sendToPeer can establish streams reliably.  Without this deferral,
+      // onPeerConnect can fire during mDNS discovery (before node.start()
+      // completes), causing dialProtocol to fail because the protocol
+      // handler isn't fully wired yet — and the .catch(() => {}) swallows
+      // the error silently, breaking identity exchange entirely.
 
-        // When a peer disconnects, clean up the identity map
-        mesh.onPeerDisconnect((peerId: string) => {
-          api.logger.info?.(`[libp2p-mesh] Peer disconnected: ${peerId}`);
-          peerIdentityMap.unregister(peerId);
-          peerIdentityMap.saveNow().catch(() => {});
-        });
-      }
+      mesh.onPeerConnect((peerId: string) => {
+        api.logger.info?.(`[libp2p-mesh] Peer connected: ${peerId} — sending identity`);
+        // Only send identity if relay config is set (otherwise there's no
+        // identity to announce).
+        if (!relayChannel || !relayAccountId) return;
+        const msg = buildIdentityMessage(
+          localPeerId ?? "",
+          api.name,
+          relayChannel,
+          relayAccountId,
+          localInstanceId,
+        );
+        // Retry up to 3 times with 500ms间隔, log failures
+        const maxRetries = 3;
+        let attempt = 0;
+        const sendWithRetry = async (): Promise<void> => {
+          try {
+            await mesh.sendToPeer(peerId, JSON.stringify(msg));
+          } catch (err) {
+            attempt++;
+            if (attempt < maxRetries) {
+              api.logger.debug?.(
+                `[libp2p-mesh] Identity send to ${peerId} failed (attempt ${attempt}/${maxRetries}), retrying...`,
+              );
+              setTimeout(sendWithRetry, 500);
+            } else {
+              api.logger.warn?.(
+                `[libp2p-mesh] Failed to send identity to ${peerId} after ${maxRetries} attempts: ${String(err)}`,
+              );
+            }
+          }
+        };
+        sendWithRetry();
+      });
 
-      // Wire up relay-aware message handler.
-      // Identity messages get special treatment: they register the remote
-      // peer's identity, force immediate persistence via saveNow(), and
-      // automatically send our identity back — ensuring bidirectional
-      // identity exchange even when peer:connect events are one-sided
-      // (e.g. NAT/relay scenarios).
-      mesh.onMessage((msg) => {
-        if (msg.type === "identity") {
-          const localIdentity = peerIdentityMap.getLocalIdentity();
-          handleIdentityMessage(msg, {
-            peerIdentityMap,
-            localPeerId,
-            localAgentId: api.name,
-            localChannel: relayChannel ?? "",
-            localAccountId: relayAccountId ?? "",
-            localInstanceId,
-            send: async (targetPeerId: string, replyMsg: any) => {
-              mesh.sendToPeer(targetPeerId, JSON.stringify(replyMsg)).catch(() => {});
-            },
-            logger: api.logger,
-          }).catch((err) => {
-            api.logger.error?.(`[libp2p-mesh] Identity exchange error: ${String(err)}`);
-          });
-        } else {
-          handleP2PInbound(msg, buildInboundDeps());
-        }
+      mesh.onPeerDisconnect((peerId: string) => {
+        api.logger.info?.(`[libp2p-mesh] Peer disconnected: ${peerId}`);
+        peerIdentityMap.unregister(peerId);
+        peerIdentityMap.saveNow().catch(() => {});
       });
 
       const identity = mesh.getInstanceIdentity();