clawmatrix 0.1.17 → 0.1.19

package/openclaw.plugin.json

@@ -5,73 +5,7 @@
   "providers": ["clawmatrix"],
   "configSchema": {
     "type": "object",
-    "properties": {
-      "nodeId": { "type": "string" },
-      "secret": { "type": "string" },
-      "listen": { "type": "boolean", "default": false },
-      "listenHost": { "type": "string", "default": "0.0.0.0" },
-      "listenPort": { "type": "number", "default": 19000 },
-      "peers": {
-        "type": "array",
-        "items": {
-          "type": "object",
-          "properties": {
-            "nodeId": { "type": "string" },
-            "url": { "type": "string" }
-          },
-          "required": ["nodeId", "url"]
-        },
-        "default": []
-      },
-      "agents": {
-        "type": "array",
-        "items": {
-          "type": "object",
-          "properties": {
-            "id": { "type": "string" },
-            "description": { "type": "string" },
-            "tags": { "type": "array", "items": { "type": "string" }, "default": [] }
-          },
-          "required": ["id", "description"]
-        },
-        "default": []
-      },
-      "models": {
-        "type": "array",
-        "items": {
-          "type": "object",
-          "properties": {
-            "id": { "type": "string" },
-            "provider": { "type": "string" },
-            "description": { "type": "string" }
-          },
-          "required": ["id", "provider"]
-        },
-        "default": []
-      },
-      "tags": { "type": "array", "items": { "type": "string" }, "default": [] },
-      "proxyPort": { "type": "number", "default": 19001 },
-      "toolProxy": {
-        "type": "object",
-        "properties": {
-          "enabled": { "type": "boolean", "default": false },
-          "allow": {
-            "type": "array",
-            "items": { "type": "string" },
-            "default": [],
-            "description": "Allowed OpenClaw tool names. Use [\"*\"] for all. Empty or [\"*\"] = all allowed."
-          },
-          "deny": {
-            "type": "array",
-            "items": { "type": "string" },
-            "default": [],
-            "description": "Denied OpenClaw tool names (takes precedence over allow)."
-          },
-          "maxOutputBytes": { "type": "number", "default": 1048576 }
-        }
-      }
-    },
-    "required": ["nodeId", "secret"]
+    "additionalProperties": true
   },
   "uiHints": {
     "secret": { "sensitive": true, "label": "Cluster Secret", "help": "Shared secret for HMAC authentication between nodes" },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawmatrix",
-  "version": "0.1.17",
+  "version": "0.1.19",
   "description": "Decentralized mesh cluster plugin for OpenClaw — inter-gateway communication, model proxy, task handoff, and tool proxy.",
   "type": "module",
   "license": "MIT",
@@ -32,9 +32,11 @@
     "release": "bunx bumpp"
   },
   "dependencies": {
+    "@automerge/automerge": "^3.2.4",
+    "@mariozechner/pi-coding-agent": ">=0.55.0",
+    "ignore": "^7.0.5",
     "ws": "^8.19.0",
-    "zod": "^4.3.6",
-    "@mariozechner/pi-coding-agent": ">=0.55.0"
+    "zod": "^4.3.6"
   },
   "devDependencies": {
     "@types/bun": "latest",

package/src/cluster-service.ts

@@ -4,6 +4,7 @@ import type {
   OpenClawConfig,
   PluginLogger,
 } from "openclaw/plugin-sdk";
+import path from "node:path";
 import type { ClawMatrixConfig } from "./config.ts";
 import { spawnProcess } from "./compat.ts";
 import { debug } from "./debug.ts";
@@ -12,6 +13,7 @@ import { HandoffManager } from "./handoff.ts";
 import { ModelProxy } from "./model-proxy.ts";
 import { ToolProxy, type GatewayInfo } from "./tool-proxy.ts";
 import { WebHandler } from "./web.ts";
+import { KnowledgeSync } from "./knowledge-sync.ts";
 import type {
   AnyClusterFrame,
   HandoffRequest,
@@ -22,6 +24,7 @@ import type {
   HandoffStatusResponse,
   HandoffInputRequired,
   HandoffInput,
+  KnowledgeSyncFrame,
   ModelRequest,
   ModelResponse,
   ModelStreamChunk,
@@ -49,12 +52,15 @@ export class ClusterRuntime {
   readonly handoffManager: HandoffManager;
   readonly modelProxy: ModelProxy;
   readonly toolProxy: ToolProxy;
+  knowledgeSync: KnowledgeSync | null = null;
   webHandler: WebHandler | null = null;
   private logger: PluginLogger;
+  private openclawConfig: OpenClawConfig;
 
   constructor(config: ClawMatrixConfig, logger: PluginLogger, openclawConfig: OpenClawConfig, openclawVersion?: string) {
     this.config = config;
     this.logger = logger;
+    this.openclawConfig = openclawConfig;
     const gatewayInfo = resolveGatewayInfo(openclawConfig);
     this.peerManager = new PeerManager(config, openclawVersion);
     this.handoffManager = new HandoffManager(config, this.peerManager);
@@ -85,6 +91,34 @@ export class ClusterRuntime {
       this.logger.info(`[clawmatrix] Web dashboard enabled on listen port`);
     }
 
+    // Knowledge sync
+    if (this.config.knowledge?.enabled) {
+      const workspacePath = this.resolveWorkspacePath();
+      if (workspacePath) {
+        const stateDir = path.join(path.dirname(workspacePath), ".clawmatrix");
+        this.knowledgeSync = new KnowledgeSync({
+          workspacePath,
+          storePath: path.join(stateDir, "knowledge.automerge"),
+          nodeId: this.config.nodeId,
+          debounce: this.config.knowledge.debounce ?? 5000,
+          peerManager: this.peerManager,
+        });
+        this.knowledgeSync.start().then(() => {
+          this.logger.info(`[clawmatrix] Knowledge sync started: ${workspacePath}`);
+        }).catch((err) => {
+          this.logger.error(`[clawmatrix] Knowledge sync failed to start: ${err}`);
+        });
+
+        // Sync with peers on connect/disconnect
+        this.peerManager.on("peerConnected", (nodeId) => {
+          this.knowledgeSync?.initPeerSync(nodeId);
+        });
+        this.peerManager.on("peerDisconnected", (nodeId) => {
+          this.knowledgeSync?.removePeerSync(nodeId);
+        });
+      }
+    }
+
     // Start subsystems
     this.peerManager.start();
     this.modelProxy.start();
@@ -97,6 +131,7 @@ export class ClusterRuntime {
   }
 
   async stop() {
+    await this.knowledgeSync?.stop();
     this.webHandler?.destroy();
     this.handoffManager.destroy();
     this.modelProxy.stop();
@@ -105,6 +140,24 @@ export class ClusterRuntime {
     this.logger.info(`[clawmatrix] Node "${this.config.nodeId}" stopped`);
   }
 
+  private resolveWorkspacePath(): string | null {
+    // Read workspace from OpenClaw agent config (first agent or default agent)
+    const agents = (this.openclawConfig as Record<string, unknown>).agents as
+      | { list?: Array<{ id?: string; default?: boolean; workspace?: string }>; defaults?: { workspace?: string } }
+      | undefined;
+    if (!agents) return null;
+    const list = agents.list ?? [];
+    const defaultAgent = list.find((a) => a.default) ?? list[0];
+    const workspace = defaultAgent?.workspace ?? agents.defaults?.workspace;
+    if (!workspace) return null;
+    // Resolve ~ to home directory
+    if (workspace.startsWith("~/") || workspace === "~") {
+      const home = process.env.HOME ?? process.env.USERPROFILE ?? "";
+      return path.resolve(home, workspace.slice(2));
+    }
+    return path.resolve(workspace);
+  }
+
   private dispatchFrame(frame: AnyClusterFrame) {
     if (frame.type.startsWith("model_")) {
       debug("dispatch", `${frame.type} id=${frame.id} from=${frame.from}`);
@@ -161,6 +214,11 @@ export class ClusterRuntime {
       case "send":
         this.handleSendMessage(frame as SendMessage);
         break;
+      case "knowledge_sync":
+        this.knowledgeSync?.handleSyncMessage(frame as KnowledgeSyncFrame).catch((err) => {
+          this.logger.error(`[clawmatrix] Knowledge sync error: ${err}`);
+        });
+        break;
     }
   }
 

package/src/config.ts

@@ -77,6 +77,11 @@ const ProxyModelGroupSchema = z.object({
   models: z.array(ProxyModelEntrySchema),
 });
 
+const KnowledgeConfigSchema = z.object({
+  enabled: z.boolean().default(false),
+  debounce: z.number().default(5000),
+}).optional();
+
 const WebConfigSchema = z.object({
   enabled: z.boolean().default(false),
   token: z.string().min(8, "web token must be at least 8 characters"),
@@ -97,6 +102,7 @@ const RawClawMatrixConfigSchema = z.object({
   toolProxy: ToolProxyConfigSchema.optional(),
   handoffTimeout: z.number().default(600_000),
   web: WebConfigSchema,
+  knowledge: KnowledgeConfigSchema,
 });
 
 /** Flat proxy model after group expansion (used internally). */
@@ -122,9 +128,15 @@ export { RawClawMatrixConfigSchema as ClawMatrixConfigSchema };
 export type PeerConfig = z.infer<typeof PeerConfigSchema>;
 export type ToolProxyConfig = z.infer<typeof ToolProxyConfigSchema>;
 
-/** Parse and flatten grouped proxyModels into flat array. */
+/** Parse and flatten grouped proxyModels into flat array.
+ *  Uses passthrough() to ignore unknown fields and safeParse to avoid crashing. */
 export function parseConfig(raw: unknown): ClawMatrixConfig {
-  const parsed = RawClawMatrixConfigSchema.parse(raw);
+  const result = RawClawMatrixConfigSchema.passthrough().safeParse(raw);
+  if (!result.success) {
+    const issues = result.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ");
+    throw new Error(`ClawMatrix config error: ${issues}`);
+  }
+  const parsed = result.data;
 
   // Flatten proxy model groups
   const proxyModels: ProxyModel[] = [];

package/src/index.ts

@@ -21,24 +21,20 @@ const plugin = {
 
   configSchema: {
     safeParse(value: unknown) {
-      const result = ClawMatrixConfigSchema.safeParse(value);
-      if (result.success) {
-        return { success: true, data: result.data };
-      }
-      return {
-        success: false,
-        error: {
-          issues: result.error.issues.map((i) => ({
-            path: i.path.map(String),
-            message: i.message,
-          })),
-        },
-      };
+      // Always pass — validation is handled internally with warnings
+      return { success: true, data: value };
     },
   },
 
   register(api: OpenClawPluginApi) {
-    const config = parseConfig(api.pluginConfig);
+    let config: ReturnType<typeof parseConfig>;
+    try {
+      config = parseConfig(api.pluginConfig);
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      console.warn(`[clawmatrix] Config error (plugin disabled): ${message}`);
+      return;
+    }
 
     // Background service: manages mesh connections, WS listener, heartbeat
     api.registerService(createClusterService(config, api.config, api.runtime.version));