shadow-claw 1.51.0 → 1.52.1

package/src/components/shadow-claw-toast/shadow-claw-toast.test.ts

@@ -76,4 +76,83 @@ describe("shadow-claw-toast", () => {
     await new Promise((r) => setTimeout(r, 50));
     expect(onClick).toHaveBeenCalled();
   });
+
+  it("dismisses toast on Escape key press", async () => {
+    toastStore.show("Dismiss on esc", { type: "info" });
+    await el.render();
+
+    const toastEl = el.shadowRoot?.querySelector(".toast");
+    expect(toastEl).not.toBeNull();
+
+    const escEvent = new KeyboardEvent("keydown", {
+      key: "Escape",
+      bubbles: true,
+      cancelable: true,
+    });
+    toastEl?.dispatchEvent(escEvent);
+
+    await new Promise((r) => setTimeout(r, 250));
+    expect(toastStore.toasts.length).toBe(0);
+  });
+
+  it("ignores non-Escape keydown or invalid targets", async () => {
+    toastStore.show("Stay open", { type: "info" });
+    await el.render();
+
+    const enterEvent = new KeyboardEvent("keydown", {
+      key: "Enter",
+      bubbles: true,
+      cancelable: true,
+    });
+    el.shadowRoot?.dispatchEvent(enterEvent);
+
+    // Event on non-toast element
+    const escOnRoot = new KeyboardEvent("keydown", {
+      key: "Escape",
+      bubbles: false,
+    });
+    el.shadowRoot?.dispatchEvent(escOnRoot);
+
+    expect(toastStore.toasts.length).toBe(1);
+  });
+
+  it("pauses and resumes on mouseenter / mouseleave", async () => {
+    const pauseSpy = jest.spyOn(toastStore, "pause");
+    const resumeSpy = jest.spyOn(toastStore, "resume");
+
+    const id = toastStore.show("Hover me", { type: "warning" });
+    await el.render();
+
+    const toastEl = el.shadowRoot?.querySelector(".toast");
+    toastEl?.dispatchEvent(new MouseEvent("mouseenter"));
+    expect(pauseSpy).toHaveBeenCalledWith(id);
+
+    toastEl?.dispatchEvent(new MouseEvent("mouseleave"));
+    expect(resumeSpy).toHaveBeenCalledWith(id);
+  });
+
+  it("renders appropriate icons for all toast types", () => {
+    expect(el.iconForType("success")).toBe("✓");
+    expect(el.iconForType("error")).toBe("!");
+    expect(el.iconForType("warning")).toBe("⚠");
+    expect(el.iconForType("info")).toBe("i");
+  });
+
+  it("delegates show() to toastStore.show", () => {
+    const id = el.show("Via helper", { type: "success" });
+    expect(id).toBeDefined();
+    expect(toastStore.toasts.some((t) => t.message === "Via helper")).toBe(
+      true,
+    );
+  });
+
+  it("returns early if toast is already exiting", async () => {
+    const id = toastStore.show("Exiting toast", { type: "info" });
+    await el.render();
+
+    el.exitingToasts.add(id);
+    await el.dismissWithAnimation(id);
+    // Should not re-add or throw
+    expect(el.exitingToasts.has(id)).toBe(true);
+  });
 });

package/src/components/shadow-claw-tools/shadow-claw-tools.test.ts

@@ -120,7 +120,8 @@ const { ShadowClawTools } = await import("./shadow-claw-tools.js");
 const { toolsStore } = (await import("../../stores/tools.js")) as any;
 const { orchestratorStore } =
   (await import("../../stores/orchestrator.js")) as any;
-const { showSuccess } = (await import("../../ui/toast.js")) as any;
+const { showSuccess, showInfo, showError } =
+  (await import("../../ui/toast.js")) as any;
 
 describe("shadow-claw-tools", () => {
   beforeEach(() => {
@@ -636,4 +637,231 @@ describe("shadow-claw-tools", () => {
 
     document.body.removeChild(el);
   });
+
+  it("handles back button, add button, restore button, and select all/none", async () => {
+    const el = new ShadowClawTools();
+    document.body.appendChild(el);
+    await new Promise((r) => setTimeout(r, 50));
+    await el.render();
+
+    const root = el.shadowRoot!;
+
+    // 1. Back button
+    let backNavigated = false;
+    el.addEventListener("navigate-back", () => {
+      backNavigated = true;
+    });
+    const backBtn = root.querySelector(".tools__back-btn") as HTMLButtonElement;
+    backBtn?.dispatchEvent(new Event("click"));
+    expect(backNavigated).toBe(true);
+
+    // 2. Add button
+    const dialog = root.querySelector("dialog") as HTMLDialogElement;
+    dialog.showModal = jest.fn();
+    const addBtn = root.querySelector(".tools__add-btn") as HTMLButtonElement;
+    addBtn?.dispatchEvent(new Event("click"));
+    expect(dialog.showModal).toHaveBeenCalled();
+
+    // 3. Restore button
+    const restoreBtn = root.querySelector(
+      ".tools__restore-btn",
+    ) as HTMLButtonElement;
+    const restoreInput = root.querySelector(
+      ".tools__hidden-restore",
+    ) as HTMLInputElement;
+    const clickSpy = jest
+      .spyOn(restoreInput, "click")
+      .mockImplementation(() => {});
+    restoreBtn?.dispatchEvent(new Event("click"));
+    expect(clickSpy).toHaveBeenCalled();
+    clickSpy.mockRestore();
+
+    // 4. Select all / none
+    const selectAllBtn = root.querySelector(
+      ".tools__select-all-btn",
+    ) as HTMLButtonElement;
+    selectAllBtn?.dispatchEvent(new Event("click"));
+    expect(toolsStore.setAllEnabled).toHaveBeenCalled();
+    expect(showInfo).toHaveBeenCalledWith("All tools enabled");
+
+    const selectNoneBtn = root.querySelector(
+      ".tools__select-none-btn",
+    ) as HTMLButtonElement;
+    selectNoneBtn?.dispatchEvent(new Event("click"));
+    expect(showInfo).toHaveBeenCalledWith("All tools disabled");
+
+    document.body.removeChild(el);
+  });
+
+  it("handles WebMCP, internet access, and Web Search toggles", async () => {
+    const el = new ShadowClawTools();
+    document.body.appendChild(el);
+    await new Promise((r) => setTimeout(r, 50));
+    await el.render();
+
+    const root = el.shadowRoot!;
+
+    // 1. WebMCP toggle
+    const webMcpToggle = root.querySelector(
+      ".tools__webmcp-toggle",
+    ) as HTMLInputElement;
+    if (webMcpToggle) {
+      webMcpToggle.checked = true;
+      webMcpToggle.dispatchEvent(new Event("change"));
+      await new Promise((r) => setTimeout(r, 20));
+      expect(showInfo).toHaveBeenCalledWith("WebMCP tool registration enabled");
+
+      // Without orchestrator
+      el.orchestrator = null;
+      (orchestratorStore as any).orchestrator = null;
+      webMcpToggle.checked = true;
+      webMcpToggle.dispatchEvent(new Event("change"));
+      await new Promise((r) => setTimeout(r, 20));
+      expect(showError).toHaveBeenCalledWith("Orchestrator is not ready");
+
+      // Restore orchestrator
+      (orchestratorStore as any).orchestrator = {
+        getWebMcpToolsEnabled: jest.fn(() => true),
+        getWebMcpMode: jest.fn(() => "native"),
+        setWebMcpToolsEnabled: jest.fn(),
+        setWebMcpMode: jest.fn(),
+      };
+    }
+
+    // 2. Internet access toggle
+    const internetToggle = root.querySelector(
+      ".tools__internet-access-toggle",
+    ) as HTMLInputElement;
+    if (internetToggle) {
+      internetToggle.checked = true;
+      internetToggle.dispatchEvent(new Event("change"));
+      await new Promise((r) => setTimeout(r, 20));
+      expect(orchestratorStore.setVMBashFullInternetAccess).toHaveBeenCalled();
+      expect(showInfo).toHaveBeenCalledWith(
+        "Full internet access enabled for Bash and JavaScript tools",
+      );
+    }
+
+    // 3. Web Search proxy toggle
+    const proxyToggle = root.querySelector(
+      ".tools__websearch-proxy-toggle",
+    ) as HTMLInputElement;
+    if (proxyToggle) {
+      proxyToggle.checked = true;
+      proxyToggle.dispatchEvent(new Event("change"));
+      await new Promise((r) => setTimeout(r, 20));
+      expect(toolsStore.setWebSearchUseProxy).toHaveBeenCalled();
+      expect(showInfo).toHaveBeenCalledWith("Web Search local proxy enabled");
+    }
+
+    document.body.removeChild(el);
+  });
+
+  it("handles prompt override save, clear, and dialog controls", async () => {
+    const el = new ShadowClawTools();
+    document.body.appendChild(el);
+    await new Promise((r) => setTimeout(r, 50));
+    await el.render();
+
+    const root = el.shadowRoot!;
+
+    // 1. Save and Clear prompt
+    const textarea = root.querySelector(
+      ".tools__prompt-area",
+    ) as HTMLTextAreaElement;
+    if (textarea) textarea.value = "Custom system instructions";
+
+    const savePromptBtn = root.querySelector(
+      ".tools__save-prompt-btn",
+    ) as HTMLButtonElement;
+    savePromptBtn?.dispatchEvent(new Event("click"));
+    expect(toolsStore.setSystemPromptOverride).toHaveBeenCalled();
+    expect(showSuccess).toHaveBeenCalledWith("System prompt override saved");
+
+    const clearPromptBtn = root.querySelector(
+      ".tools__clear-prompt-btn",
+    ) as HTMLButtonElement;
+    clearPromptBtn?.dispatchEvent(new Event("click"));
+    expect(showSuccess).toHaveBeenCalledWith("System prompt override cleared");
+
+    // 2. Dialog controls (close, cancel, backdrop)
+    const dialog = root.querySelector(".tools__dialog") as HTMLDialogElement;
+    if (dialog) {
+      dialog.close = jest.fn();
+      const closeBtn = dialog.querySelector(
+        ".tools__dialog-close",
+      ) as HTMLButtonElement;
+      closeBtn?.dispatchEvent(new Event("click"));
+      expect(dialog.close).toHaveBeenCalledTimes(1);
+
+      const cancelBtn = dialog.querySelector(
+        ".tools__btn-cancel",
+      ) as HTMLButtonElement;
+      cancelBtn?.dispatchEvent(new Event("click"));
+      expect(dialog.close).toHaveBeenCalledTimes(2);
+
+      Object.defineProperty(dialog, "target", { value: dialog });
+      dialog.dispatchEvent(new MouseEvent("click", { bubbles: true }));
+      expect(dialog.close).toHaveBeenCalledTimes(3);
+    }
+
+    // 3. Clone dialog controls
+    const cloneDialog = root.querySelector(
+      ".tools__clone-dialog",
+    ) as HTMLDialogElement;
+    if (cloneDialog) {
+      cloneDialog.close = jest.fn();
+      const cloneCloseBtn = root.querySelector(
+        ".tools__clone-dialog-close",
+      ) as HTMLButtonElement;
+      cloneCloseBtn?.dispatchEvent(new Event("click"));
+      expect(cloneDialog.close).toHaveBeenCalledTimes(1);
+
+      const cloneCancelBtn = root.querySelector(
+        ".tools__clone-cancel-btn",
+      ) as HTMLButtonElement;
+      cloneCancelBtn?.dispatchEvent(new Event("click"));
+      expect(cloneDialog.close).toHaveBeenCalledTimes(2);
+    }
+
+    // 4. Profile dialog controls and Profile select
+    const profileDialog = root.querySelector(
+      ".tools__profile-dialog",
+    ) as HTMLDialogElement;
+    if (profileDialog) {
+      profileDialog.close = jest.fn();
+      const profileCloseBtn = root.querySelector(
+        ".tools__profile-dialog-close",
+      ) as HTMLButtonElement;
+      profileCloseBtn?.dispatchEvent(new Event("click"));
+      expect(profileDialog.close).toHaveBeenCalledTimes(1);
+
+      const profileCancelBtn = root.querySelector(
+        ".tools__profile-cancel-btn",
+      ) as HTMLButtonElement;
+      profileCancelBtn?.dispatchEvent(new Event("click"));
+      expect(profileDialog.close).toHaveBeenCalledTimes(2);
+
+      Object.defineProperty(profileDialog, "target", { value: profileDialog });
+      profileDialog.dispatchEvent(new MouseEvent("click", { bubbles: true }));
+      expect(profileDialog.close).toHaveBeenCalledTimes(3);
+    }
+
+    const profileSelect = root.querySelector(
+      ".tools__profile-select",
+    ) as HTMLSelectElement;
+    if (profileSelect) {
+      profileSelect.value = "custom_profile";
+      profileSelect.dispatchEvent(new Event("change"));
+      expect(toolsStore.activateProfile).toHaveBeenCalled();
+      expect(showInfo).toHaveBeenCalledWith("Profile activated");
+
+      profileSelect.value = "";
+      profileSelect.dispatchEvent(new Event("change"));
+      expect(toolsStore.deactivateProfile).toHaveBeenCalled();
+      expect(showInfo).toHaveBeenCalledWith("Profile deactivated");
+    }
+
+    document.body.removeChild(el);
+  });
 });

package/src/config/config.test.ts

@@ -67,7 +67,7 @@ describe("config.js", () => {
     });
 
     it("should have valid DEFAULT_PROVIDER", () => {
-      expect(DEFAULT_PROVIDER).toBe("prompt_api");
+      expect(DEFAULT_PROVIDER).toBe("transformers_js_browser");
     });
 
     it("should have valid SCHEDULER_INTERVAL", () => {
@@ -561,10 +561,10 @@ describe("config.js", () => {
       expect(provider.id).toBe(DEFAULT_PROVIDER);
     });
 
-    it("default provider should be valid prompt_api config", () => {
+    it("default provider should be valid transformers_js_browser config", () => {
       const provider = getDefaultProvider();
-      expect(provider.name).toBe("Prompt API (Browser)");
-      expect(provider.format).toBe("prompt_api");
+      expect(provider.name).toBe("Transformers.js (Browser)");
+      expect(provider.format).toBe("transformers_js");
     });
   });
 

package/src/config/config.ts

@@ -191,7 +191,7 @@ export function getModelMaxTokens(modelId: string): number {
 }
 
 /** Default provider */
-export const DEFAULT_PROVIDER = "prompt_api";
+export const DEFAULT_PROVIDER = "transformers_js_browser";
 
 /** Task scheduler check interval (ms) */
 export const SCHEDULER_INTERVAL = 60_000;
@@ -1129,6 +1129,7 @@ export const CONFIG_KEYS = {
   PROMPT_API_DTYPE_STRATEGY: "prompt_api_dtype_strategy",
   PROMPT_API_FALLBACK_MODEL: "prompt_api_fallback_model",
   PROMPT_API_ONBOARDING_SEEN: "prompt_api_onboarding_seen",
+  TRANSFORMERS_JS_ONBOARDING_SEEN: "transformers_js_onboarding_seen",
   PEERJS_MY_ALIAS: "peerjs_my_alias",
   PEERJS_MY_PEER_ID: "peerjs_my_peer_id",
   PEERJS_PEER_ALIASES: "peerjs_peer_aliases",

package/src/core/orchestrator/orchestrator.test.ts

@@ -1554,7 +1554,7 @@ describe("Orchestrator", () => {
         trustedPeerIds: [],
       });
 
-      expect(o.provider).toBe("prompt_api");
+      expect(o.provider).toBe("transformers_js_browser");
       expect(o.proxyUrl).toBe("/proxy");
 
       expect(o.rateLimitAutoAdapt).toBe(true);
@@ -2424,6 +2424,7 @@ describe("Orchestrator", () => {
 
       // Active request restarted
       o.state = "thinking";
+      o.provider = "prompt_api";
       o.inFlightTriggerByGroup.set("g-restart", "Original prompt");
       o.agentWorker = {
         postMessage: jest.fn(),

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

@@ -291,11 +291,12 @@ export async function initProviderAndModel(
     getConfig(db, CONFIG_KEYS.RATE_LIMIT_AUTO_ADAPT),
   ]);
 
-  const matchedProvider = storedProvider
-    ? getProvider(storedProvider)
+  const effectiveProvider = storedProvider || orchestrator.provider;
+  const matchedProvider = effectiveProvider
+    ? getProvider(effectiveProvider)
     : undefined;
-  if (storedProvider && matchedProvider) {
-    orchestrator.provider = storedProvider;
+  if (matchedProvider) {
+    orchestrator.provider = effectiveProvider;
     orchestrator.providerConfig = matchedProvider;
   }
 

package/src/server/logger.test.ts

@@ -0,0 +1,57 @@
+import { jest } from "@jest/globals";
+import { createLogger } from "./logger.js";
+
+describe("createLogger", () => {
+  let logSpy: any;
+  let errorSpy: any;
+
+  beforeEach(() => {
+    logSpy = jest.spyOn(console, "log").mockImplementation(() => {});
+    errorSpy = jest.spyOn(console, "error").mockImplementation(() => {});
+  });
+
+  afterEach(() => {
+    logSpy.mockRestore();
+    errorSpy.mockRestore();
+  });
+
+  it("logs DEFAULT level messages in non-verbose mode", () => {
+    const logger = createLogger(false);
+    logger.log("DEFAULT", "standard log");
+    expect(logSpy).toHaveBeenCalledWith(
+      expect.stringContaining("[LOG]"),
+      "standard log",
+    );
+
+    logger.log("VERBOSE", "hidden log");
+    expect(logSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("logs VERBOSE level messages when verbose is true", () => {
+    const logger = createLogger(true);
+    logger.log("VERBOSE", "verbose log");
+    expect(logSpy).toHaveBeenCalledWith(
+      expect.stringContaining("[VERBOSE]"),
+      "verbose log",
+    );
+  });
+
+  it("logs errors in DEFAULT and VERBOSE levels", () => {
+    const logger = createLogger(false);
+    logger.error("DEFAULT", "standard error");
+    expect(errorSpy).toHaveBeenCalledWith(
+      expect.stringContaining("[ERROR]"),
+      "standard error",
+    );
+
+    logger.error("VERBOSE", "hidden error");
+    expect(errorSpy).toHaveBeenCalledTimes(1);
+
+    const verboseLogger = createLogger(true);
+    verboseLogger.error("VERBOSE", "verbose error");
+    expect(errorSpy).toHaveBeenCalledWith(
+      expect.stringContaining("[VERBOSE ERROR]"),
+      "verbose error",
+    );
+  });
+});

package/src/server/peer.test.ts

@@ -0,0 +1,47 @@
+import { jest } from "@jest/globals";
+import { EventEmitter } from "node:events";
+
+describe("attachPeerServer", () => {
+  it("attaches ExpressPeerServer and listens to connection and disconnect events", async () => {
+    const mockPeerServer: any = new EventEmitter();
+    const expressPeerServerMock = jest.fn(() => mockPeerServer);
+
+    jest.unstable_mockModule("peer", () => ({
+      ExpressPeerServer: expressPeerServerMock,
+    }));
+
+    const { attachPeerServer } = await import("./peer.js");
+
+    const mockHttpServer: any = {};
+    const mockApp: any = {
+      use: jest.fn(),
+    };
+
+    const logSpy = jest.spyOn(console, "log").mockImplementation(() => {});
+
+    try {
+      attachPeerServer(mockHttpServer, mockApp);
+
+      expect(expressPeerServerMock).toHaveBeenCalledWith(mockHttpServer, {
+        path: "/",
+        allow_discovery: false,
+      });
+      expect(mockApp.use).toHaveBeenCalledWith(mockPeerServer);
+
+      const mockClient = { getId: () => "peer-client-123" };
+      mockPeerServer.emit("connection", mockClient);
+      expect(logSpy).toHaveBeenCalledWith(
+        expect.stringContaining("PeerJS: client connected — peer-client-123"),
+      );
+
+      mockPeerServer.emit("disconnect", mockClient);
+      expect(logSpy).toHaveBeenCalledWith(
+        expect.stringContaining(
+          "PeerJS: client disconnected — peer-client-123",
+        ),
+      );
+    } finally {
+      logSpy.mockRestore();
+    }
+  });
+});