shadow-claw 1.26.0 → 1.27.0

package/src/components/shadow-claw-a2ui/shadow-claw-a2ui.ts

@@ -596,8 +596,6 @@ export class ShadowClawA2UI extends ShadowClawElement {
       return;
     }
 
-    const db = await getDb();
-
     // Collect all deferred media elements
     const mediaElements = [
       ...Array.from(root.querySelectorAll("img[data-a2ui-workspace-src]")),
@@ -605,15 +603,22 @@ export class ShadowClawA2UI extends ShadowClawElement {
       ...Array.from(root.querySelectorAll("audio[data-a2ui-workspace-src]")),
     ];
 
+    // Also resolve poster URLs for videos
+    const videosWithPoster = Array.from(
+      root.querySelectorAll("video[data-a2ui-workspace-poster]"),
+    );
+
+    if (mediaElements.length === 0 && videosWithPoster.length === 0) {
+      return;
+    }
+
+    const db = await getDb();
+
     // Parallelize all media blob URL conversions using Promise.all
     await Promise.all(
       mediaElements.map((el) => this.#resolveSingleMediaToBlobUrl(el, db)),
     );
 
-    // Also resolve poster URLs for videos
-    const videosWithPoster = Array.from(
-      root.querySelectorAll("video[data-a2ui-workspace-poster]"),
-    );
     await Promise.all(
       videosWithPoster.map((el) =>
         this.#resolveVideoPosterToBlobUrl(el as HTMLVideoElement, db),

package/src/components/shadow-claw-file-viewer/shadow-claw-file-viewer.test.ts

@@ -667,7 +667,7 @@ describe("shadow-claw-file-viewer", () => {
     configScript.textContent = JSON.stringify({
       customElements: {
         scripts: [
-          "pages/main/block-garden-adapter.js",
+          { src: "pages/main/block-garden-adapter.js", hasInit: true },
           "https://kherrick.github.io/block-garden/block-garden-bundle-min.mjs",
         ],
       },
@@ -686,6 +686,13 @@ describe("shadow-claw-file-viewer", () => {
     expect(srcdoc).toContain(
       'src="https://kherrick.github.io/block-garden/block-garden-bundle-min.mjs"',
     );
+    // Has init script for block-garden-adapter.js because hasInit is true
+    expect(srcdoc).toContain('import("/block-garden-adapter.js")');
+    expect(srcdoc).toContain('m?.init === "function"');
+    // Does NOT have init script for block-garden-bundle-min.mjs
+    expect(srcdoc).not.toContain(
+      'import("https://kherrick.github.io/block-garden/block-garden-bundle-min.mjs")',
+    );
 
     document.head.removeChild(configScript);
     setAllowedCustomElementHostPatterns([]);

package/src/components/shadow-claw-file-viewer/shadow-claw-file-viewer.ts

@@ -51,7 +51,7 @@ import type { Config } from "dompurify";
 import type { ShadowClawDatabase } from "../../db/types.js";
 
 import {
-  getApprovedCustomElementScripts,
+  getApprovedCustomElementScriptDescriptors,
   getIframeCsp,
   getIframeSandboxPolicy,
   isAllowedCustomElement,
@@ -1386,7 +1386,7 @@ export class ShadowClawFileViewer extends ShadowClawElement {
       "/assets/iframe-storage-bridge.js",
     );
 
-    const approvedScripts = getApprovedCustomElementScripts();
+    const approvedScripts = getApprovedCustomElementScriptDescriptors();
     const cspContent = getIframeCsp(nonce);
 
     const configScript =
@@ -1399,11 +1399,11 @@ export class ShadowClawFileViewer extends ShadowClawElement {
         : "";
 
     const searchScriptHtml = searchParams
-      ? `<script nonce="${nonce}">(function(){try{Object.defineProperty(window.location,"search",{get:function(){return ${JSON.stringify(searchParams)};},configurable:true});}catch(e){}})();</script>`
+      ? `<script nonce="${nonce}">(function(){try{Object.defineProperty(globalThis.location,"search",{get:function(){return ${JSON.stringify(searchParams)};},configurable:true});}catch(e){}})();</script>`
       : "";
 
     const customElementScriptsHtml = approvedScripts
-      .map((src) => {
+      .map(({ src, hasInit }) => {
         const isExternal =
           src.startsWith("http://") ||
           src.startsWith("https://") ||
@@ -1415,7 +1415,15 @@ export class ShadowClawFileViewer extends ShadowClawElement {
                 ? src
                 : `/${src.replace(/^pages\/main\//, "")}`,
             );
-        return `<script type="module" src="${resolvedSrc}" nonce="${nonce}"></script>`;
+        const tags = [
+          `<script type="module" src="${resolvedSrc}" nonce="${nonce}"></script>`,
+        ];
+        if (hasInit) {
+          tags.push(
+            `<script type="module" nonce="${nonce}">import("${resolvedSrc}").then((m) => { try { if (typeof m?.init === "function") m.init(); } catch (e) { console.error("[ShadowClaw] Error executing init for " + ${JSON.stringify(resolvedSrc)}, e); } }).catch(() => {});</script>`,
+          );
+        }
+        return tags.join("\n");
       })
       .join("\n");
 

package/src/components/shadow-claw-pages/utils/buildHtmlPageSrcdoc.ts

@@ -10,7 +10,7 @@ import {
   getIframeThemeStyleHtml,
 } from "../../../ui/iframe-theme.js";
 import {
-  getApprovedCustomElementScripts,
+  getApprovedCustomElementScriptDescriptors,
   getIframeCsp,
   isAllowedCustomElement,
 } from "../../../security/custom-element-security.js";
@@ -85,7 +85,7 @@ export async function buildHtmlPageSrcdoc({
     "/assets/iframe-storage-bridge.js",
   );
 
-  const approvedScripts = getApprovedCustomElementScripts();
+  const approvedScripts = getApprovedCustomElementScriptDescriptors();
   const cspContent = getIframeCsp(nonce);
 
   const configScript =
@@ -98,11 +98,11 @@ export async function buildHtmlPageSrcdoc({
       : "";
 
   const searchScriptHtml = searchParams
-    ? `<script nonce="${nonce}">(function(){try{Object.defineProperty(window.location,"search",{get:function(){return ${JSON.stringify(searchParams)};},configurable:true});}catch(e){}})();</script>`
+    ? `<script nonce="${nonce}">(function(){try{Object.defineProperty(globalThis.location,"search",{get:function(){return ${JSON.stringify(searchParams)};},configurable:true});}catch(e){}})();</script>`
     : "";
 
   const customElementScriptsHtml = approvedScripts
-    .map((src) => {
+    .map(({ src, hasInit }) => {
       const isExternal =
         src.startsWith("http://") ||
         src.startsWith("https://") ||
@@ -112,7 +112,15 @@ export async function buildHtmlPageSrcdoc({
         : applyBasePath(
             src.startsWith("/") ? src : `/${src.replace(/^pages\/main\//, "")}`,
           );
-      return `<script type="module" src="${resolvedSrc}" nonce="${nonce}"></script>`;
+      const tags = [
+        `<script type="module" src="${resolvedSrc}" nonce="${nonce}"></script>`,
+      ];
+      if (hasInit) {
+        tags.push(
+          `<script type="module" nonce="${nonce}">import("${resolvedSrc}").then((m) => { try { if (typeof m?.init === "function") m.init(); } catch (e) { console.error("[ShadowClaw] Error executing init for " + ${JSON.stringify(resolvedSrc)}, e); } }).catch(() => {});</script>`,
+        );
+      }
+      return tags.join("\n");
     })
     .join("\n");
 

package/src/core/control-plane-client.ts

@@ -247,6 +247,9 @@ export class ControlPlaneClient {
 
   public disconnect(): void {
     this._isDestroyed = true;
+    try {
+      this._sendUnregister();
+    } catch (_) {}
     this._cleanupConnection();
     if (this._reconnectTimer) {
       clearTimeout(this._reconnectTimer);
@@ -331,6 +334,18 @@ export class ControlPlaneClient {
     });
   }
 
+  private _sendUnregister(): void {
+    if (!this._clientId) return;
+    const payload = {
+      clientId: this._clientId,
+    };
+    this._sendMessage({
+      id: ulid(),
+      type: "client:unregister",
+      payload,
+    });
+  }
+
   private _sendMessage(msg: ControlMessage): void {
     if (this._transport === "websocket") {
       if (

package/src/core/utils/initControlPlane.test.ts

@@ -588,6 +588,193 @@ describe("initControlPlane", () => {
         Object.defineProperty(navigator, "modelContext", origNavMC);
     });
 
+    it("handles native Chromium WebMCP invoke-tool passing ModelContextTool to executeTool", async () => {
+      const origDocMC = Object.getOwnPropertyDescriptor(
+        document,
+        "modelContext",
+      );
+      const origNavMC = Object.getOwnPropertyDescriptor(
+        navigator,
+        "modelContext",
+      );
+      delete (navigator as any).modelContext;
+
+      const nativeModelContextTool = {
+        name: "list_files",
+        description: "List files and directories",
+        inputSchema: '{"type":"object"}',
+        title: "list_files",
+        origin: "http://localhost:8888",
+        window: globalThis.window,
+      };
+
+      const mockExecuteTool = (jest.fn() as any).mockImplementation(
+        async (tool: any, _inputArgsJson: string) => {
+          // Native Chromium strictly requires the tool object from getTools()
+          if (tool !== nativeModelContextTool) {
+            throw new TypeError(
+              "Failed to execute 'executeTool' on 'ModelContext': parameter 1 is not of type 'ModelContextTool'",
+            );
+          }
+          return `.agents/ MEMORY.md index.html -/`;
+        },
+      );
+
+      Object.defineProperty(document, "modelContext", {
+        value: {
+          getTools: (jest.fn() as any).mockResolvedValue([
+            nativeModelContextTool,
+          ]),
+          executeTool: mockExecuteTool,
+        },
+        configurable: true,
+      });
+
+      try {
+        const res = await executeClientControlCommand(
+          "invoke-tool",
+          { toolName: "list_files", input: {} },
+          {},
+        );
+
+        expect(res).toEqual({
+          result: ".agents/ MEMORY.md index.html -/",
+        });
+        expect(mockExecuteTool).toHaveBeenCalledWith(
+          nativeModelContextTool,
+          "{}",
+        );
+      } finally {
+        if (origDocMC)
+          Object.defineProperty(document, "modelContext", origDocMC);
+        if (origNavMC)
+          Object.defineProperty(navigator, "modelContext", origNavMC);
+      }
+    });
+
+    it("refuses to execute tool when tool is not registered on client or not enabled in active conversation", async () => {
+      const origDocMC = Object.getOwnPropertyDescriptor(
+        document,
+        "modelContext",
+      );
+      const origNavMC = Object.getOwnPropertyDescriptor(
+        navigator,
+        "modelContext",
+      );
+      delete (navigator as any).modelContext;
+
+      Object.defineProperty(document, "modelContext", {
+        value: {
+          getTools: (jest.fn() as any).mockResolvedValue([
+            {
+              name: "list_files",
+              description: "List files",
+              inputSchema: "{}",
+            },
+          ]),
+          executeTool: jest.fn(),
+        },
+        configurable: true,
+      });
+
+      try {
+        // 1. Client has WebMCP tools registered, but ask_user is not among them
+        await expect(
+          executeClientControlCommand("invoke-tool", { toolName: "ask_user" }),
+        ).rejects.toThrow(
+          "Tool 'ask_user' is not enabled or registered on this client.",
+        );
+
+        // 2. Conversation group has restricted toolTags
+        const { orchestratorStore } =
+          await import("../../stores/orchestrator.js");
+        const groupsSpy = jest
+          .spyOn(orchestratorStore, "groups", "get")
+          .mockReturnValue([
+            { groupId: "br:restricted", toolTags: ["read_file"] } as any,
+          ]);
+
+        try {
+          await expect(
+            executeClientControlCommand(
+              "invoke-tool",
+              { toolName: "write_file", groupId: "br:restricted" },
+              { orchestrator: { activeGroupId: "br:restricted" } as any },
+            ),
+          ).rejects.toThrow(
+            "Tool 'write_file' is not enabled in the active conversation (br:restricted).",
+          );
+        } finally {
+          groupsSpy.mockRestore();
+        }
+      } finally {
+        if (origDocMC)
+          Object.defineProperty(document, "modelContext", origDocMC);
+        if (origNavMC)
+          Object.defineProperty(navigator, "modelContext", origNavMC);
+      }
+    });
+
+    it("falls back to worker when modelContext executeTool throws", async () => {
+      const origDocMC = Object.getOwnPropertyDescriptor(
+        document,
+        "modelContext",
+      );
+      delete (document as any).modelContext;
+
+      let workerHandler: any;
+      const mockWorker: any = {
+        addEventListener: jest.fn((event: string, handler: any) => {
+          if (event === "message") {
+            workerHandler = handler;
+          }
+        }),
+        removeEventListener: jest.fn(),
+        postMessage: jest.fn((msg: any) => {
+          setTimeout(() => {
+            workerHandler({
+              data: {
+                type: "execute-tool-result",
+                callId: msg.callId,
+                result: "worker result for " + msg.payload.name,
+              },
+            });
+          }, 0);
+        }),
+      };
+
+      // Define modelContext where executeTool throws
+      Object.defineProperty(document, "modelContext", {
+        value: {
+          getTools: (jest.fn() as any).mockResolvedValue([]),
+          executeTool: (jest.fn() as any).mockRejectedValue(
+            new Error("Native runtime fault"),
+          ),
+        },
+        configurable: true,
+      });
+
+      try {
+        const res = await executeClientControlCommand(
+          "invoke-tool",
+          { toolName: "list_files", input: { path: "docs" } },
+          {
+            orchestrator: {
+              agentWorker: mockWorker,
+              activeGroupId: "br:main",
+            } as any,
+          },
+        );
+
+        expect(res).toEqual({
+          result: "worker result for list_files",
+        });
+      } finally {
+        if (origDocMC)
+          Object.defineProperty(document, "modelContext", origDocMC);
+      }
+    });
+
     it("handles send-message when orchestrator is not ready", async () => {
       const { orchestratorStore } =
         await import("../../stores/orchestrator.js");

package/src/core/utils/initControlPlane.ts

@@ -293,7 +293,44 @@ export async function executeClientControlCommand(
         }
       } catch (_) {}
 
-      // Fallback: list built-in TOOL_DEFINITIONS
+      // Fallback: filter by conversation group toolTags if active
+      try {
+        const { orchestratorStore } =
+          await import("../../stores/orchestrator.js");
+        const orch =
+          options.orchestrator ||
+          orchestratorStore.orchestrator ||
+          (typeof document !== "undefined"
+            ? (document.querySelector("shadow-claw") as any)?.orchestrator
+            : null);
+        const activeGroupId =
+          args.groupId ||
+          orch?.activeGroupId ||
+          orchestratorStore.activeGroupId ||
+          "br:main";
+        const group = orchestratorStore.groups.find(
+          (g) => g.groupId === activeGroupId,
+        );
+
+        if (group?.toolTags && group.toolTags.length > 0) {
+          const { TOOL_DEFINITIONS } =
+            await import("../../subsystems/tools/index.js");
+          const { parseWebMcpInputSchema } =
+            await import("../../subsystems/mcp/webmcp.js");
+          const activeTools = TOOL_DEFINITIONS.filter((t) =>
+            group.toolTags!.includes(t.name),
+          );
+          return {
+            tools: activeTools.map((t) => ({
+              name: t.name,
+              description: t.description,
+              inputSchema: parseWebMcpInputSchema(t.input_schema),
+            })),
+          };
+        }
+      } catch (_) {}
+
+      // Default fallback: list built-in TOOL_DEFINITIONS
       const { TOOL_DEFINITIONS } =
         await import("../../subsystems/tools/index.js");
       const { parseWebMcpInputSchema } =
@@ -311,51 +348,185 @@ export async function executeClientControlCommand(
       if (!args.toolName) {
         throw new Error("Missing toolName parameter");
       }
+
+      // 1. Validate tool against active conversation group and toolsStore
+      try {
+        const { orchestratorStore } =
+          await import("../../stores/orchestrator.js");
+        const { toolsStore } = await import("../../stores/tools.js");
+        const orch =
+          options.orchestrator ||
+          orchestratorStore.orchestrator ||
+          (typeof document !== "undefined"
+            ? (document.querySelector("shadow-claw") as any)?.orchestrator
+            : null);
+        const activeGroupId =
+          args.groupId ||
+          orch?.activeGroupId ||
+          orchestratorStore.activeGroupId ||
+          "br:main";
+        const group = orchestratorStore.groups.find(
+          (g) => g.groupId === activeGroupId,
+        );
+
+        if (group?.toolTags && group.toolTags.length > 0) {
+          if (!group.toolTags.includes(args.toolName)) {
+            throw new Error(
+              `Tool '${args.toolName}' is not enabled in the active conversation (${activeGroupId}).`,
+            );
+          }
+        } else if (
+          toolsStore?.allTools &&
+          toolsStore.allTools.some((t: any) => t.name === args.toolName) &&
+          toolsStore?.enabledToolNames &&
+          toolsStore.enabledToolNames.size > 0
+        ) {
+          const isBuiltIn = toolsStore.enabledToolNames.has(args.toolName);
+          const isDeclarative = toolsStore.isDeclarativeToolEnabled(
+            args.toolName,
+          );
+          if (!isBuiltIn && !isDeclarative) {
+            throw new Error(
+              `Tool '${args.toolName}' is not enabled on this client.`,
+            );
+          }
+        }
+      } catch (err: any) {
+        if (err.message && err.message.includes("is not enabled")) {
+          throw err;
+        }
+      }
+
       const ctx =
         (typeof document !== "undefined" && (document as any).modelContext) ||
         (typeof navigator !== "undefined" && (navigator as any).modelContext);
 
       if (ctx) {
+        let matchedTool: any;
         if (typeof ctx.getTools === "function") {
           try {
             const tools = await ctx.getTools();
-            const tool = Array.isArray(tools)
-              ? tools.find((t: any) => t.name === args.toolName)
-              : undefined;
-            if (tool && typeof tool.execute === "function") {
-              const res = await tool.execute(args.input || {});
+            if (Array.isArray(tools) && tools.length > 0) {
+              matchedTool = tools.find((t: any) => t.name === args.toolName);
+              if (!matchedTool) {
+                throw new Error(
+                  `Tool '${args.toolName}' is not enabled or registered on this client.`,
+                );
+              }
+            } else {
+              matchedTool = Array.isArray(tools)
+                ? tools.find((t: any) => t.name === args.toolName)
+                : undefined;
+            }
+            if (matchedTool && typeof matchedTool.execute === "function") {
+              const res = await matchedTool.execute(
+                typeof args.input === "string"
+                  ? JSON.parse(args.input)
+                  : args.input || {},
+              );
               return { result: res };
             }
-          } catch (_) {}
+          } catch (err: any) {
+            if (err.message && err.message.includes("is not enabled")) {
+              throw err;
+            }
+          }
         }
+
+        const inputStr =
+          typeof args.input === "string"
+            ? args.input
+            : JSON.stringify(args.input || {});
+
         if (typeof ctx.executeTool === "function") {
-          const res = await ctx.executeTool(
-            { name: args.toolName },
-            typeof args.input === "string"
-              ? args.input
-              : JSON.stringify(args.input || {}),
-          );
-          return { result: res };
+          // 1. Pass the actual ModelContextTool object from getTools() if available (required by native Chromium)
+          if (matchedTool) {
+            try {
+              const res = await ctx.executeTool(matchedTool, inputStr);
+              return { result: res };
+            } catch (_) {}
+          }
+
+          // 2. Pass { name: toolName } object (accepted by polyfill / mocks)
+          try {
+            const res = await ctx.executeTool(
+              { name: args.toolName },
+              inputStr,
+            );
+            return { result: res };
+          } catch (_) {}
+
+          // 3. Pass toolName string directly (accepted by some preview shims)
+          try {
+            const res = await ctx.executeTool(args.toolName, inputStr);
+            return { result: res };
+          } catch (_) {}
         }
+
+        // 4. Check navigator.modelContextTesting if present
+        if (
+          typeof navigator !== "undefined" &&
+          (navigator as any).modelContextTesting &&
+          typeof (navigator as any).modelContextTesting.executeTool ===
+            "function"
+        ) {
+          try {
+            const res = await (
+              navigator as any
+            ).modelContextTesting.executeTool(args.toolName, inputStr);
+            return { result: res };
+          } catch (_) {}
+        }
+
+        // 5. Check callTool (MCP-B / extension runtime)
+        if (typeof ctx.callTool === "function") {
+          try {
+            const res = await ctx.callTool({
+              name: args.toolName,
+              arguments:
+                typeof args.input === "string"
+                  ? JSON.parse(args.input)
+                  : args.input || {},
+            });
+            return { result: res };
+          } catch (_) {}
+        }
+
+        // 6. Check invoke
         if (typeof ctx.invoke === "function") {
-          const res = await ctx.invoke(args.toolName, args.input || {});
-          return { result: res };
+          try {
+            const res = await ctx.invoke(
+              args.toolName,
+              typeof args.input === "string"
+                ? JSON.parse(args.input)
+                : args.input || {},
+            );
+            return { result: res };
+          } catch (_) {}
         }
       }
 
       // Worker fallback if agent worker is active
       const { orchestratorStore } =
         await import("../../stores/orchestrator.js");
-      const orch = options.orchestrator || orchestratorStore.orchestrator;
+      const orch =
+        options.orchestrator ||
+        orchestratorStore.orchestrator ||
+        (typeof document !== "undefined"
+          ? (document.querySelector("shadow-claw") as any)?.orchestrator
+          : null);
       const worker: any = orch?.agentWorker;
       if (worker && typeof worker.postMessage === "function") {
         const callId =
           Date.now().toString(36) + Math.random().toString(36).slice(2);
+        const isInteractive = args.toolName === "ask_user";
+        const fallbackTimeoutMs =
+          args.timeoutMs || (isInteractive ? 300000 : 60000);
         const result = await new Promise((resolve, reject) => {
           const timeout = setTimeout(() => {
             worker.removeEventListener("message", handler);
             reject(new Error("Timeout waiting for tool execution"));
-          }, 60000);
+          }, fallbackTimeoutMs);
 
           const handler = (event: MessageEvent) => {
             const data = event.data;
@@ -380,8 +551,11 @@ export async function executeClientControlCommand(
             callId,
             payload: {
               name: args.toolName,
-              input: args.input || {},
-              groupId: args.groupId || orch.activeGroupId || "br:main",
+              input:
+                typeof args.input === "string"
+                  ? JSON.parse(args.input)
+                  : args.input || {},
+              groupId: args.groupId || orch?.activeGroupId || "br:main",
             },
           });
         });