libp2p-mesh 2026.6.2 → 2026.6.4

package/src/cli.ts

@@ -0,0 +1,226 @@
+import type { PluginLogger } from "openclaw/plugin-sdk/core";
+import {
+  resolveConfigPath,
+  readFullConfig,
+  writeFullConfig,
+  getNonDefaultConfig,
+  getDefaultConfig,
+} from "./config-io.js";
+import {
+  createReadlinePrompter,
+  runSetupWizard,
+  WizardCancelledError,
+} from "./wizard.js";
+
+// OpenClawPluginCliContext is defined in openclaw's types.d.ts but not re-exported
+// from the public SDK barrel modules at this version. Define the shape locally.
+interface MinimalCommand {
+  command(name: string): MinimalCommand;
+  description(desc: string): MinimalCommand;
+  option(flags: string, description?: string): MinimalCommand;
+  action(fn: (...args: any[]) => void | Promise<void>): MinimalCommand;
+}
+interface OpenClawPluginCliContext {
+  program: MinimalCommand;
+  config: Record<string, unknown>;
+  workspaceDir?: string;
+  logger: PluginLogger;
+}
+
+export function registerLibp2pMeshCli(ctx: OpenClawPluginCliContext): void {
+  const { program, config: openclawConfig } = ctx;
+
+  const meshCmd = program
+    .command("libp2p-mesh")
+    .description("P2P Mesh 网络插件配置管理");
+
+  // ---- setup ----
+  meshCmd
+    .command("setup")
+    .description("交互式配置向导")
+    .action(async () => {
+      const configPath = resolveConfigPath();
+      const { pluginConfig } = readFullConfig(configPath);
+
+      // Discover available chat channels from config
+      const channels = openclawConfig.channels;
+      const availableChannels: string[] = [];
+      if (channels && typeof channels === "object" && !Array.isArray(channels)) {
+        for (const [id, entry] of Object.entries(channels as Record<string, unknown>)) {
+          if (
+            id !== "libp2p-mesh" &&
+            entry &&
+            typeof entry === "object" &&
+            (entry as Record<string, unknown>).enabled !== false
+          ) {
+            availableChannels.push(id);
+          }
+        }
+      }
+
+      const prompter = createReadlinePrompter();
+      try {
+        const newConfig = await runSetupWizard(prompter, pluginConfig, availableChannels);
+        writeFullConfig(configPath, newConfig);
+        console.log(`\n✓ 配置已写入 ${configPath}`);
+        console.log("  运行 openclaw gateway restart 使新配置生效。");
+      } catch (err) {
+        if (err instanceof WizardCancelledError) {
+          process.exit(0);
+        }
+        if (err instanceof Error) {
+          console.error(`\n✗ ${err.message}`);
+        }
+        process.exit(1);
+      } finally {
+        prompter.close();
+      }
+    });
+
+  // ---- config subcommand ----
+  const configCmd = meshCmd
+    .command("config")
+    .description("增量配置管理");
+
+  // ---- config list ----
+  configCmd
+    .command("list")
+    .description("列出当前所有非默认配置")
+    .action(() => {
+      const configPath = resolveConfigPath();
+      const { pluginConfig } = readFullConfig(configPath);
+      const nonDefault = getNonDefaultConfig(pluginConfig);
+      const keys = Object.keys(nonDefault);
+
+      if (keys.length === 0) {
+        console.log("当前无自定义配置，全部使用默认值。");
+        console.log("运行 openclaw libp2p-mesh setup 进行配置。");
+        return;
+      }
+
+      console.log("─────────────────────────────────");
+      console.log("  当前 libp2p-mesh 配置：\n");
+      for (const key of keys) {
+        const value = nonDefault[key];
+        if (Array.isArray(value)) {
+          console.log(`  ${key}:`);
+          if (value.length === 0) {
+            console.log("    （空列表）");
+          } else {
+            for (const item of value) {
+              if (typeof item === "object" && item !== null) {
+                const obj = item as Record<string, unknown>;
+                const label = obj.id ? `${obj.id} — ` : "";
+                console.log(`    - ${label}${obj.channel ?? ""} / ${obj.target ?? ""}`);
+              } else {
+                console.log(`    - ${item}`);
+              }
+            }
+          }
+        } else {
+          console.log(`  ${key}:  ${value}`);
+        }
+      }
+      console.log(`\n  ...共 ${keys.length} 项非默认配置`);
+    });
+
+  // ---- config get ----
+  configCmd
+    .command("get <key>")
+    .description("读取单个配置值")
+    .action((key: string) => {
+      const configPath = resolveConfigPath();
+      const { pluginConfig } = readFullConfig(configPath);
+      const defaults = getDefaultConfig();
+      const value = key in pluginConfig ? pluginConfig[key] : defaults[key];
+      if (value === undefined) {
+        console.log(`  （未配置）`);
+      } else if (Array.isArray(value)) {
+        if (value.length === 0) {
+          console.log("  （空列表）");
+        } else {
+          for (const item of value) {
+            if (typeof item === "object" && item !== null) {
+              console.log(JSON.stringify(item, null, 2));
+            } else {
+              console.log(`  ${item}`);
+            }
+          }
+        }
+      } else {
+        console.log(`  ${value}`);
+      }
+    });
+
+  // ---- config set ----
+  configCmd
+    .command("set <key> [value]")
+    .description("设置配置值。数组类型使用 --add / --remove")
+    .option("--add <item>", "追加到数组")
+    .option("--remove <item>", "从数组中移除")
+    .action(async (key: string, value: string | undefined, opts: { add?: string; remove?: string }) => {
+      const configPath = resolveConfigPath();
+      const { pluginConfig } = readFullConfig(configPath);
+      const defaults = getDefaultConfig();
+      const current = key in pluginConfig ? pluginConfig[key] : defaults[key];
+      const oldValue = current;
+
+      let newValue: unknown;
+
+      // Array operations
+      if (opts.add || opts.remove) {
+        const arr: unknown[] = Array.isArray(current) ? [...current] : [];
+        if (opts.add) {
+          if (arr.includes(opts.add)) {
+            console.log(`  ⚠ 该值已存在`);
+            return;
+          }
+          arr.push(opts.add);
+          console.log(`  ✓ 已追加`);
+        }
+        if (opts.remove) {
+          const idx = arr.indexOf(opts.remove);
+          if (idx === -1) {
+            console.log(`  ⚠ 未找到该值`);
+            return;
+          }
+          arr.splice(idx, 1);
+          console.log(`  ✓ 已移除`);
+        }
+        newValue = arr;
+      } else {
+        // Scalar
+        if (value === undefined) {
+          console.error("  请提供值。用法: openclaw libp2p-mesh config set <key> <value>");
+          process.exit(1);
+        }
+        // Auto-detect boolean and number
+        if (value === "true") newValue = true;
+        else if (value === "false") newValue = false;
+        else if (/^-?\d+(\.\d+)?$/.test(value)) newValue = Number(value);
+        else newValue = value;
+      }
+
+      // Write
+      const updates = { ...pluginConfig, [key]: newValue };
+      writeFullConfig(configPath, updates);
+
+      // Feedback
+      if (!opts.add && !opts.remove) {
+        console.log(`  ✓ ${key}: ${JSON.stringify(oldValue)} → ${JSON.stringify(newValue)}`);
+      }
+    });
+
+  // ---- config unset ----
+  configCmd
+    .command("unset <key>")
+    .description("删除 key，恢复默认值")
+    .action((key: string) => {
+      const configPath = resolveConfigPath();
+      const { pluginConfig } = readFullConfig(configPath);
+      const newConfig = { ...pluginConfig };
+      delete newConfig[key];
+      writeFullConfig(configPath, newConfig);
+      console.log(`  ✓ ${key} 已恢复为默认值`);
+    });
+}

package/src/config-io.ts

@@ -0,0 +1,204 @@
+import fs from "node:fs";
+import path from "node:path";
+import os from "node:os";
+
+export const MULTIADDR_PATTERN = /^(\/ip[46]\/(?:[\d.]+|[0-9a-fA-F:]+)|\/dns(?:[46])?\/[a-zA-Z0-9][a-zA-Z0-9.-]*)\/(?:tcp|udp|ws|wss)\/\d+(?:\/p2p\/[12][a-zA-Z2-7]{48,})?$/;
+
+export function getDefaultConfig(): Record<string, unknown> {
+  return {
+    listenAddrs: ["/ip4/0.0.0.0/tcp/0"],
+    enableWebSocket: false,
+    discovery: "mdns",
+    meshTopic: "openclaw-mesh",
+    enablePubsub: true,
+    enableAgentSync: true,
+    enableDHT: true,
+    enableNATTraversal: true,
+    enableIdentify: true,
+    enableAutoNAT: true,
+    enableUPnP: true,
+    enableCircuitRelay: true,
+    enableCircuitRelayServer: false,
+    enableDCUtR: true,
+    discoverRelays: 0,
+    deliveryAckTimeoutMs: 15000,
+  };
+}
+
+export function resolveConfigPath(): string {
+  if (process.env.OPENCLAW_CONFIG_PATH) {
+    const resolved = process.env.OPENCLAW_CONFIG_PATH.replace(/^~(?=$|\/|\\)/, os.homedir());
+    return path.resolve(resolved);
+  }
+  const stateDir = process.env.OPENCLAW_STATE_DIR
+    ? process.env.OPENCLAW_STATE_DIR.replace(/^~(?=$|\/|\\)/, os.homedir())
+    : path.join(os.homedir(), ".openclaw");
+  return path.join(stateDir, "openclaw.json");
+}
+
+export function readFullConfig(configPath: string): {
+  config: Record<string, unknown>;
+  pluginConfig: Record<string, unknown>;
+} {
+  let raw: Record<string, unknown>;
+  try {
+    raw = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+  } catch (err: unknown) {
+    if ((err as NodeJS.ErrnoException).code === "ENOENT") {
+      return { config: {}, pluginConfig: {} };
+    }
+    throw new Error(
+      `无法解析 ${configPath}: ${(err as Error).message}\n请手动修复 JSON 格式后重试。`,
+    );
+  }
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) {
+    throw new Error(`${configPath} 内容不是合法的 JSON 对象。`);
+  }
+
+  const plugins = (raw as Record<string, unknown>).plugins;
+  const entries =
+    plugins && typeof plugins === "object" && !Array.isArray(plugins)
+      ? (plugins as Record<string, unknown>).entries
+      : undefined;
+  const entry =
+    entries && typeof entries === "object" && !Array.isArray(entries)
+      ? (entries as Record<string, unknown>)["libp2p-mesh"]
+      : undefined;
+  const pluginConfig =
+    entry && typeof entry === "object" && !Array.isArray(entry)
+      ? ((entry as Record<string, unknown>).config as Record<string, unknown>) ?? {}
+      : {};
+
+  return { config: raw as Record<string, unknown>, pluginConfig };
+}
+
+export function writeFullConfig(
+  configPath: string,
+  pluginConfigUpdates: Record<string, unknown>,
+): void {
+  // Ensure directory exists
+  const dir = path.dirname(configPath);
+  fs.mkdirSync(dir, { recursive: true });
+
+  // Read existing or start fresh
+  let base: Record<string, unknown> = {};
+  try {
+    base = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+  } catch (err: unknown) {
+    if ((err as NodeJS.ErrnoException).code !== "ENOENT") {
+      throw new Error(
+        `无法读取 ${configPath}: ${(err as Error).message}`,
+      );
+    }
+  }
+
+  // Create backup
+  try {
+    if (fs.existsSync(configPath)) {
+      fs.copyFileSync(configPath, configPath + ".bak");
+    }
+  } catch {
+    console.warn("备份 openclaw.json 失败，继续写入。");
+  }
+
+  // Build output object with deep merge
+  const output = structuredClone(
+    typeof base === "object" && !Array.isArray(base) ? base : {},
+  );
+
+  // Ensure plugins.entries["libp2p-mesh"] exists
+  if (!output.plugins || typeof output.plugins !== "object" || Array.isArray(output.plugins)) {
+    output.plugins = {};
+  }
+  const plugins = output.plugins as Record<string, unknown>;
+  if (!plugins.entries || typeof plugins.entries !== "object" || Array.isArray(plugins.entries)) {
+    plugins.entries = {};
+  }
+  const entries = plugins.entries as Record<string, unknown>;
+  if (
+    !entries["libp2p-mesh"] ||
+    typeof entries["libp2p-mesh"] !== "object" ||
+    Array.isArray(entries["libp2p-mesh"])
+  ) {
+    entries["libp2p-mesh"] = {};
+  }
+  const meshEntry = entries["libp2p-mesh"] as Record<string, unknown>;
+  meshEntry.enabled = true;
+
+  // Merge plugin config shallowly (key-level)
+  if (!meshEntry.config || typeof meshEntry.config !== "object" || Array.isArray(meshEntry.config)) {
+    meshEntry.config = {};
+  }
+  const existing = meshEntry.config as Record<string, unknown>;
+  meshEntry.config = { ...existing, ...pluginConfigUpdates };
+
+  // Ensure channels["libp2p-mesh"].enabled exists
+  if (
+    !output.channels ||
+    typeof output.channels !== "object" ||
+    Array.isArray(output.channels)
+  ) {
+    output.channels = {};
+  }
+  const channels = output.channels as Record<string, unknown>;
+  if (
+    !channels["libp2p-mesh"] ||
+    typeof channels["libp2p-mesh"] !== "object" ||
+    Array.isArray(channels["libp2p-mesh"])
+  ) {
+    channels["libp2p-mesh"] = {};
+  }
+  const meshChannel = channels["libp2p-mesh"] as Record<string, unknown>;
+  meshChannel.enabled = true;
+
+  // Write atomically (write to temp, then rename)
+  const tmpPath = configPath + ".tmp";
+  try {
+    fs.writeFileSync(tmpPath, JSON.stringify(output, null, 2) + "\n", "utf-8");
+    fs.renameSync(tmpPath, configPath);
+  } catch (err: unknown) {
+    // Rollback from backup
+    try {
+      if (fs.existsSync(configPath + ".bak")) {
+        fs.copyFileSync(configPath + ".bak", configPath);
+      }
+    } catch {
+      // rollback failure — leave existing state
+    }
+    // Clean up temp
+    try {
+      fs.unlinkSync(tmpPath);
+    } catch {
+      // ok
+    }
+    throw new Error(
+      `写入 ${configPath} 失败：${(err as Error).message}。配置未更改。`,
+    );
+  }
+}
+
+export function getNonDefaultConfig(
+  pluginConfig: Record<string, unknown>,
+): Record<string, unknown> {
+  const defaults = getDefaultConfig();
+  const result: Record<string, unknown> = {};
+  for (const key of Object.keys(pluginConfig)) {
+    const value = pluginConfig[key];
+    if (value === undefined) continue;
+    if (!(key in defaults)) {
+      // Unknown key — include (could be a new key added in later version)
+      result[key] = value;
+      continue;
+    }
+    const def = defaults[key];
+    if (Array.isArray(value) && Array.isArray(def)) {
+      if (value.length === 0 && def.length > 0) continue;
+      if (value.length !== def.length || value.some((v, i) => v !== def[i])) {
+        result[key] = value;
+      }
+    } else if (value !== def) {
+      result[key] = value;
+    }
+  }
+  return result;
+}

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/inbound.ts

@@ -8,10 +8,11 @@ export type InboundHandlerDeps = {
     warn?: (msg: string) => void;
     error?: (msg: string) => void;
   };
+  sendToChannel?: (channelId: string, target: string, text: string) => Promise<void>;
 };
 
 export function handleP2PInbound(msg: P2PMessage, deps: InboundHandlerDeps): void {
-  const { logger } = deps;
+  const { logger, sendToChannel } = deps;
   const instanceTag = msg.instanceId ? ` [instance: ${msg.instanceId}]` : "";
   const signedTag = msg.signature ? " [signed]" : "";
 
@@ -45,9 +46,20 @@ export function handleP2PInbound(msg: P2PMessage, deps: InboundHandlerDeps): voi
     logger?.info?.(
       `[libp2p-mesh] Broadcast from ${msg.from}${instanceTag}${signedTag} on topic ${msg.topic ?? "(none)"}: ${msg.payload}`,
     );
-  } else {
-    logger?.info?.(
-      `[libp2p-mesh] Direct message from ${msg.from}${instanceTag}${signedTag}: ${msg.payload}`,
-    );
+    return;
+  }
+
+  // Direct message — log and forward to local channel
+  logger?.info?.(
+    `[libp2p-mesh] Direct message from ${msg.from}${instanceTag}${signedTag}: ${msg.payload}`,
+  );
+
+  if (!sendToChannel || !msg.payload) {
+    return;
   }
+
+  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}`);
+  });
 }