clawmatrix 0.1.0 → 0.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "clawmatrix",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Decentralized mesh cluster plugin for OpenClaw — inter-gateway communication, model proxy, task handoff, and tool proxy.",
   "type": "module",
   "license": "MIT",
@@ -31,10 +31,12 @@
     "prepublishOnly": "bun test"
   },
   "dependencies": {
+    "ws": "^8.19.0",
     "zod": "^4.3.6"
   },
   "devDependencies": {
     "@types/bun": "latest",
+    "@types/ws": "^8.18.1",
     "openclaw": "^2026.3.2"
   },
   "peerDependencies": {

package/src/cluster-service.ts

@@ -4,6 +4,7 @@ import type {
   PluginLogger,
 } from "openclaw/plugin-sdk";
 import type { ClawMatrixConfig } from "./config.ts";
+import { spawnProcess } from "./compat.ts";
 import { PeerManager } from "./peer-manager.ts";
 import { HandoffManager } from "./handoff.ts";
 import { ModelProxy } from "./model-proxy.ts";
@@ -124,7 +125,7 @@ export class ClusterRuntime {
     }
 
     // Fire-and-forget: inject message via openclaw agent
-    Bun.spawn(["openclaw", "agent", "--message", message], {
+    spawnProcess(["openclaw", "agent", "--message", message], {
       stdout: "ignore",
       stderr: "ignore",
     });

package/src/compat.ts

@@ -0,0 +1,62 @@
+/**
+ * Runtime compatibility layer — provides Node.js-compatible alternatives
+ * for Bun-specific APIs so the plugin works inside the OpenClaw gateway
+ * (which runs on Node.js).
+ */
+
+import { spawn as cpSpawn } from "node:child_process";
+import { readFile, writeFile } from "node:fs/promises";
+
+export interface SpawnResult {
+  exitCode: number;
+  stdout: string;
+  stderr: string;
+}
+
+/** Spawn a subprocess and collect stdout/stderr. */
+export function spawnProcess(
+  cmd: string[],
+  opts?: { cwd?: string; stdout?: "pipe" | "ignore"; stderr?: "pipe" | "ignore" },
+): { exited: Promise<number>; stdout: ReadableStream | null; stderr: ReadableStream | null; kill: () => void } {
+  const child = cpSpawn(cmd[0]!, cmd.slice(1), {
+    cwd: opts?.cwd,
+    stdio: [
+      "ignore",
+      opts?.stdout === "ignore" ? "ignore" : "pipe",
+      opts?.stderr === "ignore" ? "ignore" : "pipe",
+    ],
+  });
+
+  const exited = new Promise<number>((resolve, reject) => {
+    child.on("close", (code) => resolve(code ?? 1));
+    child.on("error", reject);
+  });
+
+  function nodeStreamToWeb(stream: import("node:stream").Readable | null): ReadableStream | null {
+    if (!stream) return null;
+    return new ReadableStream({
+      start(controller) {
+        stream.on("data", (chunk: Buffer) => controller.enqueue(chunk));
+        stream.on("end", () => controller.close());
+        stream.on("error", (err) => controller.error(err));
+      },
+    });
+  }
+
+  return {
+    exited,
+    stdout: nodeStreamToWeb(child.stdout),
+    stderr: nodeStreamToWeb(child.stderr),
+    kill: () => child.kill(),
+  };
+}
+
+/** Read a file as text (replaces Bun.file().text()). */
+export async function readFileText(path: string): Promise<string> {
+  return readFile(path, "utf-8");
+}
+
+/** Write text to a file (replaces Bun.write()). */
+export async function writeFileText(path: string, content: string): Promise<void> {
+  await writeFile(path, content, "utf-8");
+}

package/src/handoff.ts

@@ -1,5 +1,6 @@
 import type { PeerManager } from "./peer-manager.ts";
 import type { ClawMatrixConfig } from "./config.ts";
+import { spawnProcess } from "./compat.ts";
 import type {
   HandoffRequest,
   HandoffResponse,
@@ -147,16 +148,16 @@ export class HandoffManager {
         ? `${payload.task}\n\nContext:\n${payload.context}`
         : payload.task;
 
-      const proc = Bun.spawn(["openclaw", "agent", "--message", message], {
+      const proc = spawnProcess(["openclaw", "agent", "--message", message], {
         stdout: "pipe",
         stderr: "pipe",
       });
 
-      const stdout = await new Response(proc.stdout).text();
+      const stdout = proc.stdout ? await new Response(proc.stdout).text() : "";
       const exitCode = await proc.exited;
 
       if (exitCode !== 0) {
-        const stderr = await new Response(proc.stderr).text();
+        const stderr = proc.stderr ? await new Response(proc.stderr).text() : "";
         throw new Error(`Agent exited with code ${exitCode}: ${stderr}`);
       }
 

package/src/model-proxy.ts

@@ -1,3 +1,4 @@
+import { createServer, type Server } from "node:http";
 import type { PeerManager } from "./peer-manager.ts";
 import type { ClawMatrixConfig } from "./config.ts";
 import type {
@@ -21,7 +22,7 @@ export class ModelProxy {
   private config: ClawMatrixConfig;
   private peerManager: PeerManager;
   private pending = new Map<string, PendingModelReq>();
-  private httpServer: ReturnType<typeof Bun.serve> | null = null;
+  private httpServer: Server | null = null;
 
   constructor(config: ClawMatrixConfig, peerManager: PeerManager) {
     this.config = config;
@@ -30,26 +31,28 @@ export class ModelProxy {
 
   /** Start the local HTTP proxy server for OpenAI-compatible requests. */
   start() {
-    this.httpServer = Bun.serve({
-      port: this.config.proxyPort,
-      hostname: "127.0.0.1",
-      routes: {
-        "/v1/chat/completions": {
-          POST: async (req) => this.handleChatCompletion(req),
-        },
-        "/v1/models": {
-          GET: () => this.handleListModels(),
-        },
-      },
-      fetch() {
-        return new Response("Not Found", { status: 404 });
-      },
+    this.httpServer = createServer(async (req, res) => {
+      const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+
+      if (url.pathname === "/v1/chat/completions" && req.method === "POST") {
+        const body = await this.readBody(req);
+        const response = await this.handleChatCompletion(body);
+        this.sendResponse(res, response);
+      } else if (url.pathname === "/v1/models" && req.method === "GET") {
+        const response = this.handleListModels();
+        this.sendResponse(res, response);
+      } else {
+        res.writeHead(404, { "Content-Type": "text/plain" });
+        res.end("Not Found");
+      }
     });
+
+    this.httpServer.listen(this.config.proxyPort, "127.0.0.1");
   }
 
   stop() {
     if (this.httpServer) {
-      this.httpServer.stop();
+      this.httpServer.close();
       this.httpServer = null;
     }
     for (const [, pending] of this.pending) {
@@ -59,8 +62,38 @@ export class ModelProxy {
     this.pending.clear();
   }
 
+  private readBody(req: import("node:http").IncomingMessage): Promise<string> {
+    return new Promise((resolve, reject) => {
+      const chunks: Buffer[] = [];
+      req.on("data", (chunk: Buffer) => chunks.push(chunk));
+      req.on("end", () => resolve(Buffer.concat(chunks).toString()));
+      req.on("error", reject);
+    });
+  }
+
+  private sendResponse(res: import("node:http").ServerResponse, response: { status: number; headers: Record<string, string>; body: string | ReadableStream }) {
+    res.writeHead(response.status, response.headers);
+    if (typeof response.body === "string") {
+      res.end(response.body);
+    } else {
+      // Stream response
+      const reader = response.body.getReader();
+      const pump = (): void => {
+        reader.read().then(({ done, value }) => {
+          if (done) {
+            res.end();
+            return;
+          }
+          res.write(value);
+          pump();
+        }).catch(() => res.end());
+      };
+      pump();
+    }
+  }
+
   // ── HTTP handlers ──────────────────────────────────────────────
-  private async handleChatCompletion(req: Request): Promise<Response> {
+  private async handleChatCompletion(rawBody: string): Promise<{ status: number; headers: Record<string, string>; body: string | ReadableStream }> {
     let body: {
       model: string;
       messages: unknown[];
@@ -70,21 +103,23 @@ export class ModelProxy {
     };
 
     try {
-      body = (await req.json()) as typeof body;
+      body = JSON.parse(rawBody);
     } catch {
-      return new Response(JSON.stringify({ error: "Invalid JSON" }), {
+      return {
         status: 400,
         headers: { "Content-Type": "application/json" },
-      });
+        body: JSON.stringify({ error: "Invalid JSON" }),
+      };
     }
 
     const modelId = body.model;
     const route = this.peerManager.router.resolveModel(modelId);
     if (!route) {
-      return new Response(
-        JSON.stringify({ error: { message: `Model "${modelId}" not found in cluster` } }),
-        { status: 404, headers: { "Content-Type": "application/json" } },
-      );
+      return {
+        status: 404,
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ error: { message: `Model "${modelId}" not found in cluster` } }),
+      };
     }
 
     const stream = body.stream ?? false;
@@ -116,7 +151,7 @@ export class ModelProxy {
     requestId: string,
     targetNodeId: string,
     frame: ModelRequest,
-  ): Response {
+  ): { status: number; headers: Record<string, string>; body: ReadableStream } {
     const encoder = new TextEncoder();
 
     const readable = new ReadableStream({
@@ -159,20 +194,22 @@ export class ModelProxy {
       },
     });
 
-    return new Response(readable, {
+    return {
+      status: 200,
       headers: {
         "Content-Type": "text/event-stream",
         "Cache-Control": "no-cache",
-        Connection: "keep-alive",
+        "Connection": "keep-alive",
       },
-    });
+      body: readable,
+    };
   }
 
   private async handleNonStreamRequest(
     requestId: string,
     targetNodeId: string,
     frame: ModelRequest,
-  ): Promise<Response> {
+  ): Promise<{ status: number; headers: Record<string, string>; body: string }> {
     try {
       const result = await new Promise<ModelResponse["payload"]>(
         (resolve, reject) => {
@@ -199,15 +236,17 @@ export class ModelProxy {
       );
 
       if (!result.success) {
-        return new Response(
-          JSON.stringify({ error: { message: result.error } }),
-          { status: 502, headers: { "Content-Type": "application/json" } },
-        );
+        return {
+          status: 502,
+          headers: { "Content-Type": "application/json" },
+          body: JSON.stringify({ error: { message: result.error } }),
+        };
       }
 
-      // OpenAI-compatible response
-      return new Response(
-        JSON.stringify({
+      return {
+        status: 200,
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({
           id: `chatcmpl-${requestId}`,
           object: "chat.completion",
           created: Math.floor(Date.now() / 1000),
@@ -227,17 +266,17 @@ export class ModelProxy {
               }
             : undefined,
         }),
-        { headers: { "Content-Type": "application/json" } },
-      );
+      };
     } catch (err) {
-      return new Response(
-        JSON.stringify({ error: { message: err instanceof Error ? err.message : String(err) } }),
-        { status: 502, headers: { "Content-Type": "application/json" } },
-      );
+      return {
+        status: 502,
+        headers: { "Content-Type": "application/json" },
+        body: JSON.stringify({ error: { message: err instanceof Error ? err.message : String(err) } }),
+      };
     }
   }
 
-  private handleListModels(): Response {
+  private handleListModels(): { status: number; headers: Record<string, string>; body: string } {
     const models = this.peerManager.router
       .getAllPeers()
       .flatMap((p) =>
@@ -249,10 +288,11 @@ export class ModelProxy {
         })),
       );
 
-    return new Response(
-      JSON.stringify({ object: "list", data: models }),
-      { headers: { "Content-Type": "application/json" } },
-    );
+    return {
+      status: 200,
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify({ object: "list", data: models }),
+    };
   }
 
   // ── Incoming frame handlers ────────────────────────────────────
@@ -273,7 +313,6 @@ export class ModelProxy {
 
     try {
       if (frame.payload.done) {
-        // Send final chunk with usage if available
         if (frame.payload.usage) {
           const usageChunk = {
             id: `chatcmpl-${frame.id}`,
@@ -310,7 +349,6 @@ export class ModelProxy {
         );
       }
     } catch {
-      // controller may be closed
       clearTimeout(pending.timer);
       this.pending.delete(frame.id);
     }
@@ -320,7 +358,6 @@ export class ModelProxy {
   async handleModelRequest(frame: ModelRequest): Promise<void> {
     const { id, from, payload } = frame;
 
-    // Find the model in our local config
     const model = this.config.models.find((m) => m.id === payload.model);
     if (!model) {
       this.peerManager.sendTo(from, {
@@ -335,9 +372,6 @@ export class ModelProxy {
     }
 
     try {
-      // Use OpenClaw's API to run the model locally
-      // This is done by calling the local gateway's /v1/chat/completions endpoint
-      // The local OpenClaw gateway handles provider routing
       const localUrl = `http://127.0.0.1:${process.env.OPENCLAW_GATEWAY_PORT ?? 3000}/v1/chat/completions`;
 
       const response = await fetch(localUrl, {
@@ -353,7 +387,6 @@ export class ModelProxy {
       });
 
       if (payload.stream) {
-        // Read SSE stream and forward as model_stream frames
         const reader = response.body?.getReader();
         if (!reader) throw new Error("No response body");
 

package/src/peer-manager.ts

@@ -1,5 +1,6 @@
 import { EventEmitter } from "node:events";
-import type { ServerWebSocket } from "bun";
+import { createServer, type IncomingMessage, type Server } from "node:http";
+import { WebSocketServer, WebSocket as WsWebSocket } from "ws";
 import type { ClawMatrixConfig, PeerConfig } from "./config.ts";
 import { Connection } from "./connection.ts";
 import type { WsTransport } from "./connection.ts";
@@ -25,12 +26,13 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
   readonly router: Router;
   private config: ClawMatrixConfig;
   private localCapabilities: NodeCapabilities;
-  private wsServer: ReturnType<typeof Bun.serve> | null = null;
+  private httpServer: Server | null = null;
+  private wss: WebSocketServer | null = null;
   private reconnectTimers = new Map<string, ReturnType<typeof setTimeout>>();
   private reconnectAttempts = new Map<string, number>();
   private stopped = false;
-  /** Map from ServerWebSocket to Connection for inbound connections. */
-  private inboundConnections = new Map<ServerWebSocket<unknown>, Connection>();
+  /** Map from ws WebSocket to Connection for inbound connections. */
+  private inboundConnections = new Map<WsWebSocket, Connection>();
 
   constructor(config: ClawMatrixConfig) {
     super();
@@ -76,50 +78,52 @@ export class PeerManager extends EventEmitter<PeerManagerEvents> {
       conn.close(1000, "shutdown");
     }
 
-    if (this.wsServer) {
-      this.wsServer.stop();
-      this.wsServer = null;
+    if (this.wss) {
+      this.wss.close();
+      this.wss = null;
+    }
+    if (this.httpServer) {
+      this.httpServer.close();
+      this.httpServer = null;
     }
   }
 
-  // ── Inbound WS server (Bun.serve) ─────────────────────────────
+  // ── Inbound WS server (node:http + ws) ──────────────────────────
   private startListening() {
     const port = this.config.listenPort;
     const hostname = this.config.listenHost;
-    const self = this;
-
-    this.wsServer = Bun.serve<undefined>({
-      port,
-      hostname,
-      fetch(req, server) {
-        if (server.upgrade(req)) {
-          return undefined;
+
+    this.httpServer = createServer((_req, res) => {
+      res.writeHead(426, { "Content-Type": "text/plain" });
+      res.end("WebSocket upgrade required");
+    });
+
+    this.wss = new WebSocketServer({ server: this.httpServer });
+
+    this.wss.on("connection", (ws) => {
+      this.handleInboundOpen(ws);
+
+      ws.on("message", (data) => {
+        const conn = this.inboundConnections.get(ws);
+        if (conn) {
+          conn.feedMessage(typeof data === "string" ? data : String(data));
         }
-        return new Response("WebSocket upgrade required", { status: 426 });
-      },
-      websocket: {
-        open(ws) {
-          self.handleInboundOpen(ws);
-        },
-        message(ws, message) {
-          const conn = self.inboundConnections.get(ws);
-          if (conn) {
-            conn.feedMessage(typeof message === "string" ? message : Buffer.from(message));
-          }
-        },
-        close(ws, code, reason) {
-          const conn = self.inboundConnections.get(ws);
-          if (conn) {
-            conn.feedClose(code, reason);
-            self.inboundConnections.delete(ws);
-          }
-        },
-      },
+      });
+
+      ws.on("close", (code, reason) => {
+        const conn = this.inboundConnections.get(ws);
+        if (conn) {
+          conn.feedClose(code, reason.toString());
+          this.inboundConnections.delete(ws);
+        }
+      });
     });
+
+    this.httpServer.listen(port, hostname);
   }
 
-  private handleInboundOpen(ws: ServerWebSocket<unknown>) {
-    // Wrap Bun's ServerWebSocket into our WsTransport interface
+  private handleInboundOpen(ws: WsWebSocket) {
+    // Wrap ws WebSocket into our WsTransport interface
     const transport: WsTransport = {
       send(data: string) {
         ws.send(data);

package/src/tool-proxy.ts

@@ -2,6 +2,7 @@ import { readdir, stat } from "node:fs/promises";
 import { join, resolve, normalize } from "node:path";
 import type { PeerManager } from "./peer-manager.ts";
 import type { ClawMatrixConfig, ToolProxyConfig } from "./config.ts";
+import { spawnProcess, readFileText, writeFileText } from "./compat.ts";
 import type { ToolProxyRequest, ToolProxyResponse } from "./types.ts";
 
 const TOOL_TIMEOUT = 30_000;
@@ -198,7 +199,7 @@ export class ToolProxy {
     const cwd = (params.cwd as string) ?? process.cwd();
     const timeout = (params.timeout as number) ?? TOOL_TIMEOUT;
 
-    const proc = Bun.spawn(["sh", "-c", command], {
+    const proc = spawnProcess(["sh", "-c", command], {
       cwd,
       stdout: "pipe",
       stderr: "pipe",
@@ -207,8 +208,8 @@ export class ToolProxy {
     const timeoutId = setTimeout(() => proc.kill(), timeout);
 
     const [stdout, stderr] = await Promise.all([
-      new Response(proc.stdout).text(),
-      new Response(proc.stderr).text(),
+      proc.stdout ? new Response(proc.stdout).text() : "",
+      proc.stderr ? new Response(proc.stderr).text() : "",
     ]);
     const exitCode = await proc.exited;
     clearTimeout(timeoutId);
@@ -229,8 +230,7 @@ export class ToolProxy {
     if (!path) throw new Error("Missing path");
     this.validatePath(path, tpConfig);
 
-    const file = Bun.file(path);
-    const content = await file.text();
+    const content = await readFileText(path);
     return {
       content: content.slice(0, tpConfig.maxOutputBytes),
     };
@@ -245,7 +245,7 @@ export class ToolProxy {
     if (!path || content === undefined) throw new Error("Missing path or content");
     this.validatePath(path, tpConfig);
 
-    await Bun.write(path, content);
+    await writeFileText(path, content);
     return { success: true };
   }