shadow-claw 1.40.0 → 1.40.1

package/src/core/orchestrator/utils/configurePeerJs.test.ts

@@ -204,4 +204,31 @@ describe("configurePeerJs", () => {
 
     expect(mockOrchestrator.peerjs.start).not.toHaveBeenCalled();
   });
+
+  it("should handle non-finite port and empty path/port when serverHost is provided", async () => {
+    mockOrchestrator.getChannelEnabled.mockReturnValue(true);
+
+    await configurePeerJs(
+      mockOrchestrator,
+      mockDb,
+      "my-peer",
+      [],
+      "host.com",
+      NaN,
+      "",
+      true,
+    );
+
+    expect(mockOrchestrator.peerjsServerPort).toBe(0);
+    expect(mockOrchestrator.peerjs.configure).toHaveBeenCalledWith(
+      "my-peer",
+      ["trusted-1", "trusted-2"],
+      {
+        host: "host.com",
+        path: undefined,
+        port: undefined,
+        secure: true,
+      },
+    );
+  });
 });

package/src/core/orchestrator/utils/deliverResponse.test.ts

@@ -81,6 +81,78 @@ describe("deliverResponse", () => {
 
       consoleSpy.mockRestore();
     });
+
+    it("should deliver intermediate response for browser channel without sending to router", async () => {
+      mockOrchestrator.channelRegistry.getChannelType.mockReturnValue(
+        "browser",
+      );
+
+      await deliverIntermediateResponse(
+        mockOrchestrator,
+        mockDb,
+        "group1",
+        "Hello browser",
+      );
+
+      expect(mockOrchestrator.router.send).not.toHaveBeenCalled();
+      expect(mockOrchestrator.events.emit).toHaveBeenCalledWith(
+        "message",
+        expect.objectContaining({
+          channel: "browser",
+          content: "Hello browser",
+        }),
+      );
+    });
+
+    it("should deliver intermediate response over non-browser channel successfully", async () => {
+      mockOrchestrator.channelRegistry.getChannelType.mockReturnValue(
+        "telegram",
+      );
+
+      await deliverIntermediateResponse(
+        mockOrchestrator,
+        mockDb,
+        "group1",
+        "Hello",
+      );
+
+      expect(mockOrchestrator.router.send).toHaveBeenCalledWith(
+        "group1",
+        "Hello",
+      );
+      expect(mockOrchestrator.events.emit).toHaveBeenCalledWith(
+        "message",
+        expect.objectContaining({
+          channel: "telegram",
+          content: "Hello",
+        }),
+      );
+    });
+
+    it("should handle non-Error throw in intermediate response", async () => {
+      mockOrchestrator.channelRegistry.getChannelType.mockReturnValue(
+        "telegram",
+      );
+      mockOrchestrator.router.send.mockRejectedValue("String failure");
+
+      const consoleSpy = (
+        jest.spyOn(console, "error") as any
+      ).mockImplementation();
+
+      await deliverIntermediateResponse(
+        mockOrchestrator,
+        mockDb,
+        "group1",
+        "Hello",
+      );
+
+      expect(mockOrchestrator.events.emit).toHaveBeenCalledWith("error", {
+        groupId: "group1",
+        error: "Failed to deliver response to telegram: String failure",
+      });
+
+      consoleSpy.mockRestore();
+    });
   });
 
   describe("deliverResponse", () => {
@@ -108,6 +180,34 @@ describe("deliverResponse", () => {
       consoleSpy.mockRestore();
     });
 
+    it("should handle non-Error rejection in deliverResponse", async () => {
+      mockOrchestrator.channelRegistry.getChannelType.mockReturnValue(
+        "telegram",
+      );
+      mockOrchestrator.router.send.mockRejectedValue("String error");
+
+      const consoleSpy = (
+        jest.spyOn(console, "error") as any
+      ).mockImplementation();
+
+      await deliverResponse(mockOrchestrator, mockDb, "group1", "Hello");
+
+      expect(mockOrchestrator.events.emit).toHaveBeenCalledWith("error", {
+        groupId: "group1",
+        error: "Failed to deliver response to telegram: String error",
+      });
+
+      consoleSpy.mockRestore();
+    });
+
+    it("should succeed when router is undefined", async () => {
+      mockOrchestrator.router = undefined;
+
+      await deliverResponse(mockOrchestrator, mockDb, "group1", "Hello");
+
+      expect(mockOrchestrator.setState).toHaveBeenCalledWith("idle", "group1");
+    });
+
     it("should play chime and clear pending scheduled task if present", async () => {
       mockOrchestrator.pendingScheduledTasks.add("group1");
 
@@ -127,5 +227,32 @@ describe("deliverResponse", () => {
       );
       expect(mockOrchestrator.peerCompletedContexts.has("peer:123")).toBe(true);
     });
+
+    it("should not add to peerCompletedContexts if completeActiveTask returns false", async () => {
+      mockOrchestrator.channelRegistry.getChannelType.mockReturnValue("peerjs");
+      mockOrchestrator.peerjs.completeActiveTask.mockReturnValue(false);
+
+      await deliverResponse(mockOrchestrator, mockDb, "peer:123", "Hello");
+
+      expect(mockOrchestrator.peerCompletedContexts.has("peer:123")).toBe(
+        false,
+      );
+    });
+
+    it("should not complete active task if group is peer: but deliveryError occurred", async () => {
+      mockOrchestrator.channelRegistry.getChannelType.mockReturnValue("peerjs");
+      mockOrchestrator.router.send.mockRejectedValue(
+        new Error("Peer send failed"),
+      );
+
+      const consoleSpy = (
+        jest.spyOn(console, "error") as any
+      ).mockImplementation();
+
+      await deliverResponse(mockOrchestrator, mockDb, "peer:123", "Hello");
+
+      expect(mockOrchestrator.peerjs.completeActiveTask).not.toHaveBeenCalled();
+      consoleSpy.mockRestore();
+    });
   });
 });

package/src/core/orchestrator/utils/dispatchSubagentInvoke.test.ts

@@ -185,6 +185,29 @@ describe("dispatchSubagentInvoke", () => {
     expect(callArgs[6]).toBe(controller.signal);
   });
 
+  it("forwards emit callback messages to workerPost", async () => {
+    mockInvokeWithTransformersJs.mockImplementationOnce(
+      async (
+        _db: unknown,
+        _groupId: string,
+        _sys: string,
+        _msgs: unknown[],
+        _tokens: number,
+        emit: (msg: { type: string; content: string }) => Promise<void>,
+      ) => {
+        await emit({ type: "stream", content: "chunk" });
+      },
+    );
+
+    const payload = makePayload({ provider: "transformers_js_browser" });
+    await dispatchSubagentInvoke(mockDb, payload);
+
+    expect(mockWorkerPost).toHaveBeenCalledWith({
+      type: "stream",
+      content: "chunk",
+    });
+  });
+
   // ── prompt_api path ───────────────────────────────────────────────────────
 
   it("routes prompt_api to invokeWithPromptApi when supported", async () => {