libp2p-mesh 2026.5.19 → 2026.5.20

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

@@ -310,11 +310,18 @@ export declare function buildP2PTools(mesh: MeshNetwork): ({
             text: string;
         }[];
         details: {
-            knownIdentities: ({
-                instanceId: any;
-                agentId: any;
-                channel: any;
-            } | null)[];
+            localPeerId: string;
+            localInstanceId: any;
+            connectedPeers: number;
+            knownPeers: {
+                peerId: string;
+                agentId: string;
+                channel: string;
+                instanceId?: string;
+                sessionKey: string;
+                status: string;
+                lastSeen?: number;
+            }[];
         };
     }>;
 })[];

package/dist/src/agent-tools.js

@@ -278,28 +278,59 @@ export function buildP2PTools(mesh) {
         {
             name: "p2p_relay_status",
             label: "P2P Relay Status",
-            description: "Get current P2P mesh connection status, known peers, and identity mapping.",
+            description: "Get full P2P mesh identity table: local node info, all known peers (connected or not), their instance IDs, channels, and last seen time.",
             parameters: { type: "object", properties: {} },
             async execute(_toolCallId, _params, _ctx) {
                 const peerIdentityMap = this.peerIdentityMap;
                 const localPeerId = mesh.getLocalPeerId();
                 const connectedPeers = mesh.getConnectedPeers();
-                const knownIdentities = connectedPeers
-                    .map((p) => {
-                    const identity = peerIdentityMap?.resolve(p);
-                    if (!identity)
-                        return null;
-                    return {
-                        instanceId: identity.instanceId || p.slice(0, 12) + "...",
+                const connectedSet = new Set(connectedPeers);
+                // Build full identity table from all known peers (not just connected)
+                const allPeers = [];
+                for (const [peerId, identity] of peerIdentityMap?.entries() ?? []) {
+                    if (peerId === localPeerId)
+                        continue; // skip local in peer list
+                    allPeers.push({
+                        peerId,
                         agentId: identity.agentId,
                         channel: identity.channel,
-                    };
-                })
-                    .filter(Boolean);
-                const text = `P2P Mesh Status:\nLocal Peer ID: ${localPeerId}\nConnected Peers: ${connectedPeers.length}\nKnown Identities: ${knownIdentities.length}`;
+                        instanceId: identity.instanceId,
+                        sessionKey: identity.sessionKey,
+                        status: connectedSet.has(peerId) ? "connected" : "known",
+                        lastSeen: identity.lastSeen,
+                    });
+                }
+                // Local identity
+                const localIdentity = peerIdentityMap?.getLocalIdentity();
+                const localInstanceId = localIdentity?.instanceId ?? "(not set)";
+                // Format output
+                const lines = [];
+                lines.push(`P2P Mesh Identity Table`);
+                lines.push(`Local: ${localPeerId.slice(0, 16)}... | Instance: ${localInstanceId}`);
+                lines.push(`Connected: ${connectedPeers.length} | Known total: ${allPeers.length}`);
+                lines.push("");
+                if (allPeers.length === 0) {
+                    lines.push("(no known peers yet)");
+                }
+                else {
+                    for (const p of allPeers) {
+                        const shortId = p.peerId.slice(0, 16) + "...";
+                        const time = p.lastSeen ? new Date(p.lastSeen).toLocaleTimeString() : "unknown";
+                        lines.push(`  [${p.status}] ${shortId}`);
+                        lines.push(`    Agent: ${p.agentId} | Channel: ${p.channel}`);
+                        lines.push(`    Instance: ${p.instanceId ?? "unknown"}`);
+                        lines.push(`    Last seen: ${time}`);
+                    }
+                }
+                const text = lines.join("\n");
                 return {
                     content: [{ type: "text", text }],
-                    details: { knownIdentities },
+                    details: {
+                        localPeerId,
+                        localInstanceId,
+                        connectedPeers: connectedPeers.length,
+                        knownPeers: allPeers,
+                    },
                 };
             },
         },

package/dist/src/peer-identity.d.ts

@@ -3,8 +3,12 @@ export interface PeerIdentity {
     channel: string;
     accountId: string;
     sessionKey: string;
-    /** Human-readable Instance ID (e.g. "alice-mac@AQIDBAU.7a3f9e2b") */
+    /** Human-readable Instance ID */
     instanceId?: string;
+    /** When this identity was first registered (epoch ms) */
+    firstSeen?: number;
+    /** Last time we saw this peer (epoch ms) */
+    lastSeen?: number;
 }
 export interface PeerIdentityMap {
     register(peerId: string, identity: PeerIdentity): void;
@@ -19,5 +23,9 @@ export interface PeerIdentityMap {
     getLocalIdentity(): PeerIdentity | undefined;
     hasIdentity(peerId: string): boolean;
     entries(): IterableIterator<[string, PeerIdentity]>;
+    /** Persist current state to disk */
+    save(): Promise<void>;
 }
-export declare function createPeerIdentityMap(): PeerIdentityMap;
+export declare function createPeerIdentityMap(storePath?: string): PeerIdentityMap & {
+    load(): Promise<void>;
+};

package/dist/src/peer-identity.js

@@ -1,14 +1,66 @@
-export function createPeerIdentityMap() {
+import { homedir } from "node:os";
+import path from "node:path";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+const DEFAULT_STORE_PATH = path.join(homedir(), ".openclaw", "libp2p", "peer-identities.json");
+export function createPeerIdentityMap(storePath) {
     const peers = new Map();
     const byInstanceId = new Map();
     let localPeerId;
     let localIdentity;
+    const filePath = storePath ?? DEFAULT_STORE_PATH;
+    async function save() {
+        const entries = {};
+        for (const [peerId, identity] of peers.entries()) {
+            entries[peerId] = identity;
+        }
+        const payload = {
+            localPeerId,
+            localIdentity,
+            peers: entries,
+            savedAt: Date.now(),
+        };
+        try {
+            await mkdir(path.dirname(filePath), { recursive: true });
+            await writeFile(filePath, JSON.stringify(payload, null, 2), "utf-8");
+        }
+        catch {
+            // Best-effort persistence; non-critical
+        }
+    }
+    async function load() {
+        try {
+            const raw = await readFile(filePath, "utf-8");
+            const data = JSON.parse(raw);
+            if (data.localPeerId)
+                localPeerId = data.localPeerId;
+            if (data.localIdentity)
+                localIdentity = data.localIdentity;
+            if (data.peers) {
+                for (const [peerId, identity] of Object.entries(data.peers)) {
+                    peers.set(peerId, identity);
+                    const id = identity.instanceId;
+                    if (id)
+                        byInstanceId.set(id, { peerId, identity: identity });
+                }
+            }
+        }
+        catch {
+            // File doesn't exist yet or is corrupt — start fresh
+        }
+    }
     return {
+        async save() { await save(); },
+        async load() { await load(); },
         register(peerId, identity) {
+            const now = Date.now();
+            const existing = peers.get(peerId);
+            identity.firstSeen = existing?.firstSeen ?? now;
+            identity.lastSeen = now;
             peers.set(peerId, identity);
             if (identity.instanceId) {
                 byInstanceId.set(identity.instanceId, { peerId, identity });
             }
+            save().catch(() => { });
         },
         resolve(peerId) {
             return peers.get(peerId);
@@ -25,14 +77,22 @@ export function createPeerIdentityMap() {
                 byInstanceId.delete(identity.instanceId);
             }
             peers.delete(peerId);
+            // Note: intentionally NOT saving on unregister — peer disconnects are
+            // often temporary (NAT timeout, network blip). Persisting the deletion
+            // would cause identity re-exchange on every reconnect. The entry will
+            // be refreshed when the peer reconnects and sends a new identity.
         },
         setLocalIdentity(peerId, identity) {
             localPeerId = peerId;
             localIdentity = identity;
+            const now = Date.now();
+            identity.firstSeen = now;
+            identity.lastSeen = now;
             peers.set(peerId, identity);
             if (identity.instanceId) {
                 byInstanceId.set(identity.instanceId, { peerId, identity });
             }
+            save().catch(() => { });
         },
         getLocalIdentity() {
             return localIdentity;

package/dist/src/plugin.js

@@ -24,6 +24,8 @@ export function registerLibp2pMesh(api) {
         id: "libp2p-mesh",
         start: async () => {
             await mesh.start();
+            // Load persisted peer identities from disk
+            await peerIdentityMap.load();
             // Gather local relay identity info
             const config = api.pluginConfig;
             const relayChannel = config?.relayChannel;

package/package.json

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

package/src/agent-tools.ts

@@ -278,27 +278,62 @@ export function buildP2PTools(mesh: MeshNetwork) {
     {
       name: "p2p_relay_status",
       label: "P2P Relay Status",
-      description: "Get current P2P mesh connection status, known peers, and identity mapping.",
+      description: "Get full P2P mesh identity table: local node info, all known peers (connected or not), their instance IDs, channels, and last seen time.",
       parameters: { type: "object" as const, properties: {} },
       async execute(_toolCallId: string, _params: {}, _ctx: any) {
         const peerIdentityMap = (this as any).peerIdentityMap;
         const localPeerId = mesh.getLocalPeerId();
         const connectedPeers = mesh.getConnectedPeers();
-        const knownIdentities = connectedPeers
-          .map((p) => {
-            const identity = peerIdentityMap?.resolve(p);
-            if (!identity) return null;
-            return {
-              instanceId: identity.instanceId || p.slice(0, 12) + "...",
-              agentId: identity.agentId,
-              channel: identity.channel,
-            };
-          })
-          .filter(Boolean);
-        const text = `P2P Mesh Status:\nLocal Peer ID: ${localPeerId}\nConnected Peers: ${connectedPeers.length}\nKnown Identities: ${knownIdentities.length}`;
+        const connectedSet = new Set(connectedPeers);
+
+        // Build full identity table from all known peers (not just connected)
+        const allPeers: { peerId: string; agentId: string; channel: string; instanceId?: string; sessionKey: string; status: string; lastSeen?: number }[] = [];
+        for (const [peerId, identity] of peerIdentityMap?.entries() ?? []) {
+          if (peerId === localPeerId) continue; // skip local in peer list
+          allPeers.push({
+            peerId,
+            agentId: identity.agentId,
+            channel: identity.channel,
+            instanceId: identity.instanceId,
+            sessionKey: identity.sessionKey,
+            status: connectedSet.has(peerId) ? "connected" : "known",
+            lastSeen: identity.lastSeen,
+          });
+        }
+
+        // Local identity
+        const localIdentity = peerIdentityMap?.getLocalIdentity();
+        const localInstanceId = localIdentity?.instanceId ?? "(not set)";
+
+        // Format output
+        const lines: string[] = [];
+        lines.push(`P2P Mesh Identity Table`);
+        lines.push(`Local: ${localPeerId.slice(0, 16)}... | Instance: ${localInstanceId}`);
+        lines.push(`Connected: ${connectedPeers.length} | Known total: ${allPeers.length}`);
+        lines.push("");
+
+        if (allPeers.length === 0) {
+          lines.push("(no known peers yet)");
+        } else {
+          for (const p of allPeers) {
+            const shortId = p.peerId.slice(0, 16) + "...";
+            const time = p.lastSeen ? new Date(p.lastSeen).toLocaleTimeString() : "unknown";
+            lines.push(`  [${p.status}] ${shortId}`);
+            lines.push(`    Agent: ${p.agentId} | Channel: ${p.channel}`);
+            lines.push(`    Instance: ${p.instanceId ?? "unknown"}`);
+            lines.push(`    Last seen: ${time}`);
+          }
+        }
+
+        const text = lines.join("\n");
         return {
           content: [{ type: "text" as const, text }],
-          details: { knownIdentities },
+          details: {
+            localPeerId,
+            localInstanceId,
+            connectedPeers: connectedPeers.length,
+            knownPeers: allPeers,
+          },
         };
       },
     },

package/src/peer-identity.ts

@@ -1,10 +1,18 @@
+import { homedir } from "node:os";
+import path from "node:path";
+import { readFile, writeFile, mkdir } from "node:fs/promises";
+
 export interface PeerIdentity {
   agentId: string;
   channel: string;
   accountId: string;
   sessionKey: string;
-  /** Human-readable Instance ID (e.g. "alice-mac@AQIDBAU.7a3f9e2b") */
+  /** Human-readable Instance ID */
   instanceId?: string;
+  /** When this identity was first registered (epoch ms) */
+  firstSeen?: number;
+  /** Last time we saw this peer (epoch ms) */
+  lastSeen?: number;
 }
 
 export interface PeerIdentityMap {
@@ -17,20 +25,71 @@ export interface PeerIdentityMap {
   getLocalIdentity(): PeerIdentity | undefined;
   hasIdentity(peerId: string): boolean;
   entries(): IterableIterator<[string, PeerIdentity]>;
+  /** Persist current state to disk */
+  save(): Promise<void>;
 }
 
-export function createPeerIdentityMap(): PeerIdentityMap {
+const DEFAULT_STORE_PATH = path.join(homedir(), ".openclaw", "libp2p", "peer-identities.json");
+
+export function createPeerIdentityMap(storePath?: string): PeerIdentityMap & { load(): Promise<void> } {
   const peers = new Map<string, PeerIdentity>();
   const byInstanceId = new Map<string, { peerId: string; identity: PeerIdentity }>();
   let localPeerId: string | undefined;
   let localIdentity: PeerIdentity | undefined;
+  const filePath = storePath ?? DEFAULT_STORE_PATH;
+
+  async function save(): Promise<void> {
+    const entries: Record<string, PeerIdentity> = {};
+    for (const [peerId, identity] of peers.entries()) {
+      entries[peerId] = identity;
+    }
+    const payload = {
+      localPeerId,
+      localIdentity,
+      peers: entries,
+      savedAt: Date.now(),
+    };
+    try {
+      await mkdir(path.dirname(filePath), { recursive: true });
+      await writeFile(filePath, JSON.stringify(payload, null, 2), "utf-8");
+    } catch {
+      // Best-effort persistence; non-critical
+    }
+  }
+
+  async function load(): Promise<void> {
+    try {
+      const raw = await readFile(filePath, "utf-8");
+      const data = JSON.parse(raw);
+      if (data.localPeerId) localPeerId = data.localPeerId;
+      if (data.localIdentity) localIdentity = data.localIdentity;
+      if (data.peers) {
+        for (const [peerId, identity] of Object.entries(data.peers)) {
+          peers.set(peerId, identity as PeerIdentity);
+          const id = (identity as PeerIdentity).instanceId;
+          if (id) byInstanceId.set(id, { peerId, identity: identity as PeerIdentity });
+        }
+      }
+    } catch {
+      // File doesn't exist yet or is corrupt — start fresh
+    }
+  }
 
   return {
+    async save() { await save(); },
+
+    async load() { await load(); },
+
     register(peerId: string, identity: PeerIdentity): void {
+      const now = Date.now();
+      const existing = peers.get(peerId);
+      identity.firstSeen = existing?.firstSeen ?? now;
+      identity.lastSeen = now;
       peers.set(peerId, identity);
       if (identity.instanceId) {
         byInstanceId.set(identity.instanceId, { peerId, identity });
       }
+      save().catch(() => {});
     },
 
     resolve(peerId: string): PeerIdentity | undefined {
@@ -51,15 +110,23 @@ export function createPeerIdentityMap(): PeerIdentityMap {
         byInstanceId.delete(identity.instanceId);
       }
       peers.delete(peerId);
+      // Note: intentionally NOT saving on unregister — peer disconnects are
+      // often temporary (NAT timeout, network blip). Persisting the deletion
+      // would cause identity re-exchange on every reconnect. The entry will
+      // be refreshed when the peer reconnects and sends a new identity.
     },
 
     setLocalIdentity(peerId: string, identity: PeerIdentity): void {
       localPeerId = peerId;
       localIdentity = identity;
+      const now = Date.now();
+      identity.firstSeen = now;
+      identity.lastSeen = now;
       peers.set(peerId, identity);
       if (identity.instanceId) {
         byInstanceId.set(identity.instanceId, { peerId, identity });
       }
+      save().catch(() => {});
     },
 
     getLocalIdentity(): PeerIdentity | undefined {

package/src/plugin.ts

@@ -33,6 +33,9 @@ export function registerLibp2pMesh(api: OpenClawPluginApi) {
     start: async () => {
       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;