shadow-claw 1.54.0 → 1.55.0

package/src/stores/tools.ts

@@ -79,8 +79,8 @@ export class ToolsStore {
     this._enabledDeclarativeTools = new Signal.Computed(() => {
       const tools = this._declarativeTools.get();
       const enabledSet = this._declarativeToolNamesEnabled.get();
-      if (enabledSet === null) {
-        return tools;
+      if (!enabledSet || enabledSet.size === 0) {
+        return [];
       }
       return tools.filter((t) => enabledSet.has(t.name));
     });
@@ -137,8 +137,8 @@ export class ToolsStore {
 
   isDeclarativeToolEnabled(name: string): boolean {
     const enabledSet = this._declarativeToolNamesEnabled.get();
-    if (enabledSet === null) {
-      return true;
+    if (!enabledSet) {
+      return false;
     }
     return enabledSet.has(name);
   }
@@ -183,12 +183,7 @@ export class ToolsStore {
     enabled: boolean,
   ): Promise<void> {
     const currentEnabled = this._declarativeToolNamesEnabled.get();
-    const allDeclTools = this._declarativeTools.get();
-    const nextSet = new Set(
-      currentEnabled === null
-        ? allDeclTools.map((t) => t.name)
-        : currentEnabled,
-    );
+    const nextSet = new Set(currentEnabled === null ? [] : currentEnabled);
     if (enabled) {
       nextSet.add(toolName);
     } else {

package/src/subsystems/mcp/webmcp.test.ts

@@ -29,20 +29,24 @@ describe("webmcp integration", () => {
     mockRegisterTool = jest.fn(() => undefined);
     mockUnregisterTool = jest.fn(() => undefined);
 
-    // Mock the polyfill module so initializeWebMCPPolyfill installs our
+    // Mock the polyfill module so installWebMCP installs our
     // test mock onto document.modelContext instead of the real polyfill.
+    const installMock = jest.fn(() => {
+      if (!(globalThis as any).document?.modelContext) {
+        Object.defineProperty((globalThis as any).document, "modelContext", {
+          configurable: true,
+          value: {
+            registerTool: mockRegisterTool,
+            unregisterTool: mockUnregisterTool,
+            addEventListener: jest.fn(),
+            removeEventListener: jest.fn(),
+          },
+        });
+      }
+    });
+
     jest.unstable_mockModule("@mcp-b/webmcp-polyfill", () => ({
-      initializeWebMCPPolyfill: jest.fn(() => {
-        if (!(globalThis as any).document?.modelContext) {
-          Object.defineProperty((globalThis as any).document, "modelContext", {
-            configurable: true,
-            value: {
-              registerTool: mockRegisterTool,
-              unregisterTool: mockUnregisterTool,
-            },
-          });
-        }
-      }),
+      installWebMCP: installMock,
     }));
 
     jest.unstable_mockModule("../../db/open-database.js", () => ({
@@ -227,7 +231,7 @@ describe("webmcp integration", () => {
     // Re-mock the polyfill to be a no-op (simulates polyfill failure)
     jest.resetModules();
     jest.unstable_mockModule("@mcp-b/webmcp-polyfill", () => ({
-      initializeWebMCPPolyfill: jest.fn(),
+      installWebMCP: jest.fn(),
     }));
 
     jest.unstable_mockModule("../../db/open-database.js", () => ({
@@ -1070,6 +1074,73 @@ describe("webmcp integration", () => {
 
         unsubscribe();
       });
+
+      it("subscribes to toolchange event via onWebMcpToolChange", async () => {
+        const { onWebMcpToolChange } = await import("./webmcp.js");
+
+        const mockTarget = new EventTarget();
+        Object.defineProperty((globalThis as any).document, "modelContext", {
+          configurable: true,
+          value: mockTarget,
+        });
+
+        const listener = jest.fn();
+        const unsubscribe = onWebMcpToolChange(listener);
+
+        const changeEvt = new Event("toolchange");
+        mockTarget.dispatchEvent(changeEvt);
+
+        expect(listener).toHaveBeenCalledWith(changeEvt);
+
+        unsubscribe();
+        mockTarget.dispatchEvent(new Event("toolchange"));
+        expect(listener).toHaveBeenCalledTimes(1);
+      });
+    });
+
+    describe("annotations and discovery spec features", () => {
+      it("supports debugging annotation in resolveWebMcpToolAnnotations", async () => {
+        const { resolveWebMcpToolAnnotations } = await import("./webmcp.js");
+
+        const normal = resolveWebMcpToolAnnotations("read_file");
+        expect(normal.debugging).toBeUndefined();
+
+        const debugTool = resolveWebMcpToolAnnotations("dump_state", {
+          debugging: true,
+        });
+        expect(debugTool.debugging).toBe(true);
+      });
+
+      it("passes fromOrigins to modelContext.getTools and preserves title", async () => {
+        const { getWebMcpTools } = await import("./webmcp.js");
+
+        const mockGetTools = jest.fn(async (_opts?: any) => [
+          {
+            name: "cross_frame_tool",
+            title: "Cross Frame Tool",
+            description: "A tool from another origin",
+            inputSchema: { type: "object", properties: {} },
+          },
+        ]);
+
+        Object.defineProperty((globalThis as any).document, "modelContext", {
+          configurable: true,
+          value: {
+            registerTool: jest.fn(),
+            getTools: mockGetTools,
+          },
+        });
+
+        const tools = await getWebMcpTools({
+          fromOrigins: ["https://cart.example.com"],
+        });
+
+        expect(mockGetTools).toHaveBeenCalledWith({
+          fromOrigins: ["https://cart.example.com"],
+        });
+        expect(tools[0].name).toBe("cross_frame_tool");
+        expect(tools[0].title).toBe("Cross Frame Tool");
+      });
     });
   });
 });

package/src/subsystems/mcp/webmcp.ts

@@ -1,4 +1,5 @@
-import { initializeWebMCPPolyfill } from "@mcp-b/webmcp-polyfill";
+import { installWebMCP } from "@mcp-b/webmcp-polyfill";
+export type { WebMCP } from "webmcp-types";
 
 import { DEFAULT_GROUP_ID } from "../../config/config.js";
 import { TOOL_DEFINITIONS, type ToolDefinition } from "../tools/tools.js";
@@ -35,14 +36,37 @@ export function getWebMcpMode(): WebMcpMode {
 /**
  * Install the `@mcp-b/webmcp-polyfill` onto `document.modelContext`.
  *
+ * In `@mcp-b/webmcp-polyfill` 6.0.0+, the entry point is `installWebMCP()`
+ * (previously `initializeWebMCPPolyfill()` in v5).
  * The polyfill itself bails out when Chrome's native `document.modelContext`
  * is already present — it does NOT override the native API. We call it
- * unconditionally; if the polyfill is already installed it will detect the
- * existing install via its own `installState` guard and return quickly.
+ * unconditionally; if the polyfill is already installed it returns quickly.
  */
 function ensurePolyfill(): void {
   try {
-    initializeWebMCPPolyfill();
+    // Some test / mock environments or non-HTTPS dev setups may not define isSecureContext.
+    // If running in a browser-like environment without isSecureContext set, ensure safe default.
+    if (
+      typeof globalThis !== "undefined" &&
+      typeof globalThis.isSecureContext === "undefined" &&
+      typeof location !== "undefined" &&
+      (location.protocol === "https:" ||
+        location.hostname === "localhost" ||
+        location.hostname === "127.0.0.1")
+    ) {
+      try {
+        Object.defineProperty(globalThis, "isSecureContext", {
+          value: true,
+          configurable: true,
+        });
+      } catch {
+        // Ignore if read-only
+      }
+    }
+
+    if (typeof installWebMCP === "function") {
+      installWebMCP();
+    }
   } catch (err) {
     console.warn("WebMCP polyfill initialization failed:", err);
   }
@@ -177,6 +201,7 @@ export interface WebMcpExecuteContext {
 
 export interface WebMcpRegisteredTool {
   name: string;
+  title?: string;
   description?: string;
   inputSchema?: unknown;
   annotations?: Record<string, unknown>;
@@ -188,6 +213,7 @@ export interface WebMcpRegisteredTool {
 
 export interface NormalizedWebMcpRegisteredTool {
   name: string;
+  title?: string;
   description?: string;
   inputSchema: Record<string, unknown>;
   annotations?: Record<string, unknown>;
@@ -232,14 +258,17 @@ export function extractAbortSignal(
  * - Feature-detects `getTools()` on `document.modelContext` / `navigator.modelContext`.
  * - If `getTools()` is absent (older browser builds or polyfills without getTools),
  *   returns an empty array `[]` without throwing.
+ * - Supports options dictionary with `fromOrigins` to discover cross-frame/cross-origin tools (Chrome 155+).
  * - Normalizes `RegisteredTool#inputSchema` so caller receives a JavaScript object
  *   whether running on Chrome 154+ (native object) or Chrome < 154 (DOMString JSON).
  */
-export async function getWebMcpTools(): Promise<
-  NormalizedWebMcpRegisteredTool[]
-> {
+export async function getWebMcpTools(options?: {
+  fromOrigins?: string[];
+}): Promise<NormalizedWebMcpRegisteredTool[]> {
   const modelContext = getModelContextApi() as {
-    getTools?: () => Promise<WebMcpRegisteredTool[]>;
+    getTools?: (options?: {
+      fromOrigins?: string[];
+    }) => Promise<WebMcpRegisteredTool[]>;
   } | null;
 
   if (!modelContext || typeof modelContext.getTools !== "function") {
@@ -247,13 +276,14 @@ export async function getWebMcpTools(): Promise<
   }
 
   try {
-    const rawTools = await modelContext.getTools();
+    const rawTools = await modelContext.getTools(options);
     if (!Array.isArray(rawTools)) {
       return [];
     }
 
     return rawTools.map((tool) => ({
       name: tool.name,
+      ...(tool.title ? { title: tool.title } : {}),
       ...(tool.description ? { description: tool.description } : {}),
       inputSchema: parseWebMcpInputSchema(tool.inputSchema),
       ...(tool.annotations ? { annotations: tool.annotations } : {}),
@@ -595,6 +625,34 @@ export function onWebMcpToolCancel(
   return addWebMcpEventListener("toolcancel", listener, options);
 }
 
+/**
+ * Convenience helper to subscribe to tool registration change events (`toolchange`).
+ * Dispatched on `document.modelContext` when tools are registered or unregistered.
+ * Returns an unsubscribe cleanup function.
+ */
+export function onWebMcpToolChange(
+  listener: (event: Event) => void,
+  options?: boolean | AddEventListenerOptions,
+): () => void {
+  const doc = typeof document !== "undefined" ? document : undefined;
+  const nav = typeof navigator !== "undefined" ? navigator : undefined;
+  const modelContext: any =
+    (doc as any)?.modelContext ?? (nav as any)?.modelContext;
+
+  if (!modelContext || typeof modelContext.addEventListener !== "function") {
+    return () => {};
+  }
+
+  modelContext.addEventListener("toolchange", listener, options);
+  return () => {
+    try {
+      modelContext.removeEventListener("toolchange", listener, options);
+    } catch {
+      // Ignore cleanup error
+    }
+  };
+}
+
 /**
  * Consequential tools that perform high-stakes, irreversible, or external real-world actions
  * (such as deleting data, executing arbitrary system commands, or transmitting live communications).
@@ -649,6 +707,7 @@ export interface WebMcpToolAnnotations {
   readOnlyHint?: boolean;
   consequentialHint?: boolean;
   untrustedContentHint?: boolean;
+  debugging?: boolean;
   [key: string]: unknown;
 }
 
@@ -668,6 +727,9 @@ export function resolveWebMcpToolAnnotations(
     readOnlyHint: isReadOnly,
     consequentialHint: isConsequential,
     untrustedContentHint: true,
+    ...(typeof customAnnotations?.debugging === "boolean"
+      ? { debugging: customAnnotations.debugging }
+      : {}),
     ...(customAnnotations || {}),
   };
 }
@@ -680,7 +742,7 @@ export function resolveWebMcpToolAnnotations(
  * that unregistration works identically regardless of which implementation is
  * actually active.
  *
- * Key correctness detail: `initializeWebMCPPolyfill()` is a no-op when
+ * Key correctness detail: `ensurePolyfill()` is a no-op when
  * Chrome's native `document.modelContext` already exists — it does NOT
  * override the native API. In that situation we are talking to the native
  * Chrome API even in "polyfill" mode. The native Chrome API only supports
@@ -735,6 +797,7 @@ export async function registerWebMcpTools(
     try {
       const toolDef: any = {
         name: def.name,
+        title: (def as any).title || def.name,
         description: def.description,
         inputSchema: parseWebMcpInputSchema(def.input_schema),
         annotations: resolveWebMcpToolAnnotations(

package/src/utils/index.ts

@@ -18,6 +18,7 @@ export * from "./normalize-string-list.js";
 export * from "./normalize-workspace-path.js";
 export * from "./parse-boolean-config.js";
 export * from "./parse-stored-string-list.js";
+export * from "./resolve-page-script-dependencies.js";
 export * from "./retry.js";
 export * from "./seo.js";
 export * from "./ulid.js";

package/src/utils/resolve-page-script-dependencies.test.ts

@@ -0,0 +1,245 @@
+import { describe, expect, it, jest } from "@jest/globals";
+import {
+  PageScriptDependencySource,
+  resolvePageScriptDependencies,
+} from "./resolve-page-script-dependencies.js";
+
+describe("resolvePageScriptDependencies", () => {
+  const sampleDescriptors: PageScriptDependencySource[] = [
+    {
+      id: "feed-scroller",
+      src: "/pages/main/assets/feed-scroller.js",
+      global: true,
+      hasInit: true,
+    },
+    {
+      id: "x-hook-component",
+      src: "/pages/main/assets/x-hook-component.js",
+      hasInit: true,
+    },
+    {
+      name: "x-postpress-code",
+      src: "/pages/main/assets/x-postpress-code.js",
+      hasInit: true,
+    },
+    {
+      src: "/pages/main/assets/utility-logger.js",
+    },
+  ];
+
+  it("returns empty array when descriptors are empty and no frontmatter provided", () => {
+    expect(resolvePageScriptDependencies([], null)).toEqual([]);
+    expect(resolvePageScriptDependencies(undefined as any, undefined)).toEqual(
+      [],
+    );
+  });
+
+  it("always includes global or autoload scripts even if frontmatter is empty or null", () => {
+    const result = resolvePageScriptDependencies(sampleDescriptors, null);
+    expect(result).toHaveLength(1);
+    expect(result[0].id).toBe("feed-scroller");
+  });
+
+  it("resolves dependencies specified by id in frontmatter.dependencies", () => {
+    const result = resolvePageScriptDependencies(sampleDescriptors, {
+      dependencies: ["x-hook-component"],
+    });
+    expect(result.map((r) => r.src)).toEqual([
+      "/pages/main/assets/feed-scroller.js",
+      "/pages/main/assets/x-hook-component.js",
+    ]);
+  });
+
+  it("resolves dependencies case-insensitively", () => {
+    const result = resolvePageScriptDependencies(sampleDescriptors, {
+      dependencies: ["X-Hook-Component"],
+    });
+    expect(result.some((r) => r.id === "x-hook-component")).toBe(true);
+  });
+
+  it("resolves dependencies specified by name", () => {
+    const result = resolvePageScriptDependencies(sampleDescriptors, {
+      dependencies: ["x-postpress-code"],
+    });
+    expect(result.some((r) => r.name === "x-postpress-code")).toBe(true);
+  });
+
+  it("resolves dependencies specified by src path", () => {
+    const result = resolvePageScriptDependencies(sampleDescriptors, {
+      dependencies: ["/pages/main/assets/utility-logger.js"],
+    });
+    expect(
+      result.some((r) => r.src === "/pages/main/assets/utility-logger.js"),
+    ).toBe(true);
+  });
+
+  it("resolves dependencies with normalized relative paths", () => {
+    const result = resolvePageScriptDependencies(sampleDescriptors, {
+      dependencies: ["pages/main/assets/utility-logger.js"],
+    });
+    expect(
+      result.some((r) => r.src === "/pages/main/assets/utility-logger.js"),
+    ).toBe(true);
+  });
+
+  it("resolves dependencies from frontmatter.scripts array", () => {
+    const result = resolvePageScriptDependencies(sampleDescriptors, {
+      scripts: ["x-hook-component", "x-postpress-code"],
+    });
+    expect(result.map((r) => r.src)).toEqual([
+      "/pages/main/assets/feed-scroller.js",
+      "/pages/main/assets/x-hook-component.js",
+      "/pages/main/assets/x-postpress-code.js",
+    ]);
+  });
+
+  it("resolves dependencies when provided as a comma-separated string", () => {
+    const result = resolvePageScriptDependencies(sampleDescriptors, {
+      dependencies: "x-hook-component, x-postpress-code",
+    });
+    expect(result.map((r) => r.src)).toEqual([
+      "/pages/main/assets/feed-scroller.js",
+      "/pages/main/assets/x-hook-component.js",
+      "/pages/main/assets/x-postpress-code.js",
+    ]);
+  });
+
+  it("handles string descriptors seamlessly", () => {
+    const stringDescriptors = [
+      "/pages/main/assets/global-one.js",
+      { id: "widget", src: "/pages/main/assets/widget.js" },
+    ];
+    const result = resolvePageScriptDependencies(stringDescriptors as any, {
+      dependencies: ["widget"],
+    });
+    expect(result).toHaveLength(1);
+    expect(result[0].src).toBe("/pages/main/assets/widget.js");
+  });
+
+  it("deduplicates results if a global script is also explicitly requested", () => {
+    const result = resolvePageScriptDependencies(sampleDescriptors, {
+      dependencies: ["feed-scroller", "x-hook-component"],
+    });
+    expect(result).toHaveLength(2);
+    expect(
+      result.filter((r) => r.src === "/pages/main/assets/feed-scroller.js"),
+    ).toHaveLength(1);
+  });
+
+  it("gracefully ignores missing or unknown ids without throwing an error", () => {
+    const warnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
+    const result = resolvePageScriptDependencies(sampleDescriptors, {
+      dependencies: ["non-existent-script-id", "x-hook-component"],
+    });
+
+    expect(result.map((r) => r.src)).toEqual([
+      "/pages/main/assets/feed-scroller.js",
+      "/pages/main/assets/x-hook-component.js",
+    ]);
+    expect(warnSpy).toHaveBeenCalled();
+    warnSpy.mockRestore();
+  });
+
+  it("gracefully handles completely invalid or unresolvable dependencies", () => {
+    const warnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
+    const result = resolvePageScriptDependencies(
+      [{ id: "known", src: "/known.js" }],
+      { dependencies: ["unknown-a", "unknown-b"] },
+    );
+
+    expect(result).toEqual([]);
+    warnSpy.mockRestore();
+  });
+
+  describe("graceful fallback for existing configs without id", () => {
+    const legacyDescriptors = [
+      { src: "/pages/main/assets/feed-scroller.js", global: true },
+      { src: "/pages/main/assets/x-hook-component.js" },
+      { src: "/pages/main/assets/x-postpress-code.js" },
+    ];
+
+    it("matches dependency by stem when existing config has no id", () => {
+      const result = resolvePageScriptDependencies(legacyDescriptors, {
+        dependencies: ["x-hook-component"],
+      });
+      expect(result.map((r) => r.src)).toEqual([
+        "/pages/main/assets/feed-scroller.js",
+        "/pages/main/assets/x-hook-component.js",
+      ]);
+    });
+
+    it("matches dependency by filename with extension when existing config has no id", () => {
+      const result = resolvePageScriptDependencies(legacyDescriptors, {
+        dependencies: ["x-postpress-code.js"],
+      });
+      expect(result.map((r) => r.src)).toEqual([
+        "/pages/main/assets/feed-scroller.js",
+        "/pages/main/assets/x-postpress-code.js",
+      ]);
+    });
+
+    it("fails gracefully and renders best-effort if an id is missing from existing config", () => {
+      const warnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
+      // Frontmatter requests an unknown id AND a valid legacy script
+      const result = resolvePageScriptDependencies(legacyDescriptors, {
+        dependencies: ["non-existent-widget", "x-hook-component"],
+      });
+
+      // Best effort: successfully resolves the known script and global script, ignores missing
+      expect(result.map((r) => r.src)).toEqual([
+        "/pages/main/assets/feed-scroller.js",
+        "/pages/main/assets/x-hook-component.js",
+      ]);
+      expect(warnSpy).toHaveBeenCalledWith(
+        expect.stringContaining('Script dependency "non-existent-widget"'),
+      );
+      warnSpy.mockRestore();
+    });
+
+    it("supports string array config without ids matching by stem", () => {
+      const stringArrayConfig = [
+        "/pages/main/assets/feed-scroller.js",
+        "/pages/main/assets/x-hook-component.js",
+      ];
+      const result = resolvePageScriptDependencies(stringArrayConfig, {
+        dependencies: ["x-hook-component"],
+      });
+      expect(result.map((r) => r.src)).toEqual([
+        "/pages/main/assets/x-hook-component.js",
+      ]);
+    });
+  });
+
+  describe("content-based auto-detection", () => {
+    it("automatically detects inline script tags in markdown content", () => {
+      const rawContent = `
+# Title
+Some text
+<script type="module" src="/pages/main/assets/x-postpress-code.js"></script>
+      `;
+      const result = resolvePageScriptDependencies(
+        sampleDescriptors,
+        null,
+        rawContent,
+      );
+      expect(result.map((r) => r.src)).toContain(
+        "/pages/main/assets/x-postpress-code.js",
+      );
+    });
+
+    it("automatically detects custom element tags matching descriptors in markdown content", () => {
+      const rawContent = `
+# Post
+<x-postpress-code type="html"><pre>code</pre></x-postpress-code>
+      `;
+      const result = resolvePageScriptDependencies(
+        sampleDescriptors,
+        null,
+        rawContent,
+      );
+      expect(result.map((r) => r.src)).toContain(
+        "/pages/main/assets/x-postpress-code.js",
+      );
+    });
+  });
+});