shadow-claw 1.23.3 → 1.24.0

package/src/server/routes/llamafile.test.ts

@@ -10,20 +10,18 @@ describe("llamafile-routes", () => {
       statusCode: 200,
       body: undefined,
       headers: {},
+      headersSent: false,
       status: jest.fn().mockImplementation((code: any) => {
         res.statusCode = code;
-
         return res;
       }),
       json: jest.fn().mockImplementation((payload: any) => {
         res.body = payload;
-
         return res;
       }),
       write: jest.fn(),
       end: jest.fn(),
     };
-
     return res;
   }
 
@@ -55,71 +53,197 @@ describe("llamafile-routes", () => {
       }),
     };
 
-    registerLlamafileRoutes(app as any, service, { verbose: false });
+    registerLlamafileRoutes(app as any, service, { verbose: true });
   });
 
-  it("lists local llamafile binaries", async () => {
-    const handler = routes.get("GET /llamafile-proxy/models");
-    service.listBinaries.mockResolvedValue([
-      { id: "model.llamafile", fileName: "model.llamafile" },
-    ]);
+  describe("GET /llamafile-proxy/models", () => {
+    it("lists local llamafile binaries", async () => {
+      const handler = routes.get("GET /llamafile-proxy/models");
+      service.listBinaries.mockResolvedValue([
+        { id: "model.llamafile", fileName: "model.llamafile" },
+      ]);
+
+      const res = createResponse();
+      await handler({}, res);
+
+      expect(res.json).toHaveBeenCalledWith({
+        data: [expect.objectContaining({ id: "model.llamafile" })],
+      });
+    });
+
+    it("handles failure listing binaries with 502 status", async () => {
+      const handler = routes.get("GET /llamafile-proxy/models");
+      service.listBinaries.mockRejectedValue(new Error("Disk access denied"));
 
-    const res = createResponse();
-    await handler({}, res);
+      const errSpy = jest.spyOn(console, "error").mockImplementation(() => {});
+      const res = createResponse();
+      await handler({}, res);
 
-    expect(res.json).toHaveBeenCalledWith({
-      data: [expect.objectContaining({ id: "model.llamafile" })],
+      expect(res.status).toHaveBeenCalledWith(502);
+      expect(res.body.error).toContain(
+        "Failed to list llamafile binaries: Disk access denied",
+      );
+      errSpy.mockRestore();
     });
   });
 
-  it("cancels an active llamafile request", async () => {
-    const handler = routes.get("POST /llamafile-proxy/cancel");
-    service.getLlamafileRequestId.mockReturnValue("req-123");
-    service.cancelRequest.mockReturnValue(true);
+  describe("POST /llamafile-proxy/cancel", () => {
+    it("returns 400 when request id is missing", async () => {
+      const handler = routes.get("POST /llamafile-proxy/cancel");
+      service.getLlamafileRequestId.mockReturnValue(undefined);
 
-    const req = { body: { id: "req-123" } };
-    const res = createResponse();
+      const res = createResponse();
+      await handler({ body: {} }, res);
 
-    await handler(req, res);
+      expect(res.status).toHaveBeenCalledWith(400);
+      expect(res.body.error).toContain("Missing llamafile request id");
+    });
 
-    expect(res.status).toHaveBeenCalledWith(202);
-    expect(res.json).toHaveBeenCalledWith({ ok: true, cancelled: true });
-  });
+    it("returns 200 when request was not found or already completed", async () => {
+      const handler = routes.get("POST /llamafile-proxy/cancel");
+      service.getLlamafileRequestId.mockReturnValue("req-123");
+      service.cancelRequest.mockReturnValue(false);
+
+      const res = createResponse();
+      await handler({ body: { id: "req-123" } }, res);
 
-  it("invokes llamafile in CLI mode", async () => {
-    const handler = routes.get("POST /llamafile-proxy/chat/completions");
-    service.getLlamafileRuntimeOptions.mockReturnValue({
-      mode: "cli",
-      offline: true,
+      expect(res.status).toHaveBeenCalledWith(200);
+      expect(res.body).toEqual({ ok: true, cancelled: false });
     });
 
-    const req = { body: { model: "model.llamafile" }, headers: {} };
-    const res = createResponse();
+    it("cancels an active llamafile request", async () => {
+      const handler = routes.get("POST /llamafile-proxy/cancel");
+      service.getLlamafileRequestId.mockReturnValue("req-123");
+      service.cancelRequest.mockReturnValue(true);
 
-    await handler(req, res);
+      const req = { body: { id: "req-123" } };
+      const res = createResponse();
 
-    expect(service.invokeCli).toHaveBeenCalled();
+      await handler(req, res);
+
+      expect(res.status).toHaveBeenCalledWith(202);
+      expect(res.json).toHaveBeenCalledWith({ ok: true, cancelled: true });
+    });
   });
 
-  it("invokes llamafile in SERVER mode", async () => {
-    const handler = routes.get("POST /llamafile-proxy/chat/completions");
-    service.getLlamafileRuntimeOptions.mockReturnValue({
-      mode: "server",
-      host: "127.0.0.1",
-      port: 8080,
+  describe("POST /llamafile-proxy/chat/completions", () => {
+    it("returns 400 when body is missing or not an object", async () => {
+      const handler = routes.get("POST /llamafile-proxy/chat/completions");
+      const res = createResponse();
+      await handler({ body: null, headers: {} }, res);
+
+      expect(res.status).toHaveBeenCalledWith(400);
+      expect(res.body.error).toBe("Missing request body");
     });
 
-    const req = { body: { model: "model.llamafile" }, headers: {} };
-    const res = createResponse();
+    it("returns 400 in CLI mode when model is missing", async () => {
+      const handler = routes.get("POST /llamafile-proxy/chat/completions");
+      service.getLlamafileRuntimeOptions.mockReturnValue({
+        mode: "cli",
+        offline: true,
+      });
 
-    await handler(req, res);
+      const res = createResponse();
+      await handler({ body: { model: "  " }, headers: {} }, res);
 
-    expect(invokeLlamafileServerMock).toHaveBeenCalledWith(
-      req,
-      res,
-      req.body,
-      expect.objectContaining({ host: "127.0.0.1", port: 8080 }),
-      false,
-    );
+      expect(res.status).toHaveBeenCalledWith(400);
+      expect(res.body.error).toContain(
+        "Missing or invalid 'model' parameter for CLI mode",
+      );
+    });
+
+    it("invokes llamafile in CLI mode", async () => {
+      const handler = routes.get("POST /llamafile-proxy/chat/completions");
+      service.getLlamafileRuntimeOptions.mockReturnValue({
+        mode: "cli",
+        offline: true,
+      });
+
+      const req = {
+        body: { model: "model.llamafile", llamafile: { mode: "cli" } },
+        headers: { "x-llamafile-mode": "cli" },
+      };
+      const res = createResponse();
+
+      await handler(req, res);
+
+      expect(service.invokeCli).toHaveBeenCalledWith(
+        req,
+        res,
+        req.body,
+        { model: "model.llamafile", offline: true },
+        true,
+      );
+    });
+
+    it("invokes llamafile in SERVER mode", async () => {
+      const handler = routes.get("POST /llamafile-proxy/chat/completions");
+      service.getLlamafileRuntimeOptions.mockReturnValue({
+        mode: "server",
+        host: "127.0.0.1",
+        port: 8080,
+      });
+
+      const req = { body: { model: "model.llamafile" }, headers: {} };
+      const res = createResponse();
+
+      await handler(req, res);
+
+      expect(invokeLlamafileServerMock).toHaveBeenCalledWith(
+        req,
+        res,
+        req.body,
+        expect.objectContaining({ host: "127.0.0.1", port: 8080 }),
+        true,
+      );
+    });
+
+    it("handles invocation failure before headers sent with 502", async () => {
+      const handler = routes.get("POST /llamafile-proxy/chat/completions");
+      service.getLlamafileRuntimeOptions.mockReturnValue({
+        mode: "cli",
+      });
+      service.invokeCli.mockRejectedValue(new Error("Process crashed"));
+
+      const errSpy = jest.spyOn(console, "error").mockImplementation(() => {});
+      const req = { body: { model: "model.llamafile" }, headers: {} };
+      const res = createResponse();
+
+      await handler(req, res);
+
+      expect(res.status).toHaveBeenCalledWith(502);
+      expect(res.body.error).toContain(
+        "Llamafile invocation failed: Process crashed",
+      );
+      errSpy.mockRestore();
+    });
+
+    it("handles invocation failure after headers sent by writing SSE error event", async () => {
+      const handler = routes.get("POST /llamafile-proxy/chat/completions");
+      service.getLlamafileRuntimeOptions.mockReturnValue({
+        mode: "server",
+        host: "127.0.0.1",
+        port: 8080,
+      });
+      invokeLlamafileServerMock.mockImplementation(
+        async (_req: any, res: any) => {
+          res.headersSent = true;
+          throw new Error("Stream broken midway");
+        },
+      );
+
+      const errSpy = jest.spyOn(console, "error").mockImplementation(() => {});
+      const req = { body: { model: "model.llamafile" }, headers: {} };
+      const res = createResponse();
+
+      await handler(req, res);
+
+      expect(res.write).toHaveBeenCalledWith(
+        expect.stringContaining('"message":"Stream broken midway"'),
+      );
+      expect(res.write).toHaveBeenCalledWith("data: [DONE]\n\n");
+      expect(res.end).toHaveBeenCalled();
+      errSpy.mockRestore();
+    });
   });
 });

package/src/server/routes/mesh-llm.test.ts

@@ -0,0 +1,192 @@
+import { jest } from "@jest/globals";
+
+describe("mesh-llm routes", () => {
+  let routes: Map<string, any>;
+  let mockHandleProxyRequest: jest.Mock<any>;
+  let mockHandleStreamingProxyRequest: jest.Mock<any>;
+
+  function createResponse() {
+    const res: any = {
+      statusCode: 200,
+      body: undefined,
+      headers: {},
+      status: jest.fn().mockImplementation((code: any) => {
+        res.statusCode = code;
+        return res;
+      }),
+      json: jest.fn().mockImplementation((payload: any) => {
+        res.body = payload;
+        return res;
+      }),
+    };
+    return res;
+  }
+
+  beforeEach(async () => {
+    jest.resetModules();
+    routes = new Map();
+
+    mockHandleProxyRequest = jest.fn().mockResolvedValue(undefined as never);
+    mockHandleStreamingProxyRequest = jest
+      .fn()
+      .mockResolvedValue(undefined as never);
+
+    jest.unstable_mockModule("../utils/proxy-helpers.js", () => ({
+      handleProxyRequest: mockHandleProxyRequest,
+      handleStreamingProxyRequest: mockHandleStreamingProxyRequest,
+    }));
+
+    const { registerMeshLlmRoutes } = await import("./mesh-llm.js");
+
+    const app = {
+      get: jest.fn((path: string, handler: any) => {
+        routes.set(`GET ${path}`, handler);
+      }),
+      post: jest.fn((path: string, handler: any) => {
+        routes.set(`POST ${path}`, handler);
+      }),
+    };
+
+    registerMeshLlmRoutes(app as any, { verbose: true });
+  });
+
+  describe("POST /mesh-llm-proxy/chat/completions", () => {
+    const route = "POST /mesh-llm-proxy/chat/completions";
+
+    it("handles non-streaming chat completions proxying", async () => {
+      const handler = routes.get(route);
+      const req = {
+        headers: {
+          host: "localhost",
+          origin: "http://localhost",
+          referer: "http://localhost/chat",
+          authorization: "Bearer mesh-token",
+          "x-mesh-llm-host": "https://custom.mesh.io",
+        },
+        body: {
+          model: "mesh-70b",
+          messages: [{ role: "user", content: "hello" }],
+          stream: false,
+        },
+      };
+      const res = createResponse();
+
+      await handler(req, res);
+
+      expect(mockHandleProxyRequest).toHaveBeenCalledWith(
+        req,
+        res,
+        expect.objectContaining({
+          targetUrl: "https://custom.mesh.io/v1/chat/completions",
+          method: "POST",
+          headers: {
+            authorization: "Bearer mesh-token",
+            "x-mesh-llm-host": "https://custom.mesh.io",
+          },
+          body: JSON.stringify(req.body),
+        }),
+      );
+    });
+
+    it("handles streaming chat completions proxying with array header", async () => {
+      const handler = routes.get(route);
+      const req = {
+        headers: {
+          host: "localhost",
+          authorization: "Bearer mesh-token",
+          "x-mesh-llm-host": ["https://node1.mesh.io", "https://node2.mesh.io"],
+        },
+        body: {
+          model: "mesh-70b",
+          messages: [{ role: "user", content: "stream hello" }],
+          stream: true,
+        },
+      };
+      const res = createResponse();
+
+      await handler(req, res);
+
+      expect(mockHandleStreamingProxyRequest).toHaveBeenCalledWith(
+        req,
+        res,
+        expect.objectContaining({
+          targetUrl: "https://node1.mesh.io/v1/chat/completions",
+          headers: expect.not.objectContaining({ host: "localhost" }),
+          body: JSON.stringify(req.body),
+        }),
+      );
+    });
+  });
+
+  describe("GET /mesh-llm-proxy/models", () => {
+    const route = "GET /mesh-llm-proxy/models";
+
+    it("fetches and normalises models catalog", async () => {
+      const handler = routes.get(route);
+      const mockCatalog = {
+        data: [
+          {
+            id: "model-1",
+            metadata: {
+              context_length: 32768,
+            },
+          },
+          {
+            id: "model-2",
+          },
+        ],
+      };
+
+      (globalThis as any).fetch = (jest.fn() as any).mockResolvedValue({
+        ok: true,
+        json: async () => mockCatalog,
+      });
+
+      const req = { headers: {} };
+      const res = createResponse();
+
+      await handler(req, res);
+
+      expect(res.json).toHaveBeenCalledWith({
+        data: [
+          {
+            id: "model-1",
+            metadata: { context_length: 32768 },
+            context_length: 32768,
+          },
+          {
+            id: "model-2",
+          },
+        ],
+      });
+    });
+
+    it("falls back to default fallback model on fetch failure", async () => {
+      const handler = routes.get(route);
+      (globalThis as any).fetch = (jest.fn() as any).mockResolvedValue({
+        ok: false,
+        status: 500,
+        statusText: "Internal Server Error",
+        text: async () => "Upstream error",
+      });
+
+      const errSpy = jest.spyOn(console, "error").mockImplementation(() => {});
+      const req = { headers: {} };
+      const res = createResponse();
+
+      await handler(req, res);
+
+      expect(res.json).toHaveBeenCalledWith({
+        models: [
+          {
+            id: "mesh",
+            name: "mesh",
+            context_length: 8000,
+            max_completion_tokens: 4096,
+          },
+        ],
+      });
+      errSpy.mockRestore();
+    });
+  });
+});

package/src/server/routes/ollama.test.ts

@@ -164,4 +164,53 @@ describe("ollama-routes", () => {
     expect(res.write).toHaveBeenCalledWith(expect.any(Buffer));
     expect(res.end).toHaveBeenCalled();
   });
+
+  it("handles non-streaming error responses and exceptions", async () => {
+    const handler = routes.get("POST /ollama-proxy/chat/completions");
+
+    // Upstream error response
+    globalFetchMock.mockResolvedValueOnce({
+      ok: false,
+      status: 400,
+      text: async () => "Bad request from Ollama",
+    });
+
+    const req1 = {
+      body: { model: "llama3", messages: [], stream: false },
+      headers: {},
+    };
+    const res1 = createResponse();
+    await handler(req1, res1);
+
+    expect(res1.status).toHaveBeenCalledWith(400);
+    expect(res1.json).toHaveBeenCalledWith({
+      error: "Bad request from Ollama",
+    });
+
+    // Exception throw
+    globalFetchMock.mockRejectedValueOnce(new Error("Connection refused"));
+
+    const req2 = {
+      body: { model: "llama3", messages: [], stream: false },
+      headers: {},
+    };
+    const res2 = createResponse();
+    await handler(req2, res2);
+
+    expect(res2.status).toHaveBeenCalledWith(502);
+  });
+
+  it("handles models route failure gracefully", async () => {
+    const handler = routes.get("GET /ollama-proxy/models");
+
+    globalFetchMock.mockResolvedValueOnce({
+      ok: false,
+      status: 500,
+    });
+
+    const res = createResponse();
+    await handler({}, res);
+
+    expect(res.status).toHaveBeenCalledWith(502);
+  });
 });

package/src/server/server-peer.test.ts

@@ -0,0 +1,86 @@
+import { jest } from "@jest/globals";
+import { ServerPeer } from "./server-peer.js";
+
+describe("ServerPeer", () => {
+  it("initializes ServerPeer with options and handlers", () => {
+    const mockHandler = jest.fn();
+    const peer = new ServerPeer({
+      peerId: "test-server-peer",
+      host: "127.0.0.1",
+      port: 8888,
+      handlers: {
+        "custom-action": mockHandler,
+      },
+    });
+
+    expect(peer.peerId).toBe("test-server-peer");
+    expect(peer.isOpen).toBe(false);
+    expect(peer.getConnectedPeers()).toEqual([]);
+  });
+
+  it("handles incoming command:execute and command:result payloads", async () => {
+    const mockHandler = jest.fn(async (args: any) => ({
+      ok: true,
+      echo: args.text,
+    }));
+    const peer = new ServerPeer({
+      peerId: "test-server-peer",
+      handlers: {
+        "echo-test": mockHandler,
+      },
+    });
+
+    const sentMessages: any[] = [];
+    const mockConn = {
+      peer: "remote-client-peer",
+      send: (data: any) => sentMessages.push(data),
+    };
+
+    // Simulate incoming command:execute
+    await (peer as any)._handleData("remote-client-peer", mockConn, {
+      id: "req-1",
+      type: "command:execute",
+      payload: {
+        commandId: "cmd-1",
+        action: "echo-test",
+        args: { text: "hello peer" },
+      },
+    });
+
+    expect(mockHandler).toHaveBeenCalledWith({ text: "hello peer" });
+    expect(sentMessages).toHaveLength(1);
+    expect(sentMessages[0].type).toBe("command:result");
+    expect(sentMessages[0].payload.success).toBe(true);
+    expect(sentMessages[0].payload.data).toEqual({
+      ok: true,
+      echo: "hello peer",
+    });
+  });
+
+  it("handles unknown action error", async () => {
+    const peer = new ServerPeer({
+      peerId: "test-server-peer",
+    });
+
+    const sentMessages: any[] = [];
+    const mockConn = {
+      peer: "remote-client-peer",
+      send: (data: any) => sentMessages.push(data),
+    };
+
+    await (peer as any)._handleData("remote-client-peer", mockConn, {
+      id: "req-2",
+      type: "command:execute",
+      payload: {
+        commandId: "cmd-2",
+        action: "unregistered-action",
+        args: {},
+      },
+    });
+
+    expect(sentMessages).toHaveLength(1);
+    expect(sentMessages[0].type).toBe("command:result");
+    expect(sentMessages[0].payload.success).toBe(false);
+    expect(sentMessages[0].payload.error).toContain("Unknown action");
+  });
+});