clawmatrix 0.2.4 → 0.2.5

package/package.json

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

package/src/compat.ts

@@ -6,6 +6,7 @@
 
 import { spawn as cpSpawn } from "node:child_process";
 import { readFile, writeFile } from "node:fs/promises";
+import { createRequire } from "node:module";
 
 export interface SpawnResult {
   exitCode: number;
@@ -97,8 +98,8 @@ let ptyModule: {
 function loadPty() {
   if (ptyModule !== undefined) return ptyModule;
   try {
-    // eslint-disable-next-line @typescript-eslint/no-require-imports
-    ptyModule = require("node-pty");
+    const req = createRequire(import.meta.url);
+    ptyModule = req("node-pty");
   } catch {
     ptyModule = null;
   }

package/src/identity.ts

@@ -26,6 +26,7 @@
  * ECDH exchange with the peer's key.
  */
 
+import { createPrivateKey } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
 import {
@@ -82,7 +83,6 @@ export function loadOrCreateIdentity(stateDir: string): KeyPair {
 
 /** Reconstruct a KeyPair from serialized base64 strings. */
 function keyPairFromSerialized(publicKeyB64: string, privateKeyB64: string): KeyPair {
-  const { createPrivateKey } = require("node:crypto");
   const publicKey = Buffer.from(publicKeyB64, "base64");
   const privateKey = Buffer.from(privateKeyB64, "base64");
 

package/src/peer-manager.ts

@@ -28,6 +28,23 @@ import type { KeyPair } from "./crypto.ts";
 const RECONNECT_BASE = 1_000;
 const RECONNECT_MAX = 60_000;
 
+/** Classify WebSocket close code into a human-readable reason. */
+function classifyCloseReason(code: number, reason: string): string {
+  if (reason) return reason;
+  switch (code) {
+    case 1006: return "unreachable (node may be down)";
+    case 1000: return "normal close";
+    case 1001: return "peer going away";
+    case 1002: return "protocol error";
+    case 1003: return "unsupported data";
+    case 1008: return "policy violation";
+    case 1011: return "server error";
+    case 4001: return "auth failed";
+    case 4003: return "auth timeout";
+    default: return `close code ${code}`;
+  }
+}
+
 /** Check if an IP is a loopback address (IPv4 127.x or IPv6 ::1). */
 function isLoopback(ip?: string): boolean {
   if (!ip) return false;
@@ -324,24 +341,27 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
     });
 
     let reconnectScheduled = false;
+    let lastError: string | undefined;
     const tryReconnect = () => {
       if (!reconnectScheduled) {
         reconnectScheduled = true;
-        this.scheduleReconnect(peer);
+        this.scheduleReconnect(peer, lastError);
       }
     };
 
     ws.addEventListener("error", (ev) => {
-      debug("peer", `connectToPeer(${peer.nodeId}): ws error: ${(ev as ErrorEvent).message ?? "unknown"}`);
+      lastError = (ev as ErrorEvent).message || undefined;
       tryReconnect();
     });
     ws.addEventListener("close", (ev) => {
-      debug("peer", `connectToPeer(${peer.nodeId}): ws close code=${ev.code} reason=${ev.reason}`);
+      if (!lastError) {
+        lastError = classifyCloseReason(ev.code, ev.reason);
+      }
       tryReconnect();
     });
   }
 
-  private scheduleReconnect(peer: PeerConfig) {
+  private scheduleReconnect(peer: PeerConfig, reason?: string) {
     if (this.stopped) {
       debug("peer", `scheduleReconnect(${peer.nodeId}): skipped (stopped)`);
       return;
@@ -351,7 +371,8 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
     const attempt = this.reconnectAttempts.get(peer.nodeId) ?? 0;
     const delay = Math.min(RECONNECT_BASE * 2 ** attempt, RECONNECT_MAX);
     this.reconnectAttempts.set(peer.nodeId, attempt + 1);
-    debug("peer", `scheduleReconnect(${peer.nodeId}): attempt=${attempt} delay=${delay}ms`);
+    const tag = reason ? ` reason="${reason}"` : "";
+    debug("peer", `scheduleReconnect(${peer.nodeId}): attempt=${attempt} delay=${delay}ms${tag}`);
 
     const timer = setTimeout(() => {
       this.reconnectTimers.delete(peer.nodeId);