shadow-claw 1.40.0 → 1.41.0

package/src/subsystems/mcp/webmcp.ts

@@ -343,6 +343,259 @@ export function isWebMcpSupported(): boolean {
   return !!getModelContextApi();
 }
 
+/**
+ * Event fired when a tool execution begins (PR #245 / Chrome 156+).
+ * Dispatched on `document.modelContext` in Chrome 156+, or `window` in Chrome < 156.
+ */
+export interface WebMcpToolActivatedEvent extends Event {
+  readonly toolName: string;
+}
+
+/**
+ * Event fired when a tool execution is cancelled (PR #245 / Chrome 156+).
+ * Dispatched on `document.modelContext` in Chrome 156+, or `window` in Chrome < 156.
+ */
+export interface WebMcpToolCancelEvent extends Event {
+  readonly toolName: string;
+}
+
+export type WebMcpEventTarget = EventTarget & {
+  addEventListener: (type: string, listener: any, options?: any) => void;
+  removeEventListener: (type: string, listener: any, options?: any) => void;
+};
+
+export interface WebMcpEventListenerOptions extends AddEventListenerOptions {
+  /**
+   * If true, also attaches a fallback listener to window when modelContext is selected
+   * (or vice versa), deduplicating events by toolName within the same tick if both fire.
+   */
+  listenBoth?: boolean;
+}
+
+/**
+ * Resolves the appropriate EventTarget for WebMCP lifecycle events
+ * (`toolactivated` and `toolcancel`) with backwards compatibility.
+ *
+ * Starting in Chrome 156.0.8076.0 (PR #245), `ontoolactivated` and `ontoolcancel`
+ * event handler properties and lifecycle events moved from `window` to `document.modelContext`.
+ * In Chrome < 156, these events were fired on `window`.
+ *
+ * This function practices robust feature detection and graceful degradation:
+ * 1. Safely checks for existence of `document` and `window` to avoid ReferenceErrors
+ *    in non-DOM / headless / Node.js environments.
+ * 2. Checks if `on${type}` is present in `document.modelContext` (or `navigator.modelContext`).
+ *    If present and it supports `addEventListener`, `modelContext` is returned.
+ * 3. Checks if `on${type}` is present in `window`. If present and `window` supports
+ *    `addEventListener`, `window` is returned (legacy Chrome < 156 path).
+ * 4. Fallback: If neither has `on${type}` (e.g. polyfill, synthetic mock, or uninitialized prototype),
+ *    prefers `modelContext` if it supports `addEventListener`, otherwise falls back to `window`.
+ * 5. Returns `null` if no valid EventTarget is found.
+ */
+export function getWebMcpEventTarget(
+  type?: "toolactivated" | "toolcancel" | string,
+): WebMcpEventTarget | null {
+  const doc = typeof document !== "undefined" ? document : undefined;
+  const win = typeof window !== "undefined" ? window : undefined;
+  const nav = typeof navigator !== "undefined" ? navigator : undefined;
+
+  const modelContext: any =
+    (doc as any)?.modelContext ?? (nav as any)?.modelContext;
+
+  const hasModelContextListener =
+    modelContext && typeof modelContext.addEventListener === "function";
+  const hasWindowListener =
+    win && typeof (win as any).addEventListener === "function";
+
+  if (type) {
+    const handlerKey = `on${type}`;
+
+    // 1. Chrome 156+ path (PR #245): ontoolactivated / ontoolcancel on document.modelContext
+    if (modelContext && handlerKey in modelContext && hasModelContextListener) {
+      return modelContext as WebMcpEventTarget;
+    }
+
+    // 2. Chrome < 156 legacy path: ontoolactivated / ontoolcancel on window
+    if (win && handlerKey in win && hasWindowListener) {
+      return win as WebMcpEventTarget;
+    }
+  }
+
+  // 3. Fallback when neither target explicitly reflects on${type}
+  if (hasModelContextListener) {
+    return modelContext as WebMcpEventTarget;
+  }
+
+  if (hasWindowListener) {
+    return win as WebMcpEventTarget;
+  }
+
+  return null;
+}
+
+/**
+ * Safely registers a listener for WebMCP lifecycle events (`toolactivated`, `toolcancel`)
+ * with graceful degradation, event payload normalization, and automatic unsubscription.
+ *
+ * Returns an idempotent unsubscribe cleanup function.
+ */
+export function addWebMcpEventListener<
+  T extends "toolactivated" | "toolcancel" | string =
+    | "toolactivated"
+    | "toolcancel",
+>(
+  type: T,
+  listener: (
+    event: T extends "toolactivated"
+      ? WebMcpToolActivatedEvent
+      : T extends "toolcancel"
+        ? WebMcpToolCancelEvent
+        : Event & { toolName?: string },
+  ) => void,
+  options?: boolean | WebMcpEventListenerOptions,
+): () => void {
+  const target = getWebMcpEventTarget(type);
+  const opts = typeof options === "object" ? options : undefined;
+  const listenBoth = opts?.listenBoth ?? false;
+
+  const win =
+    typeof window !== "undefined" &&
+    typeof (window as any).addEventListener === "function"
+      ? (window as unknown as WebMcpEventTarget)
+      : null;
+  const doc = typeof document !== "undefined" ? document : null;
+  const nav = typeof navigator !== "undefined" ? navigator : null;
+  const modelContext: any =
+    (doc as any)?.modelContext ?? (nav as any)?.modelContext;
+  const hasMc =
+    modelContext && typeof modelContext.addEventListener === "function";
+
+  const secondaryTarget: WebMcpEventTarget | null = listenBoth
+    ? target === modelContext
+      ? win !== target
+        ? win
+        : null
+      : hasMc
+        ? (modelContext as WebMcpEventTarget)
+        : null
+    : null;
+
+  if (!target && !secondaryTarget) {
+    return () => {};
+  }
+
+  let recentToolNames: Set<string> | null = null;
+  let clearTimer: ReturnType<typeof setTimeout> | null = null;
+
+  const wrapHandler = (evt: Event) => {
+    let toolName = (evt as any).toolName;
+    if (
+      typeof toolName !== "string" &&
+      "detail" in evt &&
+      typeof (evt as any).detail === "object"
+    ) {
+      toolName = (evt as any).detail?.toolName;
+    }
+    if (typeof toolName !== "string") {
+      toolName = "";
+    }
+
+    if (!("toolName" in evt) || (evt as any).toolName !== toolName) {
+      try {
+        Object.defineProperty(evt, "toolName", {
+          value: toolName,
+          configurable: true,
+          enumerable: true,
+        });
+      } catch {
+        // Ignore errors if event is sealed
+      }
+    }
+
+    if (listenBoth && toolName) {
+      if (!recentToolNames) {
+        recentToolNames = new Set();
+      }
+      if (recentToolNames.has(toolName)) {
+        return;
+      }
+      recentToolNames.add(toolName);
+      if (!clearTimer) {
+        clearTimer = setTimeout(() => {
+          recentToolNames?.clear();
+          clearTimer = null;
+        }, 100);
+      }
+    }
+
+    listener(evt as any);
+  };
+
+  if (target) {
+    target.addEventListener(type, wrapHandler as EventListener, options);
+  }
+  if (secondaryTarget) {
+    secondaryTarget.addEventListener(
+      type,
+      wrapHandler as EventListener,
+      options,
+    );
+  }
+
+  let unsubscribed = false;
+  const unsubscribe = () => {
+    if (unsubscribed) {
+      return;
+    }
+    unsubscribed = true;
+    if (clearTimer) {
+      clearTimeout(clearTimer);
+      clearTimer = null;
+    }
+    if (target) {
+      target.removeEventListener(type, wrapHandler as EventListener, options);
+    }
+    if (secondaryTarget) {
+      secondaryTarget.removeEventListener(
+        type,
+        wrapHandler as EventListener,
+        options,
+      );
+    }
+  };
+
+  if (opts?.signal) {
+    if (opts.signal.aborted) {
+      unsubscribe();
+      return () => {};
+    }
+    opts.signal.addEventListener("abort", () => unsubscribe(), { once: true });
+  }
+
+  return unsubscribe;
+}
+
+/**
+ * Convenience helper to subscribe to tool execution start events (`toolactivated`).
+ * Returns an unsubscribe cleanup function.
+ */
+export function onWebMcpToolActivated(
+  listener: (event: WebMcpToolActivatedEvent) => void,
+  options?: boolean | WebMcpEventListenerOptions,
+): () => void {
+  return addWebMcpEventListener("toolactivated", listener, options);
+}
+
+/**
+ * Convenience helper to subscribe to tool execution cancel events (`toolcancel`).
+ * Returns an unsubscribe cleanup function.
+ */
+export function onWebMcpToolCancel(
+  listener: (event: WebMcpToolCancelEvent) => void,
+  options?: boolean | WebMcpEventListenerOptions,
+): () => void {
+  return addWebMcpEventListener("toolcancel", listener, options);
+}
+
 /**
  * Consequential tools that perform high-stakes, irreversible, or external real-world actions
  * (such as deleting data, executing arbitrary system commands, or transmitting live communications).

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");
+  });
 });