libp2p-mesh 2026.6.1 → 2026.6.3

package/dist/index.js

@@ -99,6 +99,16 @@ function createLibp2pMeshConfigSchema() {
                     items: { type: "string" },
                     description: "Multiaddrs of relay nodes to reserve a slot on (each entry must end in /p2p/<peer-id>).",
                 },
+                relayChannel: {
+                    type: "string",
+                    deprecated: true,
+                    description: "Deprecated compatibility field from older libp2p-mesh versions. Use relayList for relay nodes.",
+                },
+                relayAccountId: {
+                    type: "string",
+                    deprecated: true,
+                    description: "Deprecated compatibility field from older libp2p-mesh versions. This value is ignored.",
+                },
                 discoverRelays: {
                     type: "number",
                     default: 0,

package/dist/src/inbound-delivery.d.ts

@@ -1,11 +1,13 @@
+import type { ChannelOutboundAdapter, OpenClawConfig } from "openclaw/plugin-sdk/core";
 import type { InboundDeliveryAdapter } from "./types.js";
 export type DeliveryLogger = {
     info?: (message: string) => void;
     debug?: (message: string) => void;
     warn?: (message: string) => void;
 };
-export declare function createOpenClawCliInboundDelivery(options?: {
-    command?: string;
-    timeoutMs?: number;
+export type LoadChannelOutboundAdapter = (channel: string) => Promise<ChannelOutboundAdapter | undefined>;
+export declare function createOpenClawRuntimeInboundDelivery(options: {
+    config: OpenClawConfig;
+    loadAdapter: LoadChannelOutboundAdapter;
     logger?: DeliveryLogger;
 }): InboundDeliveryAdapter;

package/dist/src/inbound-delivery.js

@@ -1,83 +1,41 @@
-import { spawn } from "node:child_process";
-export function createOpenClawCliInboundDelivery(options) {
-    const command = options?.command ?? "openclaw";
-    const timeoutMs = options?.timeoutMs ?? 15000;
-    const logger = options?.logger;
+function summarizeError(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+export function createOpenClawRuntimeInboundDelivery(options) {
+    const { config, loadAdapter, logger } = options;
     return {
-        deliver(request) {
-            const args = [
-                "message",
-                "send",
-                "--channel",
-                request.channel,
-                "--target",
-                request.target,
-                "--message",
-                request.text,
-            ];
-            logger?.debug?.(`[libp2p-mesh] Forwarding inbound delivery via CLI: ${command} ${args.join(" ")}`);
-            return new Promise((resolve) => {
-                const child = spawn(command, args, { stdio: ["ignore", "pipe", "pipe"] });
-                const stdout = [];
-                const stderr = [];
-                let settled = false;
-                let timeout;
-                const finish = (result) => {
-                    if (settled) {
-                        return;
-                    }
-                    settled = true;
-                    if (timeout) {
-                        clearTimeout(timeout);
-                    }
-                    resolve(result);
+        async deliver(request) {
+            logger?.debug?.(`[libp2p-mesh] Forwarding inbound delivery via runtime channel adapter: ${request.channel}/${request.target}`);
+            const adapter = await loadAdapter(request.channel);
+            if (!adapter?.sendText) {
+                return {
+                    ok: false,
+                    channel: request.channel,
+                    target: request.target,
+                    error: `channel ${request.channel} does not expose runtime text delivery`,
                 };
-                timeout = setTimeout(() => {
-                    logger?.warn?.(`[libp2p-mesh] Inbound delivery command timed out after ${timeoutMs}ms`);
-                    child.kill("SIGTERM");
-                    finish({
-                        ok: false,
-                        channel: request.channel,
-                        target: request.target,
-                        error: `openclaw message send timed out after ${timeoutMs}ms`,
-                    });
-                }, timeoutMs);
-                child.stdout.on("data", (chunk) => {
-                    stdout.push(chunk);
-                });
-                child.stderr.on("data", (chunk) => {
-                    stderr.push(chunk);
-                });
-                child.on("error", (err) => {
-                    finish({
-                        ok: false,
-                        channel: request.channel,
-                        target: request.target,
-                        error: String(err),
-                    });
+            }
+            try {
+                await adapter.sendText({
+                    cfg: config,
+                    to: request.target,
+                    text: request.text,
                 });
-                child.on("close", (code) => {
-                    if (code === 0) {
-                        logger?.info?.(`[libp2p-mesh] Delivered inbound message to ${request.channel}/${request.target}`);
-                        finish({
-                            ok: true,
-                            channel: request.channel,
-                            target: request.target,
-                        });
-                        return;
-                    }
-                    const stderrText = Buffer.concat(stderr).toString().trim();
-                    const stdoutText = Buffer.concat(stdout).toString().trim();
-                    finish({
-                        ok: false,
-                        channel: request.channel,
-                        target: request.target,
-                        error: stderrText ||
-                            stdoutText ||
-                            `openclaw message send exited with code ${code}`,
-                    });
-                });
-            });
+            }
+            catch (error) {
+                return {
+                    ok: false,
+                    channel: request.channel,
+                    target: request.target,
+                    error: summarizeError(error),
+                };
+            }
+            logger?.info?.(`[libp2p-mesh] Delivered inbound message to ${request.channel}/${request.target}`);
+            return {
+                ok: true,
+                channel: request.channel,
+                target: request.target,
+            };
         },
     };
 }

package/dist/src/plugin.js

@@ -1,6 +1,6 @@
 import { createLibp2pMeshChannel } from "./channel.js";
 import { handleP2PInbound } from "./inbound.js";
-import { createOpenClawCliInboundDelivery } from "./inbound-delivery.js";
+import { createOpenClawRuntimeInboundDelivery } from "./inbound-delivery.js";
 import { createInstancePeerStore } from "./instance-peer-store.js";
 import { createInstanceRouter } from "./instance-router.js";
 import { createMeshNetwork } from "./mesh.js";
@@ -14,7 +14,11 @@ export function registerLibp2pMesh(api) {
         logger: api.logger,
     });
     const store = createInstancePeerStore({ logger: api.logger });
-    const delivery = createOpenClawCliInboundDelivery({ logger: api.logger });
+    const delivery = createOpenClawRuntimeInboundDelivery({
+        config: api.config,
+        loadAdapter: api.runtime.channel.outbound.loadAdapter,
+        logger: api.logger,
+    });
     const router = createInstanceRouter({
         mesh,
         store,

package/dist/src/types.d.ts

@@ -162,6 +162,13 @@ export interface MeshConfig {
      * reservation open with each one so other peers can dial us through them.
      */
     relayList?: string[];
+    /**
+     * Deprecated pre-2026.6 config keys kept so existing OpenClaw configs keep
+     * validating after upgrade. Relay selection is now configured with
+     * `relayList`; inbound display uses `inboundChannel`/`inboundTarget`.
+     */
+    relayChannel?: string;
+    relayAccountId?: string;
     /**
      * Number of relays to auto-discover via content routing. Requires DHT.
      * Default `0` (disabled). Set to e.g. `2` to look up public relays.

package/index.ts

@@ -101,6 +101,16 @@ function createLibp2pMeshConfigSchema(): OpenClawPluginConfigSchema {
           items: { type: "string" },
           description: "Multiaddrs of relay nodes to reserve a slot on (each entry must end in /p2p/<peer-id>).",
         },
+        relayChannel: {
+          type: "string",
+          deprecated: true,
+          description: "Deprecated compatibility field from older libp2p-mesh versions. Use relayList for relay nodes.",
+        },
+        relayAccountId: {
+          type: "string",
+          deprecated: true,
+          description: "Deprecated compatibility field from older libp2p-mesh versions. This value is ignored.",
+        },
         discoverRelays: {
           type: "number",
           default: 0,

package/openclaw.plugin.json

@@ -4,6 +4,17 @@
     "onStartup": true
   },
   "channels": ["libp2p-mesh"],
+  "channelConfigs": {
+    "libp2p-mesh": {
+      "label": "P2P Mesh",
+      "description": "libp2p mesh network channel.",
+      "schema": {
+        "type": "object",
+        "additionalProperties": false,
+        "properties": {}
+      }
+    }
+  },
   "enabledByDefault": true,
   "name": "libp2p Mesh Network",
   "description": "P2P network for cross-instance agent communication via libp2p.",
@@ -91,6 +102,16 @@
         "items": { "type": "string" },
         "description": "Multiaddrs of relays to reserve a slot on (each entry must end in /p2p/<peer-id>)."
       },
+      "relayChannel": {
+        "type": "string",
+        "deprecated": true,
+        "description": "Deprecated compatibility field from older libp2p-mesh versions. Use relayList for relay nodes."
+      },
+      "relayAccountId": {
+        "type": "string",
+        "deprecated": true,
+        "description": "Deprecated compatibility field from older libp2p-mesh versions. This value is ignored."
+      },
       "discoverRelays": {
         "type": "number",
         "default": 0,

package/package.json

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

package/src/inbound-delivery.ts

@@ -1,4 +1,7 @@
-import { spawn } from "node:child_process";
+import type {
+  ChannelOutboundAdapter,
+  OpenClawConfig,
+} from "openclaw/plugin-sdk/core";
 import type {
   InboundDeliveryAdapter,
   InboundDeliveryRequest,
@@ -11,107 +14,60 @@ export type DeliveryLogger = {
   warn?: (message: string) => void;
 };
 
-export function createOpenClawCliInboundDelivery(options?: {
-  command?: string;
-  timeoutMs?: number;
+export type LoadChannelOutboundAdapter = (
+  channel: string,
+) => Promise<ChannelOutboundAdapter | undefined>;
+
+function summarizeError(error: unknown): string {
+  return error instanceof Error ? error.message : String(error);
+}
+
+export function createOpenClawRuntimeInboundDelivery(options: {
+  config: OpenClawConfig;
+  loadAdapter: LoadChannelOutboundAdapter;
   logger?: DeliveryLogger;
 }): InboundDeliveryAdapter {
-  const command = options?.command ?? "openclaw";
-  const timeoutMs = options?.timeoutMs ?? 15000;
-  const logger = options?.logger;
+  const { config, loadAdapter, logger } = options;
 
   return {
-    deliver(request: InboundDeliveryRequest): Promise<InboundDeliveryResult> {
-      const args = [
-        "message",
-        "send",
-        "--channel",
-        request.channel,
-        "--target",
-        request.target,
-        "--message",
-        request.text,
-      ];
-
+    async deliver(request: InboundDeliveryRequest): Promise<InboundDeliveryResult> {
       logger?.debug?.(
-        `[libp2p-mesh] Forwarding inbound delivery via CLI: ${command} ${args.join(" ")}`,
+        `[libp2p-mesh] Forwarding inbound delivery via runtime channel adapter: ${request.channel}/${request.target}`,
       );
 
-      return new Promise((resolve) => {
-        const child = spawn(command, args, { stdio: ["ignore", "pipe", "pipe"] });
-        const stdout: Buffer[] = [];
-        const stderr: Buffer[] = [];
-        let settled = false;
-        let timeout: ReturnType<typeof setTimeout> | undefined;
-
-        const finish = (result: InboundDeliveryResult): void => {
-          if (settled) {
-            return;
-          }
-          settled = true;
-          if (timeout) {
-            clearTimeout(timeout);
-          }
-          resolve(result);
+      const adapter = await loadAdapter(request.channel);
+      if (!adapter?.sendText) {
+        return {
+          ok: false,
+          channel: request.channel,
+          target: request.target,
+          error: `channel ${request.channel} does not expose runtime text delivery`,
         };
+      }
 
-        timeout = setTimeout(() => {
-          logger?.warn?.(
-            `[libp2p-mesh] Inbound delivery command timed out after ${timeoutMs}ms`,
-          );
-          child.kill("SIGTERM");
-          finish({
-            ok: false,
-            channel: request.channel,
-            target: request.target,
-            error: `openclaw message send timed out after ${timeoutMs}ms`,
-          });
-        }, timeoutMs);
-
-        child.stdout.on("data", (chunk: Buffer) => {
-          stdout.push(chunk);
-        });
-
-        child.stderr.on("data", (chunk: Buffer) => {
-          stderr.push(chunk);
-        });
-
-        child.on("error", (err) => {
-          finish({
-            ok: false,
-            channel: request.channel,
-            target: request.target,
-            error: String(err),
-          });
+      try {
+        await adapter.sendText({
+          cfg: config,
+          to: request.target,
+          text: request.text,
         });
+      } catch (error) {
+        return {
+          ok: false,
+          channel: request.channel,
+          target: request.target,
+          error: summarizeError(error),
+        };
+      }
 
-        child.on("close", (code) => {
-          if (code === 0) {
-            logger?.info?.(
-              `[libp2p-mesh] Delivered inbound message to ${request.channel}/${request.target}`,
-            );
-            finish({
-              ok: true,
-              channel: request.channel,
-              target: request.target,
-            });
-            return;
-          }
-
-          const stderrText = Buffer.concat(stderr).toString().trim();
-          const stdoutText = Buffer.concat(stdout).toString().trim();
-
-          finish({
-            ok: false,
-            channel: request.channel,
-            target: request.target,
-            error:
-              stderrText ||
-              stdoutText ||
-              `openclaw message send exited with code ${code}`,
-          });
-        });
-      });
+      logger?.info?.(
+        `[libp2p-mesh] Delivered inbound message to ${request.channel}/${request.target}`,
+      );
+      return {
+        ok: true,
+        channel: request.channel,
+        target: request.target,
+      };
     },
   };
 }

package/src/plugin.ts

@@ -1,7 +1,7 @@
 import type { OpenClawPluginApi } from "openclaw/plugin-sdk/core";
 import { createLibp2pMeshChannel } from "./channel.js";
 import { handleP2PInbound } from "./inbound.js";
-import { createOpenClawCliInboundDelivery } from "./inbound-delivery.js";
+import { createOpenClawRuntimeInboundDelivery } from "./inbound-delivery.js";
 import { createInstancePeerStore } from "./instance-peer-store.js";
 import { createInstanceRouter } from "./instance-router.js";
 import { createMeshNetwork } from "./mesh.js";
@@ -18,7 +18,11 @@ export function registerLibp2pMesh(api: OpenClawPluginApi) {
     logger: api.logger,
   });
   const store = createInstancePeerStore({ logger: api.logger });
-  const delivery = createOpenClawCliInboundDelivery({ logger: api.logger });
+  const delivery = createOpenClawRuntimeInboundDelivery({
+    config: api.config,
+    loadAdapter: api.runtime.channel.outbound.loadAdapter,
+    logger: api.logger,
+  });
   const router = createInstanceRouter({
     mesh,
     store,

package/src/types.ts

@@ -187,6 +187,13 @@ export interface MeshConfig {
    * reservation open with each one so other peers can dial us through them.
    */
   relayList?: string[];
+  /**
+   * Deprecated pre-2026.6 config keys kept so existing OpenClaw configs keep
+   * validating after upgrade. Relay selection is now configured with
+   * `relayList`; inbound display uses `inboundChannel`/`inboundTarget`.
+   */
+  relayChannel?: string;
+  relayAccountId?: string;
   /**
    * Number of relays to auto-discover via content routing. Requires DHT.
    * Default `0` (disabled). Set to e.g. `2` to look up public relays.