shadow-claw 1.40.0 → 1.41.0

package/src/core/orchestrator/utils/syncWebMcpRegistration.ts

@@ -5,6 +5,8 @@ import {
   setWebMcpMode as applyWebMcpMode,
   registerWebMcpTools,
   unregisterWebMcpTools,
+  onWebMcpToolActivated,
+  onWebMcpToolCancel,
 } from "../../../subsystems/mcp/webmcp.js";
 
 import { effect } from "../../effect.js";
@@ -14,6 +16,8 @@ import { CONFIG_KEYS } from "../../../config/config.js";
 import { setConfig } from "../../../db/setConfig.js";
 
 import type { ShadowClawDatabase } from "../../../db/db.js";
+import type { DeclarativeToolDefinition } from "../../../subsystems/tools/declarative.js";
+import type { SkillRecord } from "../../../subsystems/skills/types.js";
 import type { WebMcpMode } from "../../../subsystems/mcp/webmcp.js";
 import type { OrchestratorState } from "../orchestrator-state.js";
 import type { Orchestrator } from "../orchestrator.js";
@@ -36,6 +40,19 @@ export function syncWebMcpRegistration(
     return;
   }
 
+  // Subscribe to WebMCP lifecycle events (PR #245 / Chrome 156+ with backwards compatibility).
+  const unsubscribeActivated = onWebMcpToolActivated((event) => {
+    orchestrator.events?.emit("webmcp-tool-activated", {
+      toolName: event.toolName,
+    });
+  });
+
+  const unsubscribeCancel = onWebMcpToolCancel((event) => {
+    orchestrator.events?.emit("webmcp-tool-cancel", {
+      toolName: event.toolName,
+    });
+  });
+
   // Register WebMCP tools and re-register when tool config changes.
   // This effect runs once immediately to perform the initial registration.
   // We intentionally do NOT call isWebMcpSupported() here — that accesses
@@ -43,7 +60,7 @@ export function syncWebMcpRegistration(
   // early-preview renderer. Instead, registerWebMcpTools handles feature detection
   // internally and skips modelContext access entirely when 0 tools are
   // passed.
-  orchestrator.webMcpEffectCleanup = effect(() => {
+  const disposeEffect = effect(() => {
     // Access signals to establish tracking.
     const activeGroupId = orchestratorStore.activeGroupId;
     const allTools = toolsStore.allTools;
@@ -60,7 +77,7 @@ export function syncWebMcpRegistration(
         // Small delay to allow the browser's ModelContext to process the unregistrations.
         await new Promise((resolve) => setTimeout(resolve, 0));
 
-        let declarativeTools: any[] = [];
+        let declarativeTools: DeclarativeToolDefinition[] = [];
         try {
           declarativeTools = await toolsStore.refreshDeclarativeTools(
             db,
@@ -80,7 +97,7 @@ export function syncWebMcpRegistration(
             ? candidateTools.filter((t) => group.toolTags!.includes(t.name))
             : [...globalTools, ...enabledDeclarativeTools];
 
-        let skillDiscovery: { skills: any[] } = { skills: [] };
+        let skillDiscovery: { skills: SkillRecord[] } = { skills: [] };
         try {
           skillDiscovery = await discoverSkills(db, activeGroupId);
         } catch {
@@ -107,6 +124,18 @@ export function syncWebMcpRegistration(
         console.error("WebMCP registration failed:", err);
       });
   });
+
+  orchestrator.webMcpEffectCleanup = () => {
+    try {
+      unsubscribeActivated();
+    } catch {}
+    try {
+      unsubscribeCancel();
+    } catch {}
+    if (typeof disposeEffect === "function") {
+      disposeEffect();
+    }
+  };
 }
 export async function setWebMcpMode(
   _state: Pick<

package/src/server/middleware/static-files.test.ts

@@ -175,6 +175,42 @@ describe("static-files-middleware", () => {
     }
   });
 
+  it("serves SPA shell for app routes even when route directory exists on disk", async () => {
+    await register();
+    const middleware = app.use.mock.calls[1][0];
+
+    for (const appPath of ["/files", "/files/", "/pages", "/pages/"]) {
+      const req = {
+        method: "GET",
+        headers: {
+          accept: "text/html",
+          "sec-fetch-dest": "document",
+          "sec-fetch-mode": "navigate",
+        },
+        originalUrl: appPath,
+        url: appPath,
+      };
+      const res = { setHeader: jest.fn(), sendFile: jest.fn() };
+      const next = jest.fn();
+
+      fsMock.stat.mockImplementation((_targetPath: string, cb: any) => {
+        cb(null, { isFile: () => false, isDirectory: () => true });
+      });
+      fsMock.access.mockImplementation(
+        (_targetPath: string, _mode: any, cb: any) => {
+          cb(new Error("ENOENT"));
+        },
+      );
+
+      middleware(req, res, next);
+
+      expect(res.sendFile).toHaveBeenCalledWith(
+        expect.stringContaining("/root/index.html"),
+      );
+      expect(next).not.toHaveBeenCalled();
+    }
+  });
+
   it("does not serve SPA shell for non-HTML missing requests", async () => {
     await register();
     const middleware = app.use.mock.calls[1][0];

package/src/server/middleware/static-files.ts

@@ -112,15 +112,18 @@ export function registerStaticFilesMiddleware(app: Express, rootPath: string) {
     }
 
     const urlPathname = new URL(req.url || "/", "http://localhost").pathname;
+    if (
+      isSpaShellRequest(req, requestPath) ||
+      isSpaShellRequest(req, urlPathname)
+    ) {
+      res.sendFile(path.join(rootPath, "index.html"));
+
+      return;
+    }
+
     const filePath = path.join(rootPath, urlPathname);
     fs.stat(filePath, (err, stats) => {
       if (err || !stats) {
-        if (isSpaShellRequest(req, requestPath)) {
-          res.sendFile(path.join(rootPath, "index.html"));
-
-          return;
-        }
-
         // Check if request has a subpath prefix matching a root file (e.g. /shadow-claw/index.js -> /index.js)
         const strippedSegmentPath = requestPath.replace(/^\/[^/]+/, "");
         if (strippedSegmentPath) {
@@ -212,6 +215,11 @@ export function registerStaticFilesMiddleware(app: Express, rootPath: string) {
             } else {
               res.sendFile(indexPath);
             }
+          } else if (
+            isSpaShellRequest(req, requestPath) ||
+            isSpaShellRequest(req, urlPathname)
+          ) {
+            res.sendFile(path.join(rootPath, "index.html"));
           } else {
             next();
           }

package/src/server/routes/mcp.ts

@@ -256,7 +256,7 @@ export function registerMcpRoutes(
         name: "shadow-claw",
         version: getPackageVersion(),
         description:
-          "Browser-native personal AI assistant with local and remote LLM orchestration, Web Workers, OPFS storage, and agentic tool execution.",
+          "Multi-runtime AI assistant with local and remote LLM orchestration, Web Workers, OPFS storage, and agentic tool execution.",
         title: "ShadowClaw MCP Server",
         websiteUrl: `${origin}/shadow-claw/`,
         repository: {
@@ -332,7 +332,7 @@ export function registerMcpRoutes(
         servers: [
           {
             name: "shadow-claw",
-            description: "ShadowClaw Browser-Native AI Assistant MCP Server",
+            description: "ShadowClaw Multi-Runtime AI Assistant MCP Server",
             endpoint: `${origin}/mcp`,
             capabilities: ["tools", "extensions"],
             card: `${origin}/.well-known/mcp.json`,

package/src/storage/staticRouting.test.ts

@@ -73,12 +73,29 @@ describe("staticRouting", () => {
         "/pages/main/posts/2026-07-01_03-37-38.md": {
           prettyPath: "/2026/06/30/on-developing-loops/",
         },
+        "/pages/main/index.html": {
+          prettyPath: "/",
+        },
         "/pages/main/about.md": {
           prettyPath: "/about",
         },
       },
     };
 
+    // Test root path "/"
+    expect(resolvePrettyPathToRoute("/", manifest)).toEqual({
+      page: "pages",
+      groupId: "br:main",
+      path: "index.html",
+    });
+
+    // Test root index.html
+    expect(resolvePrettyPathToRoute("/index.html", manifest)).toEqual({
+      page: "pages",
+      groupId: "br:main",
+      path: "index.html",
+    });
+
     // Test with explicit manifest
     expect(
       resolvePrettyPathToRoute("/2026/06/30/on-developing-loops/", manifest),
@@ -155,6 +172,25 @@ describe("staticRouting", () => {
         manifest,
       ),
     ).toBeNull();
+
+    const manifestWithRoot: StaticRoutesManifest = {
+      routes: {
+        "/pages/main/index.html": {
+          prettyPath: "/",
+        },
+      },
+    };
+
+    expect(
+      resolveRouteToPrettyPath(
+        { page: "pages", groupId: "br:main" },
+        manifestWithRoot,
+      ),
+    ).toBe("/");
+
+    expect(resolveRouteToPrettyPath({ page: "pages" }, manifestWithRoot)).toBe(
+      "/",
+    );
   });
 
   it("fetches static routing manifest when not embedded in DOM", async () => {

package/src/storage/staticRouting.ts

@@ -214,9 +214,6 @@ export function resolvePrettyPathToRoute(
   }
 
   const normalizedPath = normalizePrettyPathKey(pathname);
-  if (!normalizedPath) {
-    return null;
-  }
 
   for (const [canonicalKey, routeDef] of Object.entries(
     routesManifest.routes,
@@ -363,6 +360,29 @@ export function resolveRouteToPrettyPath(
       candidateKeys.push(`pages/${normalizedGroupId}/${cleanPath}`);
       candidateKeys.push(`/pages/${groupId}/${cleanPath}`);
     }
+  } else if (page === "pages" && !path) {
+    if (normalizedGroupId === "main" || !normalizedGroupId) {
+      candidateKeys.push(
+        "/pages/main/index.html",
+        "pages/main/index.html",
+        "/pages/br:main/index.html",
+        "/pages/br-main/index.html",
+        "/main/index.html",
+        "main/index.html",
+        "/index.html",
+        "index.html",
+        "/pages/main",
+        "pages/main",
+        "/pages",
+        "pages",
+      );
+    } else if (normalizedGroupId) {
+      candidateKeys.push(
+        `/pages/${normalizedGroupId}/index.html`,
+        `pages/${normalizedGroupId}/index.html`,
+        `/pages/${groupId}/index.html`,
+      );
+    }
   } else if (page === "files" && path) {
     const cleanPath = trimSlashes(path);
     if (normalizedGroupId) {
@@ -386,5 +406,13 @@ export function resolveRouteToPrettyPath(
     }
   }
 
+  if (page === "pages" && !path) {
+    for (const routeDef of Object.values(routesManifest.routes)) {
+      if (routeDef && routeDef.prettyPath === "/") {
+        return "/";
+      }
+    }
+  }
+
   return null;
 }

package/src/stores/file-viewer.test.ts

@@ -155,4 +155,15 @@ describe("FileViewerStore", () => {
       mimeType: "text/plain",
     });
   });
+
+  it("handles empty path and extension-less filenames", async () => {
+    (readGroupFile as any).mockResolvedValue("empty-content");
+    const s = new FileViewerStore();
+
+    expect(s.getPreviewBinaryMimeType("")).toBe("");
+    expect(s.getPreviewBinaryMimeType("noextension")).toBe("");
+
+    await s.openFile({} as any, "");
+    expect(s.file?.name).toBe("");
+  });
 });

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/subsystems/mcp/webmcp.test.ts

@@ -817,4 +817,259 @@ describe("webmcp integration", () => {
       errorSpy.mockRestore();
     });
   });
+
+  describe("WebMCP lifecycle events (PR #245 / Chrome 156+)", () => {
+    let originalWindowOntoolactivated: any;
+    let originalWindowOntoolcancel: any;
+
+    beforeEach(() => {
+      originalWindowOntoolactivated = (globalThis as any).window
+        ?.ontoolactivated;
+      originalWindowOntoolcancel = (globalThis as any).window?.ontoolcancel;
+      if (typeof window !== "undefined") {
+        delete (window as any).ontoolactivated;
+        delete (window as any).ontoolcancel;
+      }
+    });
+
+    afterEach(() => {
+      if (typeof window !== "undefined") {
+        if (originalWindowOntoolactivated !== undefined) {
+          (window as any).ontoolactivated = originalWindowOntoolactivated;
+        } else {
+          delete (window as any).ontoolactivated;
+        }
+        if (originalWindowOntoolcancel !== undefined) {
+          (window as any).ontoolcancel = originalWindowOntoolcancel;
+        } else {
+          delete (window as any).ontoolcancel;
+        }
+      }
+    });
+
+    describe("getWebMcpEventTarget", () => {
+      it("resolves to document.modelContext when ontoolactivated is in document.modelContext (Chrome 156+ / PR #245)", async () => {
+        const { getWebMcpEventTarget } = await import("./webmcp.js");
+
+        const mockTarget = new EventTarget();
+        (mockTarget as any).ontoolactivated = null;
+        (mockTarget as any).ontoolcancel = null;
+
+        Object.defineProperty((globalThis as any).document, "modelContext", {
+          configurable: true,
+          value: mockTarget,
+        });
+
+        // Also define ontoolactivated on window to ensure modelContext takes precedence
+        if (typeof window !== "undefined") {
+          (window as any).ontoolactivated = null;
+        }
+
+        expect(getWebMcpEventTarget("toolactivated")).toBe(mockTarget);
+        expect(getWebMcpEventTarget("toolcancel")).toBe(mockTarget);
+      });
+
+      it("falls back to window when ontoolactivated is only present on window (legacy Chrome < 156)", async () => {
+        const { getWebMcpEventTarget } = await import("./webmcp.js");
+
+        const mockModelContext = {
+          registerTool: jest.fn(),
+          // No ontoolactivated or ontoolcancel
+        };
+
+        Object.defineProperty((globalThis as any).document, "modelContext", {
+          configurable: true,
+          value: mockModelContext,
+        });
+
+        if (typeof window !== "undefined") {
+          (window as any).ontoolactivated = null;
+          (window as any).ontoolcancel = null;
+        }
+
+        expect(getWebMcpEventTarget("toolactivated")).toBe(window);
+        expect(getWebMcpEventTarget("toolcancel")).toBe(window);
+      });
+
+      it("resolves to navigator.modelContext if document.modelContext is absent (Chrome < 152)", async () => {
+        const { getWebMcpEventTarget } = await import("./webmcp.js");
+
+        delete ((globalThis as any).document as any).modelContext;
+
+        const navTarget = new EventTarget();
+        (navTarget as any).ontoolactivated = null;
+
+        Object.defineProperty((globalThis as any).navigator, "modelContext", {
+          configurable: true,
+          value: navTarget,
+        });
+
+        expect(getWebMcpEventTarget("toolactivated")).toBe(navTarget);
+
+        delete ((globalThis as any).navigator as any).modelContext;
+      });
+
+      it("prefers modelContext when neither target has on{type} property but modelContext is an EventTarget", async () => {
+        const { getWebMcpEventTarget } = await import("./webmcp.js");
+
+        const mockTarget = new EventTarget();
+        Object.defineProperty((globalThis as any).document, "modelContext", {
+          configurable: true,
+          value: mockTarget,
+        });
+
+        expect(getWebMcpEventTarget("toolactivated")).toBe(mockTarget);
+        expect(getWebMcpEventTarget()).toBe(mockTarget);
+      });
+
+      it("falls back to window if modelContext lacks addEventListener", async () => {
+        const { getWebMcpEventTarget } = await import("./webmcp.js");
+
+        Object.defineProperty((globalThis as any).document, "modelContext", {
+          configurable: true,
+          value: {
+            // Not an EventTarget
+            registerTool: jest.fn(),
+          },
+        });
+
+        expect(getWebMcpEventTarget("toolactivated")).toBe(window);
+      });
+    });
+
+    describe("addWebMcpEventListener and convenience helpers", () => {
+      it("listens to toolactivated on document.modelContext in Chrome 156+", async () => {
+        const { addWebMcpEventListener } = await import("./webmcp.js");
+
+        const mockTarget = new EventTarget();
+        (mockTarget as any).ontoolactivated = null;
+
+        Object.defineProperty((globalThis as any).document, "modelContext", {
+          configurable: true,
+          value: mockTarget,
+        });
+
+        const listener = jest.fn();
+        const unsubscribe = addWebMcpEventListener("toolactivated", listener);
+
+        const event = new CustomEvent("toolactivated");
+        (event as any).toolName = "read_file";
+        mockTarget.dispatchEvent(event);
+
+        expect(listener).toHaveBeenCalledTimes(1);
+        expect(listener).toHaveBeenCalledWith(
+          expect.objectContaining({ toolName: "read_file" }),
+        );
+
+        // Unsubscribe should remove the listener
+        unsubscribe();
+        mockTarget.dispatchEvent(event);
+        expect(listener).toHaveBeenCalledTimes(1);
+      });
+
+      it("normalizes toolName from detail.toolName if event.toolName is not directly set", async () => {
+        const { onWebMcpToolActivated } = await import("./webmcp.js");
+
+        const mockTarget = new EventTarget();
+        (mockTarget as any).ontoolactivated = null;
+
+        Object.defineProperty((globalThis as any).document, "modelContext", {
+          configurable: true,
+          value: mockTarget,
+        });
+
+        const listener = jest.fn();
+        const unsubscribe = onWebMcpToolActivated(listener);
+
+        const legacyEvent = new CustomEvent("toolactivated", {
+          detail: { toolName: "bash" },
+        });
+        mockTarget.dispatchEvent(legacyEvent);
+
+        expect(listener).toHaveBeenCalledTimes(1);
+        expect(listener).toHaveBeenCalledWith(
+          expect.objectContaining({ toolName: "bash" }),
+        );
+
+        unsubscribe();
+      });
+
+      it("listens to toolcancel on window in legacy Chrome < 156", async () => {
+        const { onWebMcpToolCancel } = await import("./webmcp.js");
+
+        delete ((globalThis as any).document as any).modelContext;
+        (window as any).ontoolcancel = null;
+
+        const listener = jest.fn();
+        const unsubscribe = onWebMcpToolCancel(listener);
+
+        const event = new CustomEvent("toolcancel");
+        (event as any).toolName = "fetch_url";
+        window.dispatchEvent(event);
+
+        expect(listener).toHaveBeenCalledTimes(1);
+        expect(listener).toHaveBeenCalledWith(
+          expect.objectContaining({ toolName: "fetch_url" }),
+        );
+
+        unsubscribe();
+        window.dispatchEvent(event);
+        expect(listener).toHaveBeenCalledTimes(1);
+      });
+
+      it("automatically cleans up when AbortSignal is aborted", async () => {
+        const { onWebMcpToolActivated } = await import("./webmcp.js");
+
+        const mockTarget = new EventTarget();
+        (mockTarget as any).ontoolactivated = null;
+
+        Object.defineProperty((globalThis as any).document, "modelContext", {
+          configurable: true,
+          value: mockTarget,
+        });
+
+        const controller = new AbortController();
+        const listener = jest.fn();
+        onWebMcpToolActivated(listener, { signal: controller.signal });
+
+        controller.abort();
+
+        const event = new CustomEvent("toolactivated");
+        (event as any).toolName = "write_file";
+        mockTarget.dispatchEvent(event);
+
+        expect(listener).not.toHaveBeenCalled();
+      });
+
+      it("supports listenBoth: true and deduplicates events within same tick", async () => {
+        const { addWebMcpEventListener } = await import("./webmcp.js");
+
+        const mockTarget = new EventTarget();
+        (mockTarget as any).ontoolactivated = null;
+
+        Object.defineProperty((globalThis as any).document, "modelContext", {
+          configurable: true,
+          value: mockTarget,
+        });
+
+        const listener = jest.fn();
+        const unsubscribe = addWebMcpEventListener("toolactivated", listener, {
+          listenBoth: true,
+        });
+
+        const evt1 = new CustomEvent("toolactivated");
+        (evt1 as any).toolName = "list_files";
+        const evt2 = new CustomEvent("toolactivated");
+        (evt2 as any).toolName = "list_files";
+
+        // Dispatch on both targets
+        mockTarget.dispatchEvent(evt1);
+        window.dispatchEvent(evt2);
+
+        expect(listener).toHaveBeenCalledTimes(1);
+
+        unsubscribe();
+      });
+    });
+  });
 });