clawmatrix 0.1.12 → 0.1.14

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawmatrix",
-  "version": "0.1.12",
+  "version": "0.1.14",
   "description": "Decentralized mesh cluster plugin for OpenClaw — inter-gateway communication, model proxy, task handoff, and tool proxy.",
   "type": "module",
   "license": "MIT",
@@ -33,12 +33,12 @@
   },
   "dependencies": {
     "ws": "^8.19.0",
-    "zod": "^4.3.6"
+    "zod": "^4.3.6",
+    "@mariozechner/pi-coding-agent": ">=0.55.0"
   },
   "devDependencies": {
     "@types/bun": "latest",
-    "@types/ws": "^8.18.1",
-    "openclaw": "^2026.3.2"
+    "@types/ws": "^8.18.1"
   },
   "peerDependencies": {
     "typescript": "^5"

package/src/auth.ts

@@ -22,17 +22,21 @@ export async function computeHmac(
   return Buffer.from(sig).toString("hex");
 }
 
+/** Constant-time string comparison. */
+export function timingSafeEqual(a: string, b: string): boolean {
+  if (a.length !== b.length) return false;
+  let diff = 0;
+  for (let i = 0; i < a.length; i++) {
+    diff |= a.charCodeAt(i) ^ b.charCodeAt(i);
+  }
+  return diff === 0;
+}
+
 export async function verifyHmac(
   nonce: string,
   secret: string,
   sig: string,
 ): Promise<boolean> {
   const expected = await computeHmac(nonce, secret);
-  if (expected.length !== sig.length) return false;
-  // Constant-time comparison
-  let diff = 0;
-  for (let i = 0; i < expected.length; i++) {
-    diff |= expected.charCodeAt(i) ^ sig.charCodeAt(i);
-  }
-  return diff === 0;
+  return timingSafeEqual(expected, sig);
 }

package/src/cluster-service.ts

@@ -11,6 +11,7 @@ import { PeerManager } from "./peer-manager.ts";
 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 type {
   AnyClusterFrame,
   HandoffRequest,
@@ -69,6 +70,13 @@ export class ClusterRuntime {
       this.logger.info(`[clawmatrix] Peer disconnected: ${nodeId}`);
     });
 
+    // Web dashboard (must be set before peerManager.start() creates the HTTP server)
+    if (this.config.web?.enabled) {
+      const webHandler = new WebHandler(this.config, this.peerManager);
+      this.peerManager.setHttpHandler((req, res) => webHandler.handle(req, res));
+      this.logger.info(`[clawmatrix] Web dashboard enabled on listen port`);
+    }
+
     // Start subsystems
     this.peerManager.start();
     this.modelProxy.start();

package/src/config.ts

@@ -68,6 +68,11 @@ const ProxyModelSchema = z.object({
   ...ModelParamsSchema,
 });
 
+const WebConfigSchema = z.object({
+  enabled: z.boolean().default(false),
+  token: z.string().min(8, "web token must be at least 8 characters"),
+}).optional();
+
 export const ClawMatrixConfigSchema = z.object({
   nodeId: z.string(),
   secret: z.string().min(16, "secret must be at least 16 characters"),
@@ -82,6 +87,7 @@ export const ClawMatrixConfigSchema = z.object({
   proxyPort: z.number().default(19001),
   toolProxy: ToolProxyConfigSchema.optional(),
   handoffTimeout: z.number().default(600_000),
+  web: WebConfigSchema,
 });
 
 export type ClawMatrixConfig = z.infer<typeof ClawMatrixConfigSchema>;

package/src/peer-manager.ts

@@ -1,5 +1,5 @@
 import { EventEmitter } from "node:events";
-import { createServer, type IncomingMessage, type Server } from "node:http";
+import { createServer, type IncomingMessage, type ServerResponse, type Server } from "node:http";
 import { WebSocketServer, WebSocket as WsWebSocket } from "ws";
 import type { ClawMatrixConfig, PeerConfig } from "./config.ts";
 import { Connection } from "./connection.ts";
@@ -95,12 +95,20 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
     this.router.destroy();
   }
 
+  /** Set an HTTP request handler for non-WebSocket requests (e.g. web dashboard). */
+  private httpRequestHandler: ((req: IncomingMessage, res: ServerResponse) => boolean) | null = null;
+
+  setHttpHandler(handler: (req: IncomingMessage, res: ServerResponse) => boolean) {
+    this.httpRequestHandler = handler;
+  }
+
   // ── Inbound WS server (node:http + ws) ──────────────────────────
   private startListening() {
     const port = this.config.listenPort;
     const hostname = this.config.listenHost;
 
-    this.httpServer = createServer((_req, res) => {
+    this.httpServer = createServer((req, res) => {
+      if (this.httpRequestHandler && this.httpRequestHandler(req, res)) return;
       res.writeHead(426, { "Content-Type": "text/plain" });
       res.end("WebSocket upgrade required");
     });
@@ -270,7 +278,9 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
     // Validate from field: must be the direct peer or a known node (relayed)
     if (frame.from && frame.from !== from.remoteNodeId && !this.router.getRoute(frame.from)) return;
 
-    if (frame.id && this.router.isDuplicate(frame.id)) return;
+    // Skip dedup for streaming frame types — they share one id across many chunks
+    const isStreamFrame = frame.type === "model_stream" || frame.type === "handoff_stream";
+    if (frame.id && !isStreamFrame && this.router.isDuplicate(frame.id)) return;
 
     if (frame.type === "peer_sync") {
       this.handlePeerSync(frame as PeerSync, from);

package/src/tool-proxy.ts

@@ -114,11 +114,17 @@ export class ToolProxy {
     }
 
     try {
+      console.log(`Received tool request for: ${payload.tool}`);
+      console.log(`Is local tool? ${isLocalTool(payload.tool)}`);
+      
       const result = isLocalTool(payload.tool)
         ? await executeLocally(payload.tool, payload.params)
         : await this.executeViaGateway(payload.tool, payload.params);
+        
+      console.log(`Tool execution result: ${JSON.stringify(result)}`);
       this.sendResponse(id, from, { success: true, result });
     } catch (err) {
+      console.error(`Tool execution error: ${err}`);
       this.sendResponse(id, from, {
         success: false,
         error: err instanceof Error ? err.message : String(err),