shadow-claw 1.40.0 → 1.40.1

package/src/stores/theme.test.ts

@@ -11,8 +11,8 @@ describe("themeStore", () => {
     localStorage.clear();
     document.documentElement.className = "";
 
-    // Mock dispatchEvent
-    (window as any).dispatchEvent = jest.fn();
+    // Spy on dispatchEvent so event listeners still fire
+    jest.spyOn(window, "dispatchEvent");
   });
 
   it("applies and persists explicit theme", async () => {
@@ -135,4 +135,43 @@ describe("themeStore", () => {
     expect(themeStore.resolved).toBe("light");
     expect(localStorage.getItem("shadow-claw-theme")).toBe("system");
   });
+
+  it("handles storage event for tab synchronization", async () => {
+    const { getNamespacedStorageKey } =
+      await import("../utils/namespacedStorage.js");
+    const { themeStore } = await import("./theme.js");
+    const targetKey = getNamespacedStorageKey("shadow-claw-theme");
+
+    // Other key should be ignored
+    const otherEv = new Event("storage") as any;
+    otherEv.key = "other-key";
+    otherEv.newValue = "dark";
+    window.dispatchEvent(otherEv);
+    expect(themeStore.theme).not.toBe("dark");
+
+    // Target key with null newValue should be ignored
+    const nullEv = new Event("storage") as any;
+    nullEv.key = targetKey;
+    nullEv.newValue = null;
+    window.dispatchEvent(nullEv);
+
+    // Target key with valid newValue updates theme
+    const validEv = new Event("storage") as any;
+    validEv.key = targetKey;
+    validEv.newValue = "dark";
+    window.dispatchEvent(validEv);
+
+    expect(themeStore.theme).toBe("dark");
+    expect(themeStore.resolved).toBe("dark");
+  });
+
+  it("falls back gracefully when matchMedia is not a function", async () => {
+    (window as any).matchMedia = undefined;
+    jest.resetModules();
+    localStorage.clear();
+    const { themeStore } = await import("./theme.js");
+
+    themeStore.setTheme("system");
+    expect(themeStore.resolved).toBe("light");
+  });
 });

package/src/stores/toast.test.ts

@@ -101,6 +101,31 @@ describe("ToastStore", () => {
 
     // No-op for non-existent or action-less toast
     await store.runAction(999);
+
+    const noActionId = store.show("without action");
+    await store.runAction(noActionId);
+  });
+
+  test("pause and resume handle missing or invalid timers gracefully", () => {
+    const store = new ToastStore();
+
+    // Calling pause on nonexistent toast or already paused toast
+    expect(() => store.pause(999)).not.toThrow();
+
+    const id = store.show("toast", { duration: 1000 });
+    store.pause(id);
+    // Pause again when timeoutId is undefined
+    expect(() => store.pause(id)).not.toThrow();
+
+    // Calling resume on nonexistent toast, or already running toast, or expired toast
+    expect(() => store.resume(999)).not.toThrow();
+
+    const runningId = store.show("running", { duration: 1000 });
+    // Resume when timer.timeoutId is still active
+    expect(() => store.resume(runningId)).not.toThrow();
+
+    // Clear timer on nonexistent toast
+    expect(() => store.clearTimer(999)).not.toThrow();
   });
 
   test("resolvers handle invalid inputs gracefully", () => {

package/src/worker/tools/bash/native-bash-executor.test.ts

@@ -1,7 +1,11 @@
-import { describe, it, expect } from "@jest/globals";
+import { describe, it, expect, afterEach } from "@jest/globals";
 import { nativeBashExecutor } from "./native-bash-executor.js";
 
 describe("nativeBashExecutor", () => {
+  afterEach(() => {
+    delete (globalThis as Record<string, unknown>).__getStorageRootPath;
+  });
+
   it("executes a shell command and captures stdout", async () => {
     const output = await nativeBashExecutor({
       command: "echo 'hello from native bash'",
@@ -26,4 +30,30 @@ describe("nativeBashExecutor", () => {
     });
     expect(output).toContain("test stderr output");
   });
+
+  it("captures both stdout and stderr formatted with newline", async () => {
+    const output = await nativeBashExecutor({
+      command: 'node -e \'process.stdout.write("out"); console.error("err");\'',
+      timeoutSec: 5,
+    });
+    expect(output).toContain("out\nerr");
+  });
+
+  it("falls back to error message when command fails with empty output", async () => {
+    const output = await nativeBashExecutor({
+      command: "node -e 'process.exit(42)'",
+      timeoutSec: 5,
+    });
+    expect(output).toContain("Command failed");
+  });
+
+  it("uses __getStorageRootPath when provided on globalThis", async () => {
+    (globalThis as Record<string, unknown>).__getStorageRootPath = () =>
+      process.cwd();
+    const output = await nativeBashExecutor({
+      command: "pwd",
+      timeoutSec: 5,
+    });
+    expect(output.trim()).toBe(process.cwd());
+  });
 });

package/src/worker/tools/git/utils/extractConflictPaths.test.ts

@@ -0,0 +1,24 @@
+import { describe, expect, it } from "@jest/globals";
+import { extractConflictPaths } from "./extractConflictPaths.js";
+
+describe("extractConflictPaths", () => {
+  it("extracts multiple file paths from conflict message", () => {
+    const message =
+      "Automatic merge failed; conflicts in the following files: fileA.ts, fileB.ts, fileC.ts";
+    expect(extractConflictPaths(message)).toEqual([
+      "fileA.ts",
+      "fileB.ts",
+      "fileC.ts",
+    ]);
+  });
+
+  it("extracts single file path from singular conflict message", () => {
+    const message = "conflict in the following file: readme.md";
+    expect(extractConflictPaths(message)).toEqual(["readme.md"]);
+  });
+
+  it("returns empty array when message does not match conflict format", () => {
+    const message = "Merge successful with fast-forward";
+    expect(extractConflictPaths(message)).toEqual([]);
+  });
+});

package/src/worker/tools/git/utils/parseConflictRegions.test.ts

@@ -0,0 +1,46 @@
+import { describe, expect, it } from "@jest/globals";
+import { parseConflictRegions } from "./parseConflictRegions.js";
+
+describe("parseConflictRegions", () => {
+  it("parses single standard conflict region", () => {
+    const content = [
+      "before",
+      "<<<<<<< HEAD",
+      "our content line 1",
+      "our content line 2",
+      "=======",
+      "their content",
+      ">>>>>>> branch-feat",
+      "after",
+    ].join("\n");
+
+    const regions = parseConflictRegions(content);
+    expect(regions).toHaveLength(1);
+    expect(regions[0]).toEqual({
+      ours: "our content line 1\nour content line 2",
+      oursLabel: "HEAD",
+      startLine: 2,
+      theirs: "their content",
+      theirsLabel: "branch-feat",
+    });
+  });
+
+  it("handles unclosed conflict regions that reach end-of-file without closing marker", () => {
+    const content = [
+      "<<<<<<< HEAD",
+      "our changes",
+      "=======",
+      "their unclosed changes",
+    ].join("\n");
+
+    const regions = parseConflictRegions(content);
+    expect(regions).toHaveLength(1);
+    expect(regions[0].theirsLabel).toBe("");
+    expect(regions[0].theirs).toBe("their unclosed changes");
+  });
+
+  it("returns empty array when no conflict markers are present", () => {
+    const content = "regular file content\nwithout conflicts";
+    expect(parseConflictRegions(content)).toEqual([]);
+  });
+});

package/src/worker/tools/git/utils/resolveCorsProxy.test.ts

@@ -1,27 +1,29 @@
 import { describe, it, expect, beforeEach } from "@jest/globals";
 import { resolveCorsProxy } from "./resolveCorsProxy.js";
 import { setHeadlessMode } from "../../../../config/headless.js";
+import type { ShadowClawDatabase } from "../../../../db/types.js";
+import type { GitToolDeps } from "../../../../subsystems/git/types.js";
 
 describe("resolveCorsProxy", () => {
-  let mockDb: any;
-  let mockDeps: any;
+  const mockDb = {} as ShadowClawDatabase;
+  let mockDeps: GitToolDeps;
   let configStore: Record<string, string>;
 
   beforeEach(() => {
     configStore = {};
-    mockDb = {};
     mockDeps = {
       configKeys: {
         GIT_CORS_PROXY: "git_cors_proxy",
         GIT_PROXY_URL: "git_proxy_url",
       },
-      getConfig: async (_db: any, key: string) => configStore[key],
+      getConfig: async (_db: ShadowClawDatabase, key: string) =>
+        configStore[key],
       getProxyUrl: (pref: string, custom?: string) => {
         if (pref === "custom") return custom || "https://custom.proxy";
         if (pref === "public") return "https://public.proxy";
         return "http://127.0.0.1:8888/git-proxy";
       },
-    };
+    } as unknown as GitToolDeps;
   });
 
   it("returns local proxy URL in browser mode by default", async () => {
@@ -44,10 +46,29 @@ describe("resolveCorsProxy", () => {
     expect(result).toBe("https://my-proxy.internal");
   });
 
+  it("falls back when custom proxy is selected but no custom URL is provided", async () => {
+    setHeadlessMode(false);
+    configStore["git_cors_proxy"] = "custom";
+    configStore["git_proxy_url"] = "";
+    const result = await resolveCorsProxy(mockDb, mockDeps);
+    expect(result).toBe("http://127.0.0.1:8888/git-proxy");
+  });
+
   it("returns public proxy URL when configured in browser mode", async () => {
     setHeadlessMode(false);
     configStore["git_cors_proxy"] = "public";
     const result = await resolveCorsProxy(mockDb, mockDeps);
     expect(result).toBe("https://public.proxy");
   });
+
+  it("returns undefined when pref is direct or none", async () => {
+    setHeadlessMode(false);
+    configStore["git_cors_proxy"] = "direct";
+    const directResult = await resolveCorsProxy(mockDb, mockDeps);
+    expect(directResult).toBeUndefined();
+
+    configStore["git_cors_proxy"] = "none";
+    const noneResult = await resolveCorsProxy(mockDb, mockDeps);
+    expect(noneResult).toBeUndefined();
+  });
 });

package/src/worker/tools/git/utils/truncateSnippet.test.ts

@@ -0,0 +1,16 @@
+import { describe, expect, it } from "@jest/globals";
+import { truncateSnippet } from "./truncateSnippet.js";
+
+describe("truncateSnippet", () => {
+  it("returns unchanged text when line count is less than or equal to maxLines", () => {
+    const text = "line 1\nline 2\nline 3";
+    expect(truncateSnippet(text, 5)).toBe(text);
+    expect(truncateSnippet(text, 3)).toBe(text);
+  });
+
+  it("truncates text and appends remaining line count when line count exceeds maxLines", () => {
+    const text = "line 1\nline 2\nline 3\nline 4\nline 5";
+    const result = truncateSnippet(text, 2);
+    expect(result).toBe("line 1\nline 2\n    [... 3 more lines]");
+  });
+});

package/src/worker/tools/node-transformers-executor.test.ts

@@ -1,21 +1,41 @@
 /** @jest-environment node */
 import { describe, it, expect, jest, beforeEach } from "@jest/globals";
-import {
-  executeNodeTransformersCompletion,
-  setTransformersServiceForTests,
-} from "./node-transformers-executor.js";
+import type { TransformersRuntimeService } from "../../server/services/transformers-runtime.js";
+
+const mockCreateServiceInstance: TransformersRuntimeService = {
+  runChatCompletion: jest.fn(async () => ({
+    text: "Created service default output",
+    promptTokens: 5,
+    completionTokens: 5,
+  })),
+} as unknown as TransformersRuntimeService;
+
+const mockCreateTransformersRuntimeService = jest.fn(
+  () => mockCreateServiceInstance,
+);
+
+jest.unstable_mockModule(
+  "../../server/services/transformers-runtime.js",
+  () => ({
+    createTransformersRuntimeService: mockCreateTransformersRuntimeService,
+  }),
+);
+
+const { executeNodeTransformersCompletion, setTransformersServiceForTests } =
+  await import("./node-transformers-executor.js");
 
 describe("executeNodeTransformersCompletion", () => {
-  let mockService: any;
+  let mockService: TransformersRuntimeService;
 
   beforeEach(() => {
+    jest.clearAllMocks();
     mockService = {
       runChatCompletion: jest.fn(async () => ({
         text: "Hello from local ONNX!",
         promptTokens: 12,
         completionTokens: 8,
       })),
-    };
+    } as unknown as TransformersRuntimeService;
     setTransformersServiceForTests(mockService);
   });
 
@@ -55,4 +75,83 @@ describe("executeNodeTransformersCompletion", () => {
       }),
     );
   });
+
+  it("handles tool calls returned by the model output", async () => {
+    mockService.runChatCompletion = jest.fn(async () => ({
+      text: 'call:read_file{"path":"test.txt"}',
+      promptTokens: 20,
+      completionTokens: 15,
+    })) as typeof mockService.runChatCompletion;
+
+    const tools = [
+      {
+        name: "read_file",
+        description: "Read a file",
+        parameters: {
+          type: "object",
+          properties: { path: { type: "string" } },
+        },
+      },
+    ];
+
+    const response = await executeNodeTransformersCompletion({
+      modelId: "onnx-community/gemma-4-E2B-it-ONNX",
+      messages: [{ role: "user", content: "Read test.txt" }],
+      tools,
+    });
+
+    expect(mockService.runChatCompletion).toHaveBeenCalledWith(
+      expect.objectContaining({
+        tools: expect.arrayContaining([
+          expect.objectContaining({
+            type: "function",
+            function: expect.objectContaining({ name: "read_file" }),
+          }),
+        ]),
+      }),
+    );
+
+    expect(response.choices[0].finish_reason).toBe("tool_calls");
+    expect(response.choices[0].message.content).toBeNull();
+    expect(response.choices[0].message.tool_calls).toHaveLength(1);
+    expect(response.choices[0].message.tool_calls[0].function.name).toBe(
+      "read_file",
+    );
+    expect(response.choices[0].message.tool_calls[0].function.arguments).toBe(
+      JSON.stringify({ path: "test.txt" }),
+    );
+  });
+
+  it("creates default service when defaultService is null", async () => {
+    setTransformersServiceForTests(null);
+
+    const response = await executeNodeTransformersCompletion({
+      modelId: "onnx-community/Qwen3-0.6B-ONNX",
+      messages: [{ role: "user", content: "Test default" }],
+    });
+
+    expect(mockCreateTransformersRuntimeService).toHaveBeenCalled();
+    expect(response.choices[0].message.content).toBe(
+      "Created service default output",
+    );
+  });
+
+  it("uses custom injected service when provided in options", async () => {
+    const customService: TransformersRuntimeService = {
+      runChatCompletion: jest.fn(async () => ({
+        text: "Custom service response",
+        promptTokens: 3,
+        completionTokens: 4,
+      })),
+    } as unknown as TransformersRuntimeService;
+
+    const response = await executeNodeTransformersCompletion({
+      modelId: "onnx-community/Qwen3-0.6B-ONNX",
+      messages: [{ role: "user", content: "Custom" }],
+      service: customService,
+    });
+
+    expect(customService.runChatCompletion).toHaveBeenCalled();
+    expect(response.choices[0].message.content).toBe("Custom service response");
+  });
 });