shadow-claw 1.52.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/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();
+    }
+  });
+});

package/src/server/routes/gemini.test.ts

@@ -339,4 +339,248 @@ describe("Gemini proxy", () => {
       }),
     );
   });
+
+  it("returns 401 when API key is missing", async () => {
+    const oldKey = process.env.GEMINI_API_KEY;
+    delete process.env.GEMINI_API_KEY;
+    try {
+      const handler = routes.get("POST /gemini-proxy/chat/completions");
+      const req = { body: {}, headers: {} } as any;
+      const res = {
+        status: jest.fn().mockReturnThis(),
+        json: jest.fn(),
+      } as any;
+
+      await handler(req, res);
+      expect(res.status).toHaveBeenCalledWith(401);
+
+      const modelsHandler = routes.get("GET /gemini-proxy/models");
+      await modelsHandler(req, res);
+      expect(res.status).toHaveBeenCalledWith(401);
+    } finally {
+      if (oldKey) process.env.GEMINI_API_KEY = oldKey;
+    }
+  });
+
+  it("handles multimodal content and tools in non-streaming completions", async () => {
+    const handler = routes.get("POST /gemini-proxy/chat/completions");
+
+    mockGenerateContent.mockResolvedValue({
+      get text() {
+        return "";
+      },
+      candidates: [
+        {
+          content: {
+            parts: [
+              {
+                functionCall: {
+                  name: "fetch_url",
+                  args: { url: "https://example.com" },
+                },
+              },
+            ],
+          },
+        },
+      ],
+      usageMetadata: {
+        promptTokenCount: 5,
+        candidatesTokenCount: 10,
+        totalTokenCount: 15,
+      },
+    });
+
+    const req = {
+      body: {
+        model: "gemini-2.0-flash",
+        messages: [
+          { role: "system", content: "You are helpful" },
+          {
+            role: "user",
+            content: [
+              { type: "text", text: "Look at this" },
+              {
+                type: "image_url",
+                image_url: { url: "data:image/png;base64,iVBORw0KGgo=" },
+              },
+              { type: "tool_use", name: "calculator", input: { a: 1 } },
+              { type: "tool_result", name: "calculator", content: "2" },
+              { type: "unknown" },
+            ],
+          },
+          { role: "assistant", content: "working" },
+          { role: "tool", content: "result" },
+        ],
+        tools: [
+          {
+            function: {
+              name: "fetch_url",
+              description: "Fetch URL",
+              parameters: { type: "object" },
+            },
+          },
+        ],
+      },
+      headers: { "x-goog-api-key": "test-key" },
+    } as any;
+
+    const res = {
+      status: jest.fn().mockReturnThis(),
+      json: jest.fn(),
+    } as any;
+
+    await handler(req, res);
+
+    expect(res.json).toHaveBeenCalledWith(
+      expect.objectContaining({
+        choices: [
+          expect.objectContaining({
+            finish_reason: "tool_calls",
+            message: expect.objectContaining({
+              role: "assistant",
+              tool_calls: [
+                expect.objectContaining({
+                  function: expect.objectContaining({
+                    name: "fetch_url",
+                  }),
+                }),
+              ],
+            }),
+          }),
+        ],
+      }),
+    );
+  });
+
+  it("handles streaming chunks with reasoning and function calls", async () => {
+    const handler = routes.get("POST /gemini-proxy/chat/completions");
+
+    const asyncIterable = (async function* () {
+      yield {
+        text: "Thinking...",
+        candidates: [
+          {
+            content: {
+              parts: [
+                { thought: true, text: "Let me check..." },
+                {
+                  functionCall: {
+                    name: "test_tool",
+                    args: { x: 1 },
+                  },
+                },
+              ],
+            },
+          },
+        ],
+      };
+      yield {
+        text: "Done!",
+      };
+    })();
+
+    mockGenerateContentStream.mockResolvedValue(asyncIterable);
+
+    const written: string[] = [];
+    const req = {
+      body: {
+        stream: true,
+        messages: [{ role: "user", content: "run test" }],
+      },
+      headers: { "x-goog-api-key": "test-key" },
+    } as any;
+
+    const res = {
+      setHeader: jest.fn(),
+      flushHeaders: jest.fn(),
+      write: jest.fn((chunk: string) => written.push(chunk)),
+      end: jest.fn(),
+    } as any;
+
+    await handler(req, res);
+
+    expect(res.setHeader).toHaveBeenCalledWith(
+      "Content-Type",
+      "text/event-stream",
+    );
+    expect(res.end).toHaveBeenCalled();
+    expect(written.length).toBeGreaterThan(0);
+  });
+
+  it("handles errors during completion with JSON error payload", async () => {
+    const handler = routes.get("POST /gemini-proxy/chat/completions");
+
+    mockGenerateContent.mockRejectedValue(
+      new Error(
+        JSON.stringify({ error: { code: 429, message: "Resource exhausted" } }),
+      ),
+    );
+
+    const req = {
+      body: { messages: [{ role: "user", content: "hi" }] },
+      headers: { "x-goog-api-key": "test-key" },
+    } as any;
+
+    const res = {
+      headersSent: false,
+      status: jest.fn().mockReturnThis(),
+      json: jest.fn(),
+    } as any;
+
+    await handler(req, res);
+    expect(res.status).toHaveBeenCalledWith(429);
+  });
+
+  it("provides fallback models when listing fails during iteration or yields empty list", async () => {
+    const handler = routes.get("GET /gemini-proxy/models");
+
+    const throwingIterable = (async function* () {
+      throw new Error("Quota exceeded during iteration");
+    })();
+    mockListModels.mockResolvedValue(throwingIterable);
+
+    const req = {
+      headers: { "x-goog-api-key": "test-key" },
+    } as any;
+
+    const res = {
+      status: jest.fn().mockReturnThis(),
+      json: jest.fn(),
+    } as any;
+
+    await handler(req, res);
+
+    expect(res.json).toHaveBeenCalledWith(
+      expect.objectContaining({
+        data: expect.arrayContaining([
+          expect.objectContaining({ id: "gemini-2.0-flash" }),
+          expect.objectContaining({ id: "gemini-1.5-flash" }),
+        ]),
+      }),
+    );
+  });
+
+  it("returns 502 when models.list() itself throws", async () => {
+    const handler = routes.get("GET /gemini-proxy/models");
+
+    mockListModels.mockRejectedValue(new Error("Network failure"));
+
+    const req = {
+      headers: { "x-goog-api-key": "test-key" },
+    } as any;
+
+    const res = {
+      status: jest.fn().mockReturnThis(),
+      json: jest.fn(),
+    } as any;
+
+    await handler(req, res);
+
+    expect(res.status).toHaveBeenCalledWith(502);
+    expect(res.json).toHaveBeenCalledWith(
+      expect.objectContaining({
+        error: expect.stringContaining("Network failure"),
+      }),
+    );
+  });
 });