shadow-claw 1.23.4 → 1.24.0

package/src/server/services/transformers-runtime.test.ts

@@ -17,25 +17,35 @@ describe("TransformersRuntimeService", () => {
     jest.resetModules();
     jest.useFakeTimers();
 
-    mkdirMock = jest.fn();
+    mkdirMock = jest.fn().mockResolvedValue(undefined as never);
     readFileMock = jest.fn();
-    writeFileMock = jest.fn();
+    writeFileMock = jest.fn().mockResolvedValue(undefined as never);
     statMock = jest.fn();
-    unlinkMock = jest.fn();
-    readdirMock = jest.fn();
+    unlinkMock = jest.fn().mockResolvedValue(undefined as never);
+    readdirMock = jest
+      .fn()
+      .mockResolvedValue(["model1.onnx", "model2.onnx"] as never);
 
-    processorMock = Object.assign(jest.fn(), {
-      apply_chat_template: jest.fn(() => "prompt"),
-      tokenizer: {},
-      dispose: jest.fn(),
-    });
+    processorMock = Object.assign(
+      jest.fn().mockImplementation(() => ({
+        input_ids: { dims: [1, 5] },
+      })),
+      {
+        apply_chat_template: jest.fn(() => "prompt"),
+        tokenizer: {
+          apply_chat_template: jest.fn(() => "prompt"),
+        },
+        batch_decode: jest.fn(() => ["Generated response"]),
+        dispose: jest.fn(),
+      },
+    );
 
     modelMock = {
       generate: jest.fn(async ({ streamer }: any) => {
         streamer?.callback_function?.("Hello");
 
         return {
-          input_ids: { dims: [1, 5] },
+          slice: jest.fn(() => [1, 2, 3]),
         };
       }),
       dispose: jest.fn(),
@@ -52,10 +62,16 @@ describe("TransformersRuntimeService", () => {
       Gemma4ForConditionalGeneration: {
         from_pretrained: jest.fn(async () => modelMock),
       },
+      AutoModelForCausalLM: {
+        from_pretrained: jest.fn(async () => modelMock),
+      },
+      AutoModelForImageTextToText: {
+        from_pretrained: jest.fn(async () => modelMock),
+      },
       TextStreamer: class {
         callback_function: any;
         constructor(_tokenizer: any, opts: any) {
-          this.callback_function = opts.callback_function;
+          this.callback_function = opts?.callback_function;
         }
       },
     };
@@ -86,7 +102,7 @@ describe("TransformersRuntimeService", () => {
   }
 
   describe("runChatCompletion", () => {
-    it("loads model and generates text", async () => {
+    it("loads Gemma 4 model and generates text", async () => {
       const service = await getService();
       const onToken = jest.fn();
 
@@ -98,7 +114,6 @@ describe("TransformersRuntimeService", () => {
         onToken,
       });
 
-      // Advance timers to handle internal awaitOperation timeout poll
       await jest.advanceTimersByTimeAsync(0);
 
       const result = await promise;
@@ -109,10 +124,44 @@ describe("TransformersRuntimeService", () => {
       ).toHaveBeenCalled();
     });
 
+    it("loads standard non-Gemma model (Qwen 3)", async () => {
+      const service = await getService();
+      const onToken = jest.fn();
+
+      const promise = service.runChatCompletion({
+        modelId: "onnx-community/Qwen3-0.6B-ONNX",
+        messages: [{ role: "user", content: "hi" }],
+        maxCompletionTokens: 10,
+        verbose: false,
+        onToken,
+      });
+
+      await jest.advanceTimersByTimeAsync(0);
+
+      const result = await promise;
+      expect(result.text).toBe("Hello");
+      expect(
+        transformersMock.AutoModelForImageTextToText.from_pretrained,
+      ).toHaveBeenCalled();
+    });
+
+    it("throws error for unsupported model ID", async () => {
+      const service = await getService();
+
+      await expect(
+        service.runChatCompletion({
+          modelId: "unsupported/model",
+          messages: [{ role: "user", content: "hi" }],
+          maxCompletionTokens: 10,
+          verbose: false,
+        }),
+      ).rejects.toThrow(/not supported by Transformers.js/);
+    });
+
     it("times out if model loading takes too long", async () => {
       process.env.TRANSFORMERS_JS_REQUEST_TIMEOUT_MS = "100";
       transformersMock.Gemma4ForConditionalGeneration.from_pretrained.mockImplementation(
-        () => new Promise(() => {}), // Never resolve
+        () => new Promise(() => {}),
       );
 
       const service = await getService();
@@ -130,14 +179,122 @@ describe("TransformersRuntimeService", () => {
       await wrappedPromise;
       delete process.env.TRANSFORMERS_JS_REQUEST_TIMEOUT_MS;
     });
+
+    it("handles batch_decode fallback when streamer produces empty string", async () => {
+      modelMock.generate.mockImplementationOnce(async () => ({
+        slice: jest.fn(() => [1, 2, 3]),
+      }));
+
+      const service = await getService();
+      const promise = service.runChatCompletion({
+        modelId: "onnx-community/gemma-4-E2B-it-ONNX",
+        messages: [{ role: "user", content: "hi" }],
+        maxCompletionTokens: 10,
+        verbose: false,
+      });
+
+      await jest.advanceTimersByTimeAsync(0);
+
+      const result = await promise;
+      expect(result.text).toBe("Generated response");
+    });
+  });
+
+  describe("fetchDynamicModels", () => {
+    it("returns models from cached models.json if present", async () => {
+      readFileMock.mockResolvedValueOnce(
+        JSON.stringify({
+          models: [
+            {
+              id: "onnx-community/custom-model",
+              name: "Custom (ONNX)",
+              context_length: 32000,
+              max_completion_tokens: 8192,
+              supports_tools: true,
+            },
+          ],
+        }),
+      );
+
+      const service = await getService();
+      const models = await service.fetchDynamicModels();
+      expect(models.length).toBe(1);
+      expect(models[0].id).toBe("onnx-community/custom-model");
+    });
+
+    it("fetches from discovery URL when cache file is missing", async () => {
+      readFileMock
+        .mockRejectedValueOnce(new Error("ENOENT")) // cache file missing
+        .mockResolvedValueOnce(
+          JSON.stringify([
+            { id: "onnx-community/gemma-4-26B-it-ONNX" },
+            { id: "onnx-community/gemma-4-E4B-it-ONNX" },
+          ]),
+        ); // discovery part file content
+
+      statMock.mockRejectedValue(new Error("ENOENT"));
+
+      (globalThis as any).fetch = (jest.fn() as any).mockResolvedValue({
+        ok: true,
+        status: 200,
+        body: {
+          getReader: () => ({
+            read: (jest.fn() as any)
+              .mockResolvedValueOnce({
+                done: false,
+                value: new Uint8Array([123]),
+              })
+              .mockResolvedValueOnce({ done: true, value: undefined }),
+            releaseLock: jest.fn(),
+          }),
+        },
+      });
+
+      const service = await getService();
+      const models = await service.fetchDynamicModels();
+      expect(models.length).toBeGreaterThan(0);
+      expect(models.some((m) => m.id.includes("gemma-4"))).toBe(true);
+    });
   });
 
-  describe("disposeRuntime", () => {
+  describe("getDownloadStatus & getDiskCacheStatus & prewarmModel", () => {
+    it("returns download status and allows testing status injection", async () => {
+      const service = await getService();
+      expect(service.getDownloadStatus().status).toBe("idle");
+
+      service.__setDownloadStatusForTests({ status: "running", progress: 0.5 });
+      expect(service.getDownloadStatus().status).toBe("running");
+      expect(service.getDownloadStatus().progress).toBe(0.5);
+    });
+
+    it("returns disk cache status", async () => {
+      statMock.mockResolvedValue({ isFile: () => true });
+      readdirMock.mockResolvedValue(["entry1", "entry2"]);
+
+      const service = await getService();
+      const status = await service.getDiskCacheStatus();
+      expect(status.modelsCatalogExists).toBe(true);
+      expect(status.runtimeCacheDirExists).toBe(true);
+      expect(status.runtimeCacheEntryCount).toBe(2);
+    });
+
+    it("prewarms model and returns metadata", async () => {
+      const service = await getService();
+      const info = await service.prewarmModel({
+        modelId: "onnx-community/gemma-4-E2B-it-ONNX",
+        verbose: false,
+      });
+
+      expect(info.modelId).toBe("onnx-community/gemma-4-E2B-it-ONNX");
+      expect(info.loader).toBeTruthy();
+    });
+  });
+
+  describe("disposeRuntime and reset", () => {
     it("disposes model and processor", async () => {
       const service = await getService();
       const modelId = "onnx-community/gemma-4-E2B-it-ONNX";
 
-      // Load it first
       await service.runChatCompletion({
         modelId,
         messages: [{ role: "user", content: "hi" }],
@@ -150,6 +307,19 @@ describe("TransformersRuntimeService", () => {
       expect(modelMock.dispose).toHaveBeenCalled();
       expect(processorMock.dispose).toHaveBeenCalled();
     });
+
+    it("resets runtime for tests", async () => {
+      const service = await getService();
+      service.__setRuntimeForTests("onnx-community/gemma-4-E2B-it-ONNX", {
+        model: modelMock,
+        processor: processorMock,
+        TextStreamer: class {},
+        modelLoaderName: "test",
+      });
+
+      await service.__resetRuntimeForTests();
+      expect(modelMock.dispose).toHaveBeenCalled();
+    });
   });
 
   describe("idle cleanup", () => {
@@ -164,10 +334,8 @@ describe("TransformersRuntimeService", () => {
         verbose: false,
       });
 
-      // Should still be alive
       expect(modelMock.dispose).not.toHaveBeenCalled();
 
-      // Wait for idle timeout (10s)
       await jest.advanceTimersByTimeAsync(11000);
 
       expect(modelMock.dispose).toHaveBeenCalled();

package/src/server/webrtc.test.ts

@@ -0,0 +1,21 @@
+import {
+  ensureServerWebRtc,
+  isWebRtcAvailable,
+  getPeerClass,
+} from "./webrtc.js";
+
+describe("server webrtc", () => {
+  it("polyfs WebRTC APIs on globalThis in Node environment", async () => {
+    const available = await ensureServerWebRtc();
+    expect(available).toBe(true);
+    expect(isWebRtcAvailable()).toBe(true);
+    expect((globalThis as any).RTCPeerConnection).toBeDefined();
+    expect((globalThis as any).RTCSessionDescription).toBeDefined();
+    expect((globalThis as any).RTCIceCandidate).toBeDefined();
+  });
+
+  it("loads PeerJS constructor configured for Node", async () => {
+    const PeerClass = await getPeerClass();
+    expect(typeof PeerClass).toBe("function");
+  });
+});

package/src/server/webrtc.ts

@@ -0,0 +1,72 @@
+/**
+ * ShadowClaw — Server-Side WebRTC Initialization & PeerJS Loader
+ *
+ * Polyfills WebRTC (RTCPeerConnection, RTCSessionDescription, RTCIceCandidate)
+ * in Node.js environments using node-datachannel, allowing Node servers and CLI
+ * tools to establish direct WebRTC RTCDataChannel connections.
+ */
+
+let isAvailable: boolean | null = null;
+
+/**
+ * Ensure WebRTC APIs are present in globalThis for Node.js environments.
+ * Returns true if WebRTC is available (either natively or via polyfill).
+ */
+export async function ensureServerWebRtc(): Promise<boolean> {
+  if (
+    typeof globalThis !== "undefined" &&
+    typeof (globalThis as any).RTCPeerConnection !== "undefined"
+  ) {
+    isAvailable = true;
+    return true;
+  }
+
+  if (isAvailable !== null) {
+    return isAvailable;
+  }
+
+  try {
+    const wrtc = await import("node-datachannel/polyfill");
+    if (wrtc && wrtc.RTCPeerConnection) {
+      Object.assign(globalThis, {
+        RTCPeerConnection: wrtc.RTCPeerConnection,
+        RTCSessionDescription: wrtc.RTCSessionDescription,
+        RTCIceCandidate: wrtc.RTCIceCandidate,
+      });
+      isAvailable = true;
+      return true;
+    }
+  } catch (err) {
+    console.warn(
+      "[webrtc] Failed to load node-datachannel WebRTC polyfill:",
+      err instanceof Error ? err.message : String(err),
+    );
+  }
+
+  isAvailable = false;
+  return false;
+}
+
+/**
+ * Check whether WebRTC is available in the current environment.
+ */
+export function isWebRtcAvailable(): boolean {
+  if (
+    typeof globalThis !== "undefined" &&
+    typeof (globalThis as any).RTCPeerConnection !== "undefined"
+  ) {
+    return true;
+  }
+  return isAvailable === true;
+}
+
+/**
+ * Dynamically loads and returns the PeerJS Peer constructor configured for Node.
+ */
+export async function getPeerClass(): Promise<any> {
+  await ensureServerWebRtc();
+  const mod = await import("peerjs");
+  return (
+    (mod as any).default?.Peer || (mod as any).default || (mod as any).Peer
+  );
+}

package/src/service-worker/fetch-proxy.test.ts

@@ -2,8 +2,9 @@
 
 import { beforeEach, describe, expect, it, jest } from "@jest/globals";
 
-describe("service-worker fetch proxy workspace routes", () => {
+describe("service-worker fetch proxy", () => {
   let fetchListener: ((event: any) => void) | null = null;
+  let messageListener: ((event: any) => void) | null = null;
   let networkFetch: jest.Mock;
 
   const imageBytes = new Uint8Array([255, 216, 255, 217]);
@@ -82,6 +83,7 @@ describe("service-worker fetch proxy workspace routes", () => {
   beforeEach(async () => {
     jest.resetModules();
     fetchListener = null;
+    messageListener = null;
 
     Object.defineProperty(globalThis, "Response", {
       configurable: true,
@@ -168,6 +170,8 @@ describe("service-worker fetch proxy workspace routes", () => {
           (type: string, handler: (event: any) => void) => {
             if (type === "fetch") {
               fetchListener = handler;
+            } else if (type === "message") {
+              messageListener = handler;
             }
           },
         ),
@@ -292,4 +296,63 @@ describe("service-worker fetch proxy workspace routes", () => {
     expect(response).toBeNull();
     expect(networkFetch).not.toHaveBeenCalled();
   });
+
+  it("handles proxy configuration messages and proxies cross-origin requests", async () => {
+    expect(messageListener).toBeTruthy();
+
+    // Enable proxy via message
+    messageListener!({
+      data: {
+        type: "set-proxy-config",
+        payload: {
+          useProxy: true,
+          proxyUrl: "/proxy",
+        },
+      },
+    } as any);
+
+    const crossOriginPostRequest = {
+      url: "https://api.external.com/v1/resource",
+      method: "POST",
+      mode: "cors",
+      destination: "fetch",
+      headers: new TestHeaders({ Authorization: "Bearer token" }),
+      clone: () => ({
+        text: async () => JSON.stringify({ key: "val" }),
+      }),
+    };
+
+    const response = await dispatchFetch(crossOriginPostRequest);
+    expect(response.status).toBe(200);
+    expect(networkFetch).toHaveBeenCalledWith(
+      `${globalThis.location.origin}/proxy/https://api.external.com/v1/resource`,
+      expect.objectContaining({
+        method: "POST",
+        headers: { "Content-Type": "application/json" },
+      }),
+    );
+  });
+
+  it("handles legacy set-use-proxy message and direct fetch when proxy disabled", async () => {
+    messageListener!({
+      data: {
+        type: "set-use-proxy",
+        payload: {
+          useProxy: false,
+        },
+      },
+    } as any);
+
+    const crossOriginGetRequest = {
+      url: "https://api.external.com/v1/data",
+      method: "GET",
+      mode: "cors",
+      destination: "fetch",
+      headers: new TestHeaders(),
+    };
+
+    const response = await dispatchFetch(crossOriginGetRequest);
+    expect(response.status).toBe(200);
+    expect(networkFetch).toHaveBeenCalledWith(crossOriginGetRequest);
+  });
 });

package/src/service-worker/push-handler.ts

@@ -12,6 +12,9 @@ interface PushData {
   type?: string;
   taskId?: string;
   groupId?: string;
+  clientId?: string;
+  action?: string;
+  args?: Record<string, unknown>;
   prompt?: string;
   taskType?: string;
   tools?: unknown[];
@@ -29,6 +32,42 @@ self.addEventListener("push", (event: PushEvent) => {
     }
   }
 
+  // Remote command trigger — relay to client windows and notify
+  if (data.type === "remote-command") {
+    event.waitUntil(
+      self.clients
+        .matchAll({ type: "window", includeUncontrolled: true })
+        .then((clientList) => {
+          for (const client of clientList) {
+            client.postMessage({
+              type: "remote-command-trigger",
+              clientId: data.clientId,
+              action: data.action,
+              args: data.args,
+              prompt: data.prompt,
+            });
+          }
+
+          return self.registration.showNotification(
+            "ShadowClaw — Remote Command",
+            {
+              body: data.prompt || `Remote command received: ${data.action}`,
+              icon: "/assets/icons/512.png",
+              badge: "/assets/icons/192.png",
+              data: {
+                type: "remote-command",
+                clientId: data.clientId,
+                action: data.action,
+                args: data.args,
+              },
+            },
+          );
+        }),
+    );
+
+    return;
+  }
+
   // Scheduled task trigger — relay to any open client windows, then show notification
   if (data.type === "scheduled-task") {
     event.waitUntil(