shadow-claw 1.23.4 → 1.24.0

package/src/server/server-peer.ts

@@ -0,0 +1,330 @@
+/**
+ * ShadowClaw — Server-Side WebRTC Peer & A2A Bridge
+ *
+ * Enables the ShadowClaw server to act as a first-class WebRTC peer using
+ * node-datachannel. Can connect to local or remote PeerJS signaling servers,
+ * communicate directly with browser clients, other ShadowClaw servers,
+ * and CLI tools over RTCDataChannels.
+ */
+
+import { getPeerClass } from "./webrtc.js";
+import { ulid } from "../utils/ulid.js";
+import type {
+  ControlMessage,
+  CommandExecutePayload,
+  CommandResultPayload,
+} from "./control-plane-types.js";
+
+export interface ServerPeerOptions {
+  peerId?: string;
+  host?: string;
+  port?: number;
+  path?: string;
+  secure?: boolean;
+  verbose?: boolean;
+  handlers?: Record<string, (args: any) => Promise<any> | any>;
+}
+
+export class ServerPeer {
+  private _peerId: string;
+  private _host: string;
+  private _port: number;
+  private _path: string;
+  private _secure: boolean;
+  private _verbose: boolean;
+  private _peer: any = null;
+  private _connections: Map<string, any> = new Map();
+  private _pendingCommands: Map<
+    string,
+    {
+      resolve: (val: any) => void;
+      reject: (err: any) => void;
+      timeout: NodeJS.Timeout;
+    }
+  > = new Map();
+  private _handlers: Map<string, (args: any) => Promise<any> | any> = new Map();
+  private _isOpen = false;
+
+  constructor(options: ServerPeerOptions = {}) {
+    this._peerId = options.peerId || `server-${ulid().toLowerCase()}`;
+    this._host = options.host || "127.0.0.1";
+    this._port = options.port || 8888;
+    this._path = options.path || "/";
+    this._secure = options.secure ?? false;
+    this._verbose = options.verbose ?? false;
+
+    if (options.handlers) {
+      for (const [action, fn] of Object.entries(options.handlers)) {
+        this._handlers.set(action, fn);
+      }
+    }
+  }
+
+  public get peerId(): string {
+    return this._peerId;
+  }
+
+  public get isOpen(): boolean {
+    return this._isOpen;
+  }
+
+  private log(msg: string): void {
+    if (this._verbose) {
+      console.log(`[server-peer] ${msg}`);
+    }
+  }
+
+  public async start(): Promise<string> {
+    const Peer = await getPeerClass();
+
+    return new Promise((resolve, reject) => {
+      try {
+        const peer = new Peer(this._peerId, {
+          host: this._host,
+          port: this._port,
+          path: this._path,
+          secure: this._secure,
+        });
+
+        this._peer = peer;
+
+        peer.on("open", (id: string) => {
+          this._peerId = id;
+          this._isOpen = true;
+          this.log(`Server peer opened with ID: ${id}`);
+          resolve(id);
+        });
+
+        peer.on("connection", (conn: any) => {
+          this._setupConnection(conn);
+        });
+
+        peer.on("error", (err: any) => {
+          this.log(`Server peer error: ${err.message || String(err)}`);
+          if (!this._isOpen) {
+            reject(err);
+          }
+        });
+
+        peer.on("close", () => {
+          this._isOpen = false;
+          this._connections.clear();
+          this.log("Server peer closed");
+        });
+      } catch (err) {
+        reject(err);
+      }
+    });
+  }
+
+  private _setupConnection(conn: any): void {
+    const remotePeerId = conn.peer;
+
+    conn.on("open", () => {
+      this._connections.set(remotePeerId, conn);
+      this.log(`DataChannel connected with peer: ${remotePeerId}`);
+    });
+
+    conn.on("data", (data: any) => {
+      this._handleData(remotePeerId, conn, data);
+    });
+
+    conn.on("close", () => {
+      this._connections.delete(remotePeerId);
+      this.log(`DataChannel closed for peer: ${remotePeerId}`);
+    });
+
+    conn.on("error", (err: any) => {
+      this.log(`DataChannel error with ${remotePeerId}: ${err.message}`);
+    });
+  }
+
+  private async _handleData(
+    _remotePeerId: string,
+    conn: any,
+    rawData: any,
+  ): Promise<void> {
+    let msg: any = rawData;
+    if (typeof rawData === "string") {
+      try {
+        msg = JSON.parse(rawData);
+      } catch {
+        return;
+      }
+    }
+
+    if (!msg || typeof msg !== "object") {
+      return;
+    }
+
+    // Handle Control Plane execute commands
+    if (msg.type === "command:execute") {
+      const payload = msg.payload as CommandExecutePayload;
+      const { commandId, action, args } = payload || {};
+
+      const handler = this._handlers.get(action);
+      if (!handler) {
+        const result: ControlMessage = {
+          id: ulid(),
+          type: "command:result",
+          replyTo: msg.id,
+          payload: {
+            commandId,
+            success: false,
+            error: `Unknown action: ${action}`,
+          } as CommandResultPayload,
+        };
+        conn.send(result);
+        return;
+      }
+
+      try {
+        const data = await handler(args);
+        const result: ControlMessage = {
+          id: ulid(),
+          type: "command:result",
+          replyTo: msg.id,
+          payload: {
+            commandId,
+            success: true,
+            data,
+          } as CommandResultPayload,
+        };
+        conn.send(result);
+      } catch (err: any) {
+        const result: ControlMessage = {
+          id: ulid(),
+          type: "command:result",
+          replyTo: msg.id,
+          payload: {
+            commandId,
+            success: false,
+            error: err.message || String(err),
+          } as CommandResultPayload,
+        };
+        conn.send(result);
+      }
+      return;
+    }
+
+    // Handle Control Plane command result responses
+    if (msg.type === "command:result") {
+      const res = msg.payload as CommandResultPayload;
+      if (res?.commandId && this._pendingCommands.has(res.commandId)) {
+        const pending = this._pendingCommands.get(res.commandId)!;
+        clearTimeout(pending.timeout);
+        this._pendingCommands.delete(res.commandId);
+        pending.resolve(res);
+      }
+      return;
+    }
+  }
+
+  public isPeerConnected(remotePeerId: string): boolean {
+    const conn = this._connections.get(remotePeerId);
+    return !!conn && (conn.open || conn._open);
+  }
+
+  public getConnectedPeers(): string[] {
+    return Array.from(this._connections.keys());
+  }
+
+  public async sendCommand(
+    remotePeerId: string,
+    action: string,
+    args: Record<string, unknown> = {},
+    timeoutMs: number = 30_000,
+  ): Promise<CommandResultPayload> {
+    if (!this._peer || !this._isOpen) {
+      throw new Error("Server peer is not running");
+    }
+
+    let conn = this._connections.get(remotePeerId);
+    if (!conn || !conn.open) {
+      conn = this._peer.connect(remotePeerId, {
+        reliable: true,
+        serialization: "binary",
+      });
+      this._setupConnection(conn);
+
+      await new Promise<void>((resolve, reject) => {
+        const t = setTimeout(
+          () => {
+            reject(
+              new Error(
+                `Connection to peer ${remotePeerId} timed out after ${timeoutMs}ms`,
+              ),
+            );
+          },
+          Math.min(10_000, timeoutMs),
+        );
+
+        conn.on("open", () => {
+          clearTimeout(t);
+          resolve();
+        });
+        conn.on("error", (err: any) => {
+          clearTimeout(t);
+          reject(err);
+        });
+      });
+    }
+
+    const commandId = ulid();
+    const commandPayload: CommandExecutePayload = {
+      commandId,
+      action: action as any,
+      args,
+    };
+
+    const message: ControlMessage = {
+      id: ulid(),
+      type: "command:execute",
+      payload: commandPayload,
+    };
+
+    return new Promise<CommandResultPayload>((resolve, reject) => {
+      const timeout = setTimeout(() => {
+        this._pendingCommands.delete(commandId);
+        reject(
+          new Error(
+            `Command ${action} to peer ${remotePeerId} timed out after ${timeoutMs}ms`,
+          ),
+        );
+      }, timeoutMs);
+
+      this._pendingCommands.set(commandId, { resolve, reject, timeout });
+
+      try {
+        conn.send(message);
+      } catch (err) {
+        clearTimeout(timeout);
+        this._pendingCommands.delete(commandId);
+        reject(err);
+      }
+    });
+  }
+
+  public close(): void {
+    this._isOpen = false;
+    for (const [, pending] of this._pendingCommands) {
+      clearTimeout(pending.timeout);
+      pending.reject(new Error("Server peer closed"));
+    }
+    this._pendingCommands.clear();
+
+    for (const conn of this._connections.values()) {
+      try {
+        conn.close();
+      } catch (_) {}
+    }
+    this._connections.clear();
+
+    if (this._peer) {
+      try {
+        this._peer.destroy();
+      } catch (_) {}
+      this._peer = null;
+    }
+  }
+}

package/src/server/server.ts

@@ -7,6 +7,8 @@ import tcpPortUsed from "tcp-port-used";
 import { DEFAULT_DEV_IP } from "../config/config.js";
 import { createApp } from "./app.js";
 import { attachPeerServer } from "./peer.js";
+import { createControlPlane } from "./control-plane.js";
+import { ServerPeer } from "./server-peer.js";
 import { parseConfig, ServerConfig } from "./config.js";
 
 export async function startServer(
@@ -27,8 +29,22 @@ export async function startServer(
 
   const httpServer = http.createServer(app);
 
+  const controlPlane = createControlPlane({
+    httpServer,
+    app,
+    token: config.controlToken,
+    verbose: config.verbose,
+  });
+
+  let serverPeer: ServerPeer | null = null;
   if (config.peerjs) {
     attachPeerServer(httpServer, app);
+    serverPeer = new ServerPeer({
+      host: config.bindHost,
+      port: config.port,
+      path: "/peerjs",
+      verbose: config.verbose,
+    });
   }
 
   return new Promise<http.Server>((resolve) => {
@@ -53,8 +69,27 @@ export async function startServer(
         );
       }
 
+      console.log(
+        `Control plane active at http://${config.bindHost}:${config.port}/api/control/events (SSE) and ws://${config.bindHost}:${config.port}/ws/control (WebSocket)`,
+      );
+      console.log(`Control token: ${controlPlane.getToken()}`);
+
       if (config.peerjs) {
         console.log("PeerJS signaling server enabled (routes at /peerjs/*)");
+        if (serverPeer) {
+          serverPeer
+            .start()
+            .then((id) => {
+              console.log(`Server WebRTC peer active with ID: ${id}`);
+            })
+            .catch((err) => {
+              if (config.verbose) {
+                console.warn(
+                  `[server] ServerPeer start notice: ${err.message || String(err)}`,
+                );
+              }
+            });
+        }
       }
 
       if (config.verbose) {

package/src/server/services/llamafile-manager.test.ts

@@ -33,7 +33,7 @@ describe("LlamafileManagerService", () => {
     return mod.createLlamafileManagerService();
   }
 
-  describe("listBinaries", () => {
+  describe("listBinaries & resolveBinary", () => {
     it("lists .llamafile files in the cache directory", async () => {
       statMock.mockResolvedValue({ isDirectory: () => true });
       readdirMock.mockResolvedValue([
@@ -48,6 +48,21 @@ describe("LlamafileManagerService", () => {
       expect(binaries).toHaveLength(2);
       expect(binaries[0].id).toBe("model1");
       expect(binaries[1].id).toBe("model2");
+
+      const resolved = await service.resolveBinary("model1");
+      expect(resolved.fileName).toBe("model1.llamafile");
+    });
+
+    it("throws error if model is not found", async () => {
+      statMock.mockResolvedValue({ isDirectory: () => true });
+      readdirMock.mockResolvedValue([
+        { name: "model1.llamafile", isFile: () => true },
+      ]);
+
+      const service = await getService();
+      await expect(service.resolveBinary("missing")).rejects.toThrow(
+        /not found under assets\/cache\/llamafile/,
+      );
     });
 
     it("throws error if no cache directory is found", async () => {
@@ -60,7 +75,7 @@ describe("LlamafileManagerService", () => {
     });
   });
 
-  describe("getLlamafileRuntimeOptions", () => {
+  describe("getLlamafileRuntimeOptions & Host Validation", () => {
     it("parses options from headers", async () => {
       const service = await getService();
       const req = {
@@ -100,11 +115,54 @@ describe("LlamafileManagerService", () => {
       expect(opts.port).toBe(9090);
       expect(opts.offline).toBe(false);
     });
+
+    it("rejects non-loopback hosts by default", async () => {
+      const service = await getService();
+      const req = {
+        headers: {
+          "x-llamafile-host": "192.168.1.100",
+        },
+        body: {},
+      } as any;
+
+      expect(() => service.getLlamafileRuntimeOptions(req)).toThrow(
+        /Unsafe host '192.168.1.100'/,
+      );
+    });
   });
 
-  describe("createLlamafilePromptEchoFilter", () => {
+  describe("cancelRequest and request ID", () => {
+    it("extracts request ID from header and body", async () => {
+      const service = await getService();
+      const reqWithHeader = {
+        headers: { "x-shadowclaw-request-id": "req-123" },
+      } as any;
+      expect(service.getLlamafileRequestId(reqWithHeader)).toBe("req-123");
+
+      const reqWithBody = {
+        headers: {},
+        body: { requestId: "req-456" },
+      } as any;
+      expect(service.getLlamafileRequestId(reqWithBody, reqWithBody.body)).toBe(
+        "req-456",
+      );
+    });
+
+    it("cancels active requests", async () => {
+      const service = await getService();
+      expect(service.cancelRequest("non-existent")).toBe(false);
+
+      const cancelFn = jest.fn();
+      service.__getActiveRequests().set("req-cancel", cancelFn);
+
+      expect(service.cancelRequest("req-cancel")).toBe(true);
+      expect(cancelFn).toHaveBeenCalled();
+    });
+  });
+
+  describe("createLlamafilePromptEchoFilter & stripLlamafilePromptEcho", () => {
     it("strips echoed prompt from output", async () => {
-      const { createLlamafilePromptEchoFilter } =
+      const { createLlamafilePromptEchoFilter, stripLlamafilePromptEcho } =
         await import("./llamafile-manager.js");
       const prompt = "USER: hello\n\nASSISTANT:";
       const filter = createLlamafilePromptEchoFilter(prompt);
@@ -112,6 +170,12 @@ describe("LlamafileManagerService", () => {
       expect(filter.push(prompt)).toBe("");
       expect(filter.push(" Hello there!")).toBe(" Hello there!");
       expect(filter.flush()).toBe("");
+
+      const stripped = stripLlamafilePromptEcho(
+        "USER: hello\n\nASSISTANT: Hello there!",
+        prompt,
+      );
+      expect(stripped).toBe("Hello there!");
     });
 
     it("handles partial echoes", async () => {
@@ -129,7 +193,6 @@ describe("LlamafileManagerService", () => {
     it("spawns llamafile process and streams output", async () => {
       const service = await getService();
 
-      // Mock listBinaries/resolveBinary
       statMock.mockResolvedValue({ isDirectory: () => true });
       readdirMock.mockResolvedValue([
         { name: "test.llamafile", isFile: () => true },
@@ -161,6 +224,7 @@ describe("LlamafileManagerService", () => {
         setHeader: jest.fn(),
         flushHeaders: jest.fn(),
         status: jest.fn().mockReturnThis(),
+        json: jest.fn(),
       }) as any;
 
       const body = {
@@ -177,7 +241,7 @@ describe("LlamafileManagerService", () => {
         false,
       );
 
-      await new Promise((resolve) => setTimeout(resolve, 0)); // Wait for spawn
+      await new Promise((resolve) => setTimeout(resolve, 0));
 
       child.stdout.emit(
         "data",
@@ -192,5 +256,165 @@ describe("LlamafileManagerService", () => {
       );
       expect(res.end).toHaveBeenCalled();
     });
+
+    it("handles non-streaming responses and parses tool calls", async () => {
+      const service = await getService();
+
+      statMock.mockResolvedValue({ isDirectory: () => true });
+      readdirMock.mockResolvedValue([
+        { name: "test.llamafile", isFile: () => true },
+      ]);
+      accessMock.mockResolvedValue(undefined);
+
+      const child: any = new EventEmitter();
+      child.stdout = new EventEmitter();
+      child.stderr = new EventEmitter();
+      child.pid = 1234;
+      child.kill = jest.fn();
+      child.exitCode = null;
+      child.signalCode = null;
+      child.killed = false;
+
+      spawnMock.mockImplementation(() => {
+        queueMicrotask(() => child.emit("spawn"));
+
+        return child;
+      });
+
+      const req: any = new EventEmitter();
+      req.headers = {};
+      req.socket = new EventEmitter();
+
+      const res = Object.assign(new EventEmitter(), {
+        write: jest.fn(),
+        end: jest.fn(),
+        setHeader: jest.fn(),
+        flushHeaders: jest.fn(),
+        status: jest.fn().mockReturnThis(),
+        json: jest.fn(),
+      }) as any;
+
+      const body = {
+        model: "test",
+        messages: [{ role: "user", content: "hi" }],
+        stream: false,
+      };
+
+      const promise = service.invokeCli(
+        req,
+        res,
+        body,
+        { model: "test", offline: false },
+        false,
+      );
+
+      await new Promise((resolve) => setTimeout(resolve, 0));
+
+      child.stdout.emit(
+        "data",
+        Buffer.from(
+          'USER: hi\n\nASSISTANT: call:web_search{"query":"test"}',
+          "utf8",
+        ),
+      );
+      child.emit("close", 0);
+
+      await promise;
+
+      expect(res.json).toHaveBeenCalledWith(
+        expect.objectContaining({
+          choices: expect.arrayContaining([
+            expect.objectContaining({
+              message: expect.objectContaining({
+                tool_calls: expect.arrayContaining([
+                  expect.objectContaining({
+                    function: expect.objectContaining({ name: "web_search" }),
+                  }),
+                ]),
+              }),
+            }),
+          ]),
+        }),
+      );
+    });
+
+    it("throws error when binary is not executable", async () => {
+      const service = await getService();
+      statMock.mockResolvedValue({ isDirectory: () => true });
+      readdirMock.mockResolvedValue([
+        { name: "test.llamafile", isFile: () => true },
+      ]);
+      accessMock.mockRejectedValue(new Error("EACCES: permission denied"));
+
+      const req: any = { headers: {} };
+      const res: any = {};
+
+      await expect(
+        service.invokeCli(
+          req,
+          res,
+          { model: "test", messages: [{ role: "user", content: "hi" }] },
+          { model: "test", offline: false },
+          false,
+        ),
+      ).rejects.toThrow(/Binary not executable or not found/);
+    });
+
+    it("cancels active requests and extracts request IDs", async () => {
+      const service = await getService();
+
+      // 1. cancelRequest
+      expect(service.cancelRequest("non-existent")).toBe(false);
+
+      const cancelFn = jest.fn(() => {
+        service.__getActiveRequests().delete("req-123");
+      });
+      service.__getActiveRequests().set("req-123", cancelFn);
+      expect(service.cancelRequest("req-123")).toBe(true);
+      expect(cancelFn).toHaveBeenCalled();
+      expect(service.__getActiveRequests().has("req-123")).toBe(false);
+
+      // 2. getLlamafileRequestId
+      const reqWithHeader = {
+        headers: { "x-shadowclaw-request-id": "header-id" },
+      } as any;
+      expect(service.getLlamafileRequestId(reqWithHeader)).toBe("header-id");
+
+      const reqWithBody = { headers: {} } as any;
+      const bodyWithId = { requestId: "body-id" };
+      expect(service.getLlamafileRequestId(reqWithBody, bodyWithId)).toBe(
+        "body-id",
+      );
+    });
+
+    it("handles invokeLlamafileServer forwarding", async () => {
+      const { invokeLlamafileServer } = await import("./llamafile-manager.js");
+
+      const req: any = { headers: {} };
+      const res: any = {
+        status: jest.fn().mockReturnThis(),
+        setHeader: jest.fn().mockReturnThis(),
+        send: jest.fn().mockReturnThis(),
+      };
+
+      // Mock fetch response for server error
+      (global.fetch as any) = jest.fn<any>().mockResolvedValue({
+        ok: false,
+        status: 502,
+        headers: new Headers({ "x-custom": "test" }),
+        text: async () => "Bad Gateway",
+      });
+
+      await invokeLlamafileServer(
+        req,
+        res,
+        { model: "custom-model", messages: [] },
+        { host: "127.0.0.1", port: 8080 },
+        false,
+      );
+
+      expect(res.status).toHaveBeenCalledWith(502);
+      expect(res.send).toHaveBeenCalledWith("Bad Gateway");
+    });
   });
 });