clawmatrix 0.1.20 → 0.1.22

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawmatrix",
-  "version": "0.1.20",
+  "version": "0.1.22",
   "description": "Decentralized mesh cluster plugin for OpenClaw — inter-gateway communication, model proxy, task handoff, and tool proxy.",
   "type": "module",
   "license": "MIT",

package/src/cli.ts

@@ -95,7 +95,9 @@ export const registerClusterCli = ({ program }: { program: Command }) => {
         models: Array<{ id: string }>;
         tags: string[];
         connected: boolean;
+        status: "direct" | "relay" | "unreachable";
         latencyMs: number;
+        reachableVia: string | null;
       }>;
 
       if (!peers || peers.length === 0) {
@@ -105,9 +107,9 @@ export const registerClusterCli = ({ program }: { program: Command }) => {
         return;
       }
 
-      const connected = peers.filter((p) => p.connected).length;
-      const countStr = `${connected}/${peers.length} connected`;
-      const countColor = connected === peers.length ? green : connected > 0 ? yellow : red;
+      const reachable = peers.filter((p) => p.connected).length;
+      const countStr = `${reachable}/${peers.length} reachable`;
+      const countColor = reachable === peers.length ? green : reachable > 0 ? yellow : red;
 
       console.log(`  ${bar}`);
       console.log(`  ${cyan("◆")}  ${bold("Peers")}  ${countColor(countStr)}`);
@@ -115,10 +117,14 @@ export const registerClusterCli = ({ program }: { program: Command }) => {
 
       for (let i = 0; i < peers.length; i++) {
         const peer = peers[i];
-        const dot = peer.connected ? green("●") : red("○");
+        const dot = peer.status === "direct" ? green("●") : peer.status === "relay" ? yellow("●") : red("○");
         const latency = peer.connected && peer.latencyMs > 0 ? dim(` ${peer.latencyMs}ms`) : "";
-        const status = peer.connected ? "" : red(" disconnected");
-        console.log(`  ${bar}  ${dot} ${bold(peer.nodeId)}${status}${latency}`);
+        const statusLabel = peer.status === "relay"
+          ? yellow(` relay via ${peer.reachableVia}`)
+          : peer.status === "unreachable"
+            ? red(" unreachable")
+            : "";
+        console.log(`  ${bar}  ${dot} ${bold(peer.nodeId)}${statusLabel}${latency}`);
 
         if (peer.tags.length > 0) {
           console.log(`  ${bar}    ${lbl("Tags")}${peer.tags.join(dim(", "))}`);

package/src/cluster-service.ts

@@ -65,7 +65,7 @@ export class ClusterRuntime {
     this.peerManager = new PeerManager(config, openclawVersion);
     this.handoffManager = new HandoffManager(config, this.peerManager);
     this.modelProxy = new ModelProxy(config, this.peerManager, gatewayInfo, openclawConfig);
-    this.toolProxy = new ToolProxy(config, this.peerManager, gatewayInfo);
+    this.toolProxy = new ToolProxy(config, this.peerManager, gatewayInfo, logger);
   }
 
   start() {
@@ -101,6 +101,7 @@ export class ClusterRuntime {
           storePath: path.join(stateDir, "knowledge.automerge"),
           nodeId: this.config.nodeId,
           debounce: this.config.knowledge.debounce ?? 5000,
+          maxFileSize: this.config.knowledge.maxFileSize ?? 512 * 1024,
           peerManager: this.peerManager,
         });
         this.knowledgeSync.start().then(() => {

package/src/config.ts

@@ -80,6 +80,7 @@ const ProxyModelGroupSchema = z.object({
 const KnowledgeConfigSchema = z.object({
   enabled: z.boolean().default(false),
   debounce: z.number().default(5000),
+  maxFileSize: z.number().default(512 * 1024),
 }).optional();
 
 const WebConfigSchema = z.object({

package/src/debug.ts

@@ -1,5 +1,5 @@
 const enabled = process.env.CLAWMATRIX_DEBUG !== "0";
 
 export function debug(tag: string, msg: string) {
-  if (enabled) console.error(`[clawmatrix:${tag}] ${msg}`);
+  if (enabled) console.debug(`[clawmatrix:${tag}] ${msg}`);
 }

package/src/index.ts

@@ -120,15 +120,19 @@ const plugin = {
             agents: config.agents.map((a) => ({ id: a.id, description: a.description })),
             models: config.models.map((m) => ({ id: m.id })),
             tags: config.tags,
-            peers: peers.map((p) => ({
-              nodeId: p.nodeId,
-              agents: p.agents,
-              models: p.models,
-              tags: p.tags,
-              connected: !!p.connection?.isOpen,
-              reachableVia: p.reachableVia,
-              latencyMs: p.latencyMs,
-            })),
+            peers: peers.map((p) => {
+              const status = runtime.peerManager.router.getPeerStatus(p);
+              return {
+                nodeId: p.nodeId,
+                agents: p.agents,
+                models: p.models,
+                tags: p.tags,
+                connected: status !== "unreachable",
+                status,
+                reachableVia: p.reachableVia,
+                latencyMs: p.latencyMs,
+              };
+            }),
           });
         } catch {
           respond(false, { error: "ClawMatrix service not running" });
@@ -141,15 +145,19 @@ const plugin = {
       ({ respond }: GatewayRequestHandlerOptions) => {
         try {
           const runtime = getClusterRuntime();
-          const peers = runtime.peerManager.router.getAllPeers().map((p) => ({
-            nodeId: p.nodeId,
-            agents: p.agents,
-            models: p.models,
-            tags: p.tags,
-            connected: !!p.connection?.isOpen,
-            reachableVia: p.reachableVia,
-            latencyMs: p.latencyMs,
-          }));
+          const peers = runtime.peerManager.router.getAllPeers().map((p) => {
+            const status = runtime.peerManager.router.getPeerStatus(p);
+            return {
+              nodeId: p.nodeId,
+              agents: p.agents,
+              models: p.models,
+              tags: p.tags,
+              connected: status !== "unreachable",
+              status,
+              reachableVia: p.reachableVia,
+              latencyMs: p.latencyMs,
+            };
+          });
           respond(true, peers);
         } catch {
           respond(true, []);

package/src/knowledge-sync.ts

@@ -1,6 +1,6 @@
 import * as Automerge from "@automerge/automerge";
 import { watch, type FSWatcher } from "node:fs";
-import { readdir, readFile, writeFile, mkdir, unlink } from "node:fs/promises";
+import { readdir, readFile, stat as fsStat, writeFile, mkdir, unlink } from "node:fs/promises";
 import path from "node:path";
 import ignore, { type Ignore } from "ignore";
 
@@ -23,18 +23,33 @@ export interface KnowledgeSyncOptions {
   nodeId: string;
   /** Debounce interval in ms for fs changes. */
   debounce: number;
+  /** Max file size in bytes. Files larger than this are skipped. */
+  maxFileSize: number;
   /** PeerManager for sending frames. */
   peerManager: PeerManager;
 }
 
 const TAG = "knowledge";
 
+async function streamToString(stream: ReadableStream | null): Promise<string> {
+  if (!stream) return "";
+  const reader = stream.getReader();
+  const chunks: Uint8Array[] = [];
+  for (;;) {
+    const { done, value } = await reader.read();
+    if (done) break;
+    chunks.push(value);
+  }
+  return Buffer.concat(chunks).toString("utf-8");
+}
+
 export class KnowledgeSync {
   private doc: Automerge.Doc<KnowledgeDoc>;
   private syncStates = new Map<string, Automerge.SyncState>();
   private watcher: FSWatcher | null = null;
   private debounceTimer: ReturnType<typeof setTimeout> | null = null;
-  private suppressWatch = false;
+  /** Paths currently being written by exportToFs — suppressed from fs watcher. */
+  private writingPaths = new Set<string>();
   private opts: KnowledgeSyncOptions;
   private ig: Ignore = ignore();
 
@@ -74,7 +89,9 @@ export class KnowledgeSync {
 
     // Start watching for file changes
     this.watcher = watch(this.opts.workspacePath, { recursive: true }, (_event, filename) => {
-      if (this.suppressWatch || !filename) return;
+      if (!filename) return;
+      // Ignore files currently being written by export
+      if (this.writingPaths.has(filename)) return;
       // Ignore hidden files
       if (filename.startsWith(".")) return;
       // Ignore gitignored files
@@ -193,8 +210,11 @@ export class KnowledgeSync {
     }
 
     for (const relPath of Object.keys(docFiles)) {
+      // Only treat as deleted if the file is genuinely gone, not just skipped by size limit
       if (!(relPath in currentFiles)) {
-        deleted.push(relPath);
+        const absPath = path.join(this.opts.workspacePath, relPath);
+        const exists = await fsStat(absPath).then(() => true, () => false);
+        if (!exists) deleted.push(relPath);
       }
     }
 
@@ -208,19 +228,14 @@ export class KnowledgeSync {
         (deleted.length > 0 ? ` deleted=[${deleted.join(",")}]` : ""),
     );
 
-    // Update automerge doc
+    // Update automerge doc — only write dirty files to minimize change history
     this.doc = Automerge.change(this.doc, (d) => {
       if (!d.files) {
         (d as KnowledgeDoc).files = {};
       }
-      for (const [relPath, content] of Object.entries(currentFiles)) {
-        d.files[relPath] = content;
-      }
-      for (const relPath of Object.keys(d.files)) {
-        if (!(relPath in currentFiles)) {
-          delete d.files[relPath];
-        }
-      }
+      for (const p of added)    d.files[p] = currentFiles[p];
+      for (const p of modified) d.files[p] = currentFiles[p];
+      for (const p of deleted)  delete d.files[p];
     });
 
     await this.saveDoc();
@@ -286,47 +301,47 @@ export class KnowledgeSync {
         await this.walkDir(base, relPath, result);
       } else if (entry.isFile()) {
         if (this.isIgnored(relPath)) continue;
-        const content = await readFile(path.join(base, relPath), "utf-8");
+        const filePath = path.join(base, relPath);
+        const st = await fsStat(filePath);
+        if (st.size > this.opts.maxFileSize) continue;
+        const content = await readFile(filePath, "utf-8");
         result[relPath] = content;
       }
     }
   }
 
   private async exportToFs() {
-    this.suppressWatch = true;
-    try {
-      const docFiles = this.doc.files ?? {};
-      const currentFiles = await this.readWorkspaceFiles();
-
-      let written = 0;
+    const docFiles = this.doc.files ?? {};
+    const currentFiles = await this.readWorkspaceFiles();
 
-      for (const [relPath, content] of Object.entries(docFiles)) {
-        // Don't export files that would be gitignored
-        if (this.isIgnored(relPath)) continue;
-        if (currentFiles[relPath] !== content) {
-          const absPath = path.join(this.opts.workspacePath, relPath);
-          await mkdir(path.dirname(absPath), { recursive: true });
-          await writeFile(absPath, content, "utf-8");
-          written++;
-        }
+    let written = 0;
+
+    for (const [relPath, content] of Object.entries(docFiles)) {
+      // Don't export files that would be gitignored
+      if (this.isIgnored(relPath)) continue;
+      if (currentFiles[relPath] !== content) {
+        this.writingPaths.add(relPath);
+        const absPath = path.join(this.opts.workspacePath, relPath);
+        await mkdir(path.dirname(absPath), { recursive: true });
+        await writeFile(absPath, content, "utf-8");
+        setTimeout(() => this.writingPaths.delete(relPath), 500);
+        written++;
       }
+    }
 
-      let removed = 0;
-      for (const relPath of Object.keys(currentFiles)) {
-        if (!(relPath in docFiles)) {
-          const absPath = path.join(this.opts.workspacePath, relPath);
-          await unlink(absPath).catch(() => {});
-          removed++;
-        }
+    let removed = 0;
+    for (const relPath of Object.keys(currentFiles)) {
+      if (!(relPath in docFiles)) {
+        this.writingPaths.add(relPath);
+        const absPath = path.join(this.opts.workspacePath, relPath);
+        await unlink(absPath).catch(() => {});
+        setTimeout(() => this.writingPaths.delete(relPath), 500);
+        removed++;
       }
+    }
 
-      if (written > 0 || removed > 0) {
-        debug(TAG, `exported to filesystem: ${written} written, ${removed} removed`);
-      }
-    } finally {
-      setTimeout(() => {
-        this.suppressWatch = false;
-      }, 500);
+    if (written > 0 || removed > 0) {
+      debug(TAG, `exported to filesystem: ${written} written, ${removed} removed`);
     }
   }
 
@@ -353,6 +368,34 @@ export class KnowledgeSync {
       } else {
         debug(TAG, "git repo already initialized");
       }
+
+      // Ensure local git user config exists (so commits don't fail on unconfigured machines)
+      const nameCheck = spawnProcess(["git", "config", "user.name"], {
+        cwd: this.opts.workspacePath,
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+      if ((await nameCheck.exited) !== 0) {
+        const setName = spawnProcess(["git", "config", "user.name", "clawmatrix"], {
+          cwd: this.opts.workspacePath,
+          stdout: "pipe",
+          stderr: "pipe",
+        });
+        await setName.exited;
+      }
+      const emailCheck = spawnProcess(["git", "config", "user.email"], {
+        cwd: this.opts.workspacePath,
+        stdout: "pipe",
+        stderr: "pipe",
+      });
+      if ((await emailCheck.exited) !== 0) {
+        const setEmail = spawnProcess(["git", "config", "user.email", "clawmatrix@local"], {
+          cwd: this.opts.workspacePath,
+          stdout: "pipe",
+          stderr: "pipe",
+        });
+        await setEmail.exited;
+      }
     } catch {
       debug(TAG, "git not available, skipping git integration");
     }
@@ -386,8 +429,13 @@ export class KnowledgeSync {
           stderr: "pipe",
         },
       );
-      await commit.exited;
-      debug(TAG, `git commit: ${message}`);
+      const commitCode = await commit.exited;
+      if (commitCode !== 0) {
+        const stderr = await streamToString(commit.stderr);
+        debug(TAG, `git commit failed (exit ${commitCode}): ${stderr}`);
+      } else {
+        debug(TAG, `git commit: ${message}`);
+      }
     } catch (err) {
       debug(TAG, `git commit failed: ${err}`);
     }