libp2p-mesh 2026.6.8 → 2026.6.10

package/dist/src/config-io.d.ts

@@ -1,5 +1,6 @@
 export declare const MULTIADDR_PATTERN: RegExp;
 export declare function getDefaultConfig(): Record<string, unknown>;
+export declare function validatePluginConfig(pluginConfig: Record<string, unknown>): void;
 export declare function resolveConfigPath(): string;
 export declare function readFullConfig(configPath: string): {
     config: Record<string, unknown>;

package/dist/src/config-io.js

@@ -22,6 +22,107 @@ export function getDefaultConfig() {
         deliveryAckTimeoutMs: 15000,
     };
 }
+const PLUGIN_CONFIG_SCHEMA = {
+    type: "object",
+    additionalProperties: false,
+    properties: {
+        listenAddrs: { type: "array", items: { type: "string" } },
+        enableWebSocket: { type: "boolean" },
+        discovery: { type: "string", enum: ["mdns", "bootstrap", "dht"] },
+        bootstrapList: { type: "array", items: { type: "string" } },
+        meshTopic: { type: "string" },
+        enablePubsub: { type: "boolean" },
+        enableAgentSync: { type: "boolean" },
+        enableDHT: { type: "boolean" },
+        instanceName: { type: "string" },
+        enableNATTraversal: { type: "boolean" },
+        enableIdentify: { type: "boolean" },
+        enableAutoNAT: { type: "boolean" },
+        enableUPnP: { type: "boolean" },
+        enableCircuitRelay: { type: "boolean" },
+        enableCircuitRelayServer: { type: "boolean" },
+        enableDCUtR: { type: "boolean" },
+        relayList: { type: "array", items: { type: "string" } },
+        relayChannel: { type: "string" },
+        relayAccountId: { type: "string" },
+        discoverRelays: { type: "number" },
+        announceAddrs: { type: "array", items: { type: "string" } },
+        inboundChannel: { type: "string" },
+        inboundTarget: { type: "string" },
+        inboundTargets: {
+            type: "array",
+            items: {
+                type: "object",
+                additionalProperties: false,
+                properties: {
+                    id: { type: "string" },
+                    channel: { type: "string" },
+                    target: { type: "string" },
+                },
+                required: ["channel", "target"],
+            },
+        },
+        deliveryAckTimeoutMs: { type: "number" },
+    },
+};
+function validateSchemaValue(value, schema, pathName) {
+    const errors = [];
+    if (value === undefined)
+        return errors;
+    if (schema.type === "object") {
+        if (!value || typeof value !== "object" || Array.isArray(value)) {
+            return [`${pathName}: expected object`];
+        }
+        const obj = value;
+        const properties = schema.properties ?? {};
+        for (const requiredKey of schema.required ?? []) {
+            if (obj[requiredKey] === undefined) {
+                errors.push(`${pathName}.${requiredKey}: required property is missing`);
+            }
+        }
+        if (schema.additionalProperties === false) {
+            for (const key of Object.keys(obj)) {
+                if (!properties[key]) {
+                    errors.push(`${pathName}: must not have additional property "${key}"`);
+                }
+            }
+        }
+        for (const [key, childSchema] of Object.entries(properties)) {
+            errors.push(...validateSchemaValue(obj[key], childSchema, `${pathName}.${key}`));
+        }
+        return errors;
+    }
+    if (schema.type === "array") {
+        if (!Array.isArray(value)) {
+            return [`${pathName}: expected array`];
+        }
+        if (schema.items) {
+            value.forEach((item, index) => {
+                errors.push(...validateSchemaValue(item, schema.items, `${pathName}[${index}]`));
+            });
+        }
+        return errors;
+    }
+    if (schema.type === "string" && typeof value !== "string") {
+        return [`${pathName}: expected string`];
+    }
+    if (schema.type === "boolean" && typeof value !== "boolean") {
+        return [`${pathName}: expected boolean`];
+    }
+    if (schema.type === "number" && (typeof value !== "number" || Number.isNaN(value))) {
+        return [`${pathName}: expected number`];
+    }
+    if (schema.enum && typeof value === "string" && !schema.enum.includes(value)) {
+        errors.push(`${pathName}: must be one of ${schema.enum.join(", ")}`);
+    }
+    return errors;
+}
+export function validatePluginConfig(pluginConfig) {
+    const errors = validateSchemaValue(pluginConfig, PLUGIN_CONFIG_SCHEMA, "plugins.entries.libp2p-mesh.config");
+    if (errors.length > 0) {
+        throw new Error(`libp2p-mesh 配置无效：\n  - ${errors.join("\n  - ")}`);
+    }
+}
 export function resolveConfigPath() {
     if (process.env.OPENCLAW_CONFIG_PATH) {
         const resolved = process.env.OPENCLAW_CONFIG_PATH.replace(/^~(?=$|\/|\\)/, os.homedir());
@@ -72,15 +173,6 @@ export function writeFullConfig(configPath, pluginConfigUpdates) {
             throw new Error(`无法读取 ${configPath}: ${err.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
@@ -105,20 +197,31 @@ export function writeFullConfig(configPath, pluginConfigUpdates) {
     }
     const existing = meshEntry.config;
     meshEntry.config = { ...existing, ...pluginConfigUpdates };
-    // Ensure channels["libp2p-mesh"].enabled exists
-    if (!output.channels ||
-        typeof output.channels !== "object" ||
-        Array.isArray(output.channels)) {
-        output.channels = {};
-    }
+    // Older wizard versions wrote channels["libp2p-mesh"].enabled, but the
+    // channel schema does not allow that field. Clean it up when saving.
     const channels = output.channels;
-    if (!channels["libp2p-mesh"] ||
-        typeof channels["libp2p-mesh"] !== "object" ||
-        Array.isArray(channels["libp2p-mesh"])) {
-        channels["libp2p-mesh"] = {};
+    if (channels && typeof channels === "object" && !Array.isArray(channels)) {
+        const channelMap = channels;
+        const meshChannel = channelMap["libp2p-mesh"];
+        if (meshChannel &&
+            typeof meshChannel === "object" &&
+            !Array.isArray(meshChannel)) {
+            delete meshChannel.enabled;
+            if (Object.keys(meshChannel).length === 0) {
+                delete channelMap["libp2p-mesh"];
+            }
+        }
+    }
+    validatePluginConfig(meshEntry.config);
+    // Create backup after validation so invalid config never mutates files.
+    try {
+        if (fs.existsSync(configPath)) {
+            fs.copyFileSync(configPath, configPath + ".bak");
+        }
+    }
+    catch {
+        console.warn("备份 openclaw.json 失败，继续写入。");
     }
-    const meshChannel = channels["libp2p-mesh"];
-    meshChannel.enabled = true;
     // Write atomically (write to temp, then rename)
     const tmpPath = configPath + ".tmp";
     try {

package/dist/src/wizard.js

@@ -95,7 +95,6 @@ function interactiveSelect(prompt, choices) {
     return new Promise((resolve) => {
         const wasRaw = process.stdin.isRaw;
         const wasPaused = process.stdin.isPaused();
-        let resolved = false;
         const onKeypress = (_str, key) => {
             if (!key || !key.name)
                 return;
@@ -109,7 +108,6 @@ function interactiveSelect(prompt, choices) {
                 reRenderChoices(choices, selectedIdx);
             }
             else if (key.name === "return" || key.name === "space") {
-                resolved = true;
                 const chosen = choices[selectedIdx];
                 cleanup();
                 eraseChoices(choices.length);
@@ -123,8 +121,6 @@ function interactiveSelect(prompt, choices) {
             }
         };
         const cleanup = () => {
-            if (resolved)
-                return;
             try {
                 // Always restore to non-raw so subsequent readline works
                 process.stdin.setRawMode(false);

package/package.json

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

package/src/config-io.ts

@@ -25,6 +25,121 @@ export function getDefaultConfig(): Record<string, unknown> {
   };
 }
 
+type JsonSchema = {
+  type?: "object" | "array" | "string" | "boolean" | "number";
+  enum?: string[];
+  additionalProperties?: boolean;
+  properties?: Record<string, JsonSchema>;
+  items?: JsonSchema;
+  required?: string[];
+};
+
+const PLUGIN_CONFIG_SCHEMA: JsonSchema = {
+  type: "object",
+  additionalProperties: false,
+  properties: {
+    listenAddrs: { type: "array", items: { type: "string" } },
+    enableWebSocket: { type: "boolean" },
+    discovery: { type: "string", enum: ["mdns", "bootstrap", "dht"] },
+    bootstrapList: { type: "array", items: { type: "string" } },
+    meshTopic: { type: "string" },
+    enablePubsub: { type: "boolean" },
+    enableAgentSync: { type: "boolean" },
+    enableDHT: { type: "boolean" },
+    instanceName: { type: "string" },
+    enableNATTraversal: { type: "boolean" },
+    enableIdentify: { type: "boolean" },
+    enableAutoNAT: { type: "boolean" },
+    enableUPnP: { type: "boolean" },
+    enableCircuitRelay: { type: "boolean" },
+    enableCircuitRelayServer: { type: "boolean" },
+    enableDCUtR: { type: "boolean" },
+    relayList: { type: "array", items: { type: "string" } },
+    relayChannel: { type: "string" },
+    relayAccountId: { type: "string" },
+    discoverRelays: { type: "number" },
+    announceAddrs: { type: "array", items: { type: "string" } },
+    inboundChannel: { type: "string" },
+    inboundTarget: { type: "string" },
+    inboundTargets: {
+      type: "array",
+      items: {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          id: { type: "string" },
+          channel: { type: "string" },
+          target: { type: "string" },
+        },
+        required: ["channel", "target"],
+      },
+    },
+    deliveryAckTimeoutMs: { type: "number" },
+  },
+};
+
+function validateSchemaValue(value: unknown, schema: JsonSchema, pathName: string): string[] {
+  const errors: string[] = [];
+  if (value === undefined) return errors;
+
+  if (schema.type === "object") {
+    if (!value || typeof value !== "object" || Array.isArray(value)) {
+      return [`${pathName}: expected object`];
+    }
+    const obj = value as Record<string, unknown>;
+    const properties = schema.properties ?? {};
+    for (const requiredKey of schema.required ?? []) {
+      if (obj[requiredKey] === undefined) {
+        errors.push(`${pathName}.${requiredKey}: required property is missing`);
+      }
+    }
+    if (schema.additionalProperties === false) {
+      for (const key of Object.keys(obj)) {
+        if (!properties[key]) {
+          errors.push(`${pathName}: must not have additional property "${key}"`);
+        }
+      }
+    }
+    for (const [key, childSchema] of Object.entries(properties)) {
+      errors.push(...validateSchemaValue(obj[key], childSchema, `${pathName}.${key}`));
+    }
+    return errors;
+  }
+
+  if (schema.type === "array") {
+    if (!Array.isArray(value)) {
+      return [`${pathName}: expected array`];
+    }
+    if (schema.items) {
+      value.forEach((item, index) => {
+        errors.push(...validateSchemaValue(item, schema.items!, `${pathName}[${index}]`));
+      });
+    }
+    return errors;
+  }
+
+  if (schema.type === "string" && typeof value !== "string") {
+    return [`${pathName}: expected string`];
+  }
+  if (schema.type === "boolean" && typeof value !== "boolean") {
+    return [`${pathName}: expected boolean`];
+  }
+  if (schema.type === "number" && (typeof value !== "number" || Number.isNaN(value))) {
+    return [`${pathName}: expected number`];
+  }
+  if (schema.enum && typeof value === "string" && !schema.enum.includes(value)) {
+    errors.push(`${pathName}: must be one of ${schema.enum.join(", ")}`);
+  }
+  return errors;
+}
+
+export function validatePluginConfig(pluginConfig: Record<string, unknown>): void {
+  const errors = validateSchemaValue(pluginConfig, PLUGIN_CONFIG_SCHEMA, "plugins.entries.libp2p-mesh.config");
+  if (errors.length > 0) {
+    throw new Error(`libp2p-mesh 配置无效：\n  - ${errors.join("\n  - ")}`);
+  }
+}
+
 export function resolveConfigPath(): string {
   if (process.env.OPENCLAW_CONFIG_PATH) {
     const resolved = process.env.OPENCLAW_CONFIG_PATH.replace(/^~(?=$|\/|\\)/, os.homedir());
@@ -92,15 +207,6 @@ export function writeFullConfig(
     }
   }
 
-  // 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 : {},
@@ -132,24 +238,34 @@ export function writeFullConfig(
   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 = {};
+  // Older wizard versions wrote channels["libp2p-mesh"].enabled, but the
+  // channel schema does not allow that field. Clean it up when saving.
+  const channels = output.channels;
+  if (channels && typeof channels === "object" && !Array.isArray(channels)) {
+    const channelMap = channels as Record<string, unknown>;
+    const meshChannel = channelMap["libp2p-mesh"];
+    if (
+      meshChannel &&
+      typeof meshChannel === "object" &&
+      !Array.isArray(meshChannel)
+    ) {
+      delete (meshChannel as Record<string, unknown>).enabled;
+      if (Object.keys(meshChannel).length === 0) {
+        delete channelMap["libp2p-mesh"];
+      }
+    }
   }
-  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"] = {};
+
+  validatePluginConfig(meshEntry.config as Record<string, unknown>);
+
+  // Create backup after validation so invalid config never mutates files.
+  try {
+    if (fs.existsSync(configPath)) {
+      fs.copyFileSync(configPath, configPath + ".bak");
+    }
+  } catch {
+    console.warn("备份 openclaw.json 失败，继续写入。");
   }
-  const meshChannel = channels["libp2p-mesh"] as Record<string, unknown>;
-  meshChannel.enabled = true;
 
   // Write atomically (write to temp, then rename)
   const tmpPath = configPath + ".tmp";

package/src/wizard.ts

@@ -149,8 +149,6 @@ function interactiveSelect(
     const wasRaw = process.stdin.isRaw;
     const wasPaused = process.stdin.isPaused();
 
-    let resolved = false;
-
     const onKeypress = (
       _str: string | undefined,
       key: { name?: string; ctrl?: boolean },
@@ -165,7 +163,6 @@ function interactiveSelect(
         selectedIdx = (selectedIdx + 1) % choices.length;
         reRenderChoices(choices, selectedIdx);
       } else if (key.name === "return" || key.name === "space") {
-        resolved = true;
         const chosen = choices[selectedIdx]!;
         cleanup();
         eraseChoices(choices.length);
@@ -179,7 +176,6 @@ function interactiveSelect(
     };
 
     const cleanup = () => {
-      if (resolved) return;
       try {
         // Always restore to non-raw so subsequent readline works
         process.stdin.setRawMode(false);