shadow-claw 1.51.0 → 1.52.1

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

@@ -339,4 +339,248 @@ describe("Gemini proxy", () => {
       }),
     );
   });
+
+  it("returns 401 when API key is missing", async () => {
+    const oldKey = process.env.GEMINI_API_KEY;
+    delete process.env.GEMINI_API_KEY;
+    try {
+      const handler = routes.get("POST /gemini-proxy/chat/completions");
+      const req = { body: {}, headers: {} } as any;
+      const res = {
+        status: jest.fn().mockReturnThis(),
+        json: jest.fn(),
+      } as any;
+
+      await handler(req, res);
+      expect(res.status).toHaveBeenCalledWith(401);
+
+      const modelsHandler = routes.get("GET /gemini-proxy/models");
+      await modelsHandler(req, res);
+      expect(res.status).toHaveBeenCalledWith(401);
+    } finally {
+      if (oldKey) process.env.GEMINI_API_KEY = oldKey;
+    }
+  });
+
+  it("handles multimodal content and tools in non-streaming completions", async () => {
+    const handler = routes.get("POST /gemini-proxy/chat/completions");
+
+    mockGenerateContent.mockResolvedValue({
+      get text() {
+        return "";
+      },
+      candidates: [
+        {
+          content: {
+            parts: [
+              {
+                functionCall: {
+                  name: "fetch_url",
+                  args: { url: "https://example.com" },
+                },
+              },
+            ],
+          },
+        },
+      ],
+      usageMetadata: {
+        promptTokenCount: 5,
+        candidatesTokenCount: 10,
+        totalTokenCount: 15,
+      },
+    });
+
+    const req = {
+      body: {
+        model: "gemini-2.0-flash",
+        messages: [
+          { role: "system", content: "You are helpful" },
+          {
+            role: "user",
+            content: [
+              { type: "text", text: "Look at this" },
+              {
+                type: "image_url",
+                image_url: { url: "data:image/png;base64,iVBORw0KGgo=" },
+              },
+              { type: "tool_use", name: "calculator", input: { a: 1 } },
+              { type: "tool_result", name: "calculator", content: "2" },
+              { type: "unknown" },
+            ],
+          },
+          { role: "assistant", content: "working" },
+          { role: "tool", content: "result" },
+        ],
+        tools: [
+          {
+            function: {
+              name: "fetch_url",
+              description: "Fetch URL",
+              parameters: { type: "object" },
+            },
+          },
+        ],
+      },
+      headers: { "x-goog-api-key": "test-key" },
+    } as any;
+
+    const res = {
+      status: jest.fn().mockReturnThis(),
+      json: jest.fn(),
+    } as any;
+
+    await handler(req, res);
+
+    expect(res.json).toHaveBeenCalledWith(
+      expect.objectContaining({
+        choices: [
+          expect.objectContaining({
+            finish_reason: "tool_calls",
+            message: expect.objectContaining({
+              role: "assistant",
+              tool_calls: [
+                expect.objectContaining({
+                  function: expect.objectContaining({
+                    name: "fetch_url",
+                  }),
+                }),
+              ],
+            }),
+          }),
+        ],
+      }),
+    );
+  });
+
+  it("handles streaming chunks with reasoning and function calls", async () => {
+    const handler = routes.get("POST /gemini-proxy/chat/completions");
+
+    const asyncIterable = (async function* () {
+      yield {
+        text: "Thinking...",
+        candidates: [
+          {
+            content: {
+              parts: [
+                { thought: true, text: "Let me check..." },
+                {
+                  functionCall: {
+                    name: "test_tool",
+                    args: { x: 1 },
+                  },
+                },
+              ],
+            },
+          },
+        ],
+      };
+      yield {
+        text: "Done!",
+      };
+    })();
+
+    mockGenerateContentStream.mockResolvedValue(asyncIterable);
+
+    const written: string[] = [];
+    const req = {
+      body: {
+        stream: true,
+        messages: [{ role: "user", content: "run test" }],
+      },
+      headers: { "x-goog-api-key": "test-key" },
+    } as any;
+
+    const res = {
+      setHeader: jest.fn(),
+      flushHeaders: jest.fn(),
+      write: jest.fn((chunk: string) => written.push(chunk)),
+      end: jest.fn(),
+    } as any;
+
+    await handler(req, res);
+
+    expect(res.setHeader).toHaveBeenCalledWith(
+      "Content-Type",
+      "text/event-stream",
+    );
+    expect(res.end).toHaveBeenCalled();
+    expect(written.length).toBeGreaterThan(0);
+  });
+
+  it("handles errors during completion with JSON error payload", async () => {
+    const handler = routes.get("POST /gemini-proxy/chat/completions");
+
+    mockGenerateContent.mockRejectedValue(
+      new Error(
+        JSON.stringify({ error: { code: 429, message: "Resource exhausted" } }),
+      ),
+    );
+
+    const req = {
+      body: { messages: [{ role: "user", content: "hi" }] },
+      headers: { "x-goog-api-key": "test-key" },
+    } as any;
+
+    const res = {
+      headersSent: false,
+      status: jest.fn().mockReturnThis(),
+      json: jest.fn(),
+    } as any;
+
+    await handler(req, res);
+    expect(res.status).toHaveBeenCalledWith(429);
+  });
+
+  it("provides fallback models when listing fails during iteration or yields empty list", async () => {
+    const handler = routes.get("GET /gemini-proxy/models");
+
+    const throwingIterable = (async function* () {
+      throw new Error("Quota exceeded during iteration");
+    })();
+    mockListModels.mockResolvedValue(throwingIterable);
+
+    const req = {
+      headers: { "x-goog-api-key": "test-key" },
+    } as any;
+
+    const res = {
+      status: jest.fn().mockReturnThis(),
+      json: jest.fn(),
+    } as any;
+
+    await handler(req, res);
+
+    expect(res.json).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.arrayContaining([
+          expect.objectContaining({ id: "gemini-2.0-flash" }),
+          expect.objectContaining({ id: "gemini-1.5-flash" }),
+        ]),
+      }),
+    );
+  });
+
+  it("returns 502 when models.list() itself throws", async () => {
+    const handler = routes.get("GET /gemini-proxy/models");
+
+    mockListModels.mockRejectedValue(new Error("Network failure"));
+
+    const req = {
+      headers: { "x-goog-api-key": "test-key" },
+    } as any;
+
+    const res = {
+      status: jest.fn().mockReturnThis(),
+      json: jest.fn(),
+    } as any;
+
+    await handler(req, res);
+
+    expect(res.status).toHaveBeenCalledWith(502);
+    expect(res.json).toHaveBeenCalledWith(
+      expect.objectContaining({
+        error: expect.stringContaining("Network failure"),
+      }),
+    );
+  });
 });

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

@@ -1,13 +1,73 @@
 import { jest } from "@jest/globals";
-import { ServerPeer } from "./server-peer.js";
+import { EventEmitter } from "node:events";
+
+class MockConn extends EventEmitter {
+  public peer: string;
+  public open = false;
+  public sent: any[] = [];
+
+  constructor(peer: string) {
+    super();
+    this.peer = peer;
+  }
+
+  send(data: any) {
+    this.sent.push(data);
+  }
+
+  close() {
+    this.open = false;
+    this.emit("close");
+  }
+}
+
+class MockPeer extends EventEmitter {
+  public id: string;
+  public options: any;
+  public connections: MockConn[] = [];
+
+  constructor(id: string, options: any) {
+    super();
+    this.id = id;
+    this.options = options;
+  }
+
+  connect(remotePeerId: string) {
+    const conn = new MockConn(remotePeerId);
+    this.connections.push(conn);
+    return conn;
+  }
+
+  destroy() {
+    this.emit("close");
+  }
+}
+
+let mockPeerInstance: MockPeer | null = null;
+const mockPeerConstructor = jest.fn((id: string, opts: any) => {
+  mockPeerInstance = new MockPeer(id, opts);
+  return mockPeerInstance;
+});
+
+jest.unstable_mockModule("./webrtc.js", () => ({
+  getPeerClass: jest.fn(async () => mockPeerConstructor),
+}));
+
+const { ServerPeer } = await import("./server-peer.js");
 
 describe("ServerPeer", () => {
+  beforeEach(() => {
+    mockPeerInstance = null;
+    jest.clearAllMocks();
+  });
+
   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,
+      verbose: true,
       handlers: {
         "custom-action": mockHandler,
       },
@@ -18,6 +78,49 @@ describe("ServerPeer", () => {
     expect(peer.getConnectedPeers()).toEqual([]);
   });
 
+  it("starts successfully and handles peer lifecycle", async () => {
+    const peer = new ServerPeer({
+      peerId: "my-peer",
+      verbose: true,
+    });
+
+    const startPromise = peer.start();
+    await new Promise((r) => setTimeout(r, 10));
+    expect(mockPeerInstance).toBeDefined();
+
+    mockPeerInstance!.emit("open", "my-peer");
+    const id = await startPromise;
+    expect(id).toBe("my-peer");
+    expect(peer.isOpen).toBe(true);
+
+    // Incoming connection from remote peer
+    const incomingConn = new MockConn("remote-client");
+    mockPeerInstance!.emit("connection", incomingConn);
+
+    incomingConn.open = true;
+    incomingConn.emit("open");
+    expect(peer.isPeerConnected("remote-client")).toBe(true);
+    expect(peer.getConnectedPeers()).toEqual(["remote-client"]);
+
+    // Connection error and close
+    incomingConn.emit("error", new Error("DataChannel drop"));
+    incomingConn.emit("close");
+    expect(peer.isPeerConnected("remote-client")).toBe(false);
+
+    // Peer close
+    mockPeerInstance!.emit("close");
+    expect(peer.isOpen).toBe(false);
+  });
+
+  it("handles start error before open", async () => {
+    const peer = new ServerPeer({ peerId: "err-peer" });
+    const startPromise = peer.start();
+    await new Promise((r) => setTimeout(r, 10));
+
+    mockPeerInstance!.emit("error", new Error("Signaling unreachable"));
+    await expect(startPromise).rejects.toThrow("Signaling unreachable");
+  });
+
   it("handles incoming command:execute and command:result payloads", async () => {
     const mockHandler = jest.fn(async (args: any) => ({
       ok: true,
@@ -36,16 +139,20 @@ describe("ServerPeer", () => {
       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" },
-      },
-    });
+    // Simulate string rawData with JSON parsing
+    await (peer as any)._handleData(
+      "remote-client-peer",
+      mockConn,
+      JSON.stringify({
+        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);
@@ -57,6 +164,38 @@ describe("ServerPeer", () => {
     });
   });
 
+  it("handles handler exception during command:execute", async () => {
+    const mockHandler = jest.fn(async () => {
+      throw new Error("Action failure");
+    });
+    const peer = new ServerPeer({
+      peerId: "test-server-peer",
+      handlers: {
+        "failing-action": mockHandler,
+      },
+    });
+
+    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-fail",
+      type: "command:execute",
+      payload: {
+        commandId: "cmd-fail",
+        action: "failing-action",
+        args: {},
+      },
+    });
+
+    expect(sentMessages).toHaveLength(1);
+    expect(sentMessages[0].payload.success).toBe(false);
+    expect(sentMessages[0].payload.error).toBe("Action failure");
+  });
+
   it("handles unknown action error", async () => {
     const peer = new ServerPeer({
       peerId: "test-server-peer",
@@ -83,4 +222,99 @@ describe("ServerPeer", () => {
     expect(sentMessages[0].payload.success).toBe(false);
     expect(sentMessages[0].payload.error).toContain("Unknown action");
   });
+
+  it("ignores invalid or non-object rawData", async () => {
+    const peer = new ServerPeer();
+    const mockConn = { send: jest.fn() };
+
+    await (peer as any)._handleData("remote", mockConn, "invalid-json{");
+    await (peer as any)._handleData("remote", mockConn, null);
+    await (peer as any)._handleData("remote", mockConn, 123);
+    expect(mockConn.send).not.toHaveBeenCalled();
+  });
+
+  it("sends command to connected peer and resolves on result", async () => {
+    const peer = new ServerPeer({ peerId: "server-sender" });
+    const startPromise = peer.start();
+    await new Promise((r) => setTimeout(r, 10));
+    mockPeerInstance!.emit("open", "server-sender");
+    await startPromise;
+
+    const mockConn = new MockConn("target-peer");
+    mockConn.open = true;
+    (peer as any)._connections.set("target-peer", mockConn);
+
+    const sendPromise = peer.sendCommand("target-peer", "ping", { val: 1 });
+    expect(mockConn.sent).toHaveLength(1);
+    const sentMsg = mockConn.sent[0];
+    const cmdId = sentMsg.payload.commandId;
+
+    // Simulate incoming command:result from remote peer
+    await (peer as any)._handleData("target-peer", mockConn, {
+      type: "command:result",
+      payload: {
+        commandId: cmdId,
+        success: true,
+        data: "pong",
+      },
+    });
+
+    const result = await sendPromise;
+    expect(result.success).toBe(true);
+    expect(result.data).toBe("pong");
+  });
+
+  it("throws when sendCommand is called before peer is started", async () => {
+    const peer = new ServerPeer();
+    await expect(peer.sendCommand("target", "action")).rejects.toThrow(
+      "Server peer is not running",
+    );
+  });
+
+  it("connects to remote peer if not already connected when sending command", async () => {
+    const peer = new ServerPeer({ peerId: "server-sender" });
+    const startPromise = peer.start();
+    await new Promise((r) => setTimeout(r, 10));
+    mockPeerInstance!.emit("open", "server-sender");
+    await startPromise;
+
+    const sendPromise = peer.sendCommand("new-remote", "fetch-data");
+    const createdConn = mockPeerInstance!.connections[0];
+    expect(createdConn).toBeDefined();
+
+    createdConn.open = true;
+    createdConn.emit("open");
+    await new Promise((r) => setTimeout(r, 10));
+
+    const sentMsg = createdConn.sent[0];
+    await (peer as any)._handleData("new-remote", createdConn, {
+      type: "command:result",
+      payload: {
+        commandId: sentMsg.payload.commandId,
+        success: true,
+      },
+    });
+
+    const res = await sendPromise;
+    expect(res.success).toBe(true);
+  });
+
+  it("closes peer and terminates pending commands and connections", async () => {
+    const peer = new ServerPeer({ peerId: "server-close" });
+    const startPromise = peer.start();
+    await new Promise((r) => setTimeout(r, 10));
+    mockPeerInstance!.emit("open", "server-close");
+    await startPromise;
+
+    const mockConn = new MockConn("peer-1");
+    mockConn.open = true;
+    (peer as any)._connections.set("peer-1", mockConn);
+
+    const pendingPromise = peer.sendCommand("peer-1", "long-job", {}, 10_000);
+    peer.close();
+
+    await expect(pendingPromise).rejects.toThrow("Server peer closed");
+    expect(peer.isOpen).toBe(false);
+    expect(peer.getConnectedPeers()).toHaveLength(0);
+  });
 });