shadow-claw 1.40.1 → 1.41.1

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

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/dist/cli/chunk-00GAzVPl2.js

@@ -1 +0,0 @@
-import{t as e}from"./chunk-WMPAfIvV2.js";export{e as fetchDiscoveryManifest};

package/dist/cli/chunk-2hnFoNNC.js

@@ -1 +0,0 @@
-import{a as e}from"./chunk-BXFHFbEd.js";export{e as getMemoryOpfsRoot};

package/dist/cli/chunk-BKQL4nzF2.js

@@ -1 +0,0 @@
-import{r as e}from"./chunk-DIbSoQmd2.js";export{e as orchestratorStore};

package/dist/cli/chunk-BQ4K3fqj2.js

@@ -1 +0,0 @@
-import{r as e}from"./chunk-BUhqHeEA2.js";export{e as orchestratorStore};

package/dist/cli/chunk-BVCGo6uf2.js

@@ -1 +0,0 @@
-import{t as e}from"./chunk-3gRhOmGo2.js";export{e as importRemoteArtifacts};