shadow-claw 1.23.4 → 1.24.0

package/src/stores/toast.test.ts

@@ -67,4 +67,54 @@ describe("ToastStore", () => {
 
     expect(store.toasts).toHaveLength(0);
   });
+
+  test("clear removes all toasts and timers", () => {
+    const store = new ToastStore();
+    store.show("toast 1");
+    store.show("toast 2");
+    expect(store.toasts).toHaveLength(2);
+
+    store.clear();
+    expect(store.toasts).toHaveLength(0);
+  });
+
+  test("caps visible toasts at MAX_VISIBLE_TOASTS", () => {
+    const store = new ToastStore();
+    for (let i = 1; i <= 7; i++) {
+      store.show(`toast ${i}`);
+    }
+
+    expect(store.toasts).toHaveLength(5);
+    expect(store.toasts[0].message).toBe("toast 3");
+    expect(store.toasts[4].message).toBe("toast 7");
+  });
+
+  test("executes action via runAction", async () => {
+    const store = new ToastStore();
+    const actionSpy: any = jest.fn();
+    const id = store.show("with action", {
+      action: { label: "Retry", onClick: actionSpy },
+    });
+
+    await store.runAction(id);
+    expect(actionSpy).toHaveBeenCalledTimes(1);
+
+    // No-op for non-existent or action-less toast
+    await store.runAction(999);
+  });
+
+  test("resolvers handle invalid inputs gracefully", () => {
+    const store = new ToastStore();
+    expect(store.resolveType("invalid" as any)).toBe("info");
+    expect(store.resolveType("error")).toBe("error");
+
+    expect(store.resolveDuration(-10)).toBe(4000);
+    expect(store.resolveDuration(NaN)).toBe(4000);
+    expect(store.resolveDuration(2500)).toBe(2500);
+
+    expect(
+      store.resolveAction({ label: "", onClick: "not-fn" } as any),
+    ).toBeUndefined();
+    expect(store.resolveAction(undefined)).toBeUndefined();
+  });
 });

package/src/stores/tools.test.ts

@@ -2,8 +2,11 @@ import { jest } from "@jest/globals";
 
 const mockGetConfig = jest.fn();
 const mockSetConfig = jest.fn();
+const mockLoadDeclarativeTools = jest.fn();
+const mockFindDeclarativeTool = jest.fn();
+const mockParseDeclarativeTool = jest.fn();
 
-jest.unstable_mockModule("../db/setConfig.js", () => ({
+jest.unstable_mockModule("../db/getConfig.js", () => ({
   getConfig: mockGetConfig,
 }));
 
@@ -11,20 +14,24 @@ jest.unstable_mockModule("../db/setConfig.js", () => ({
   setConfig: mockSetConfig,
 }));
 
+jest.unstable_mockModule("../subsystems/tools/declarative.js", () => ({
+  loadDeclarativeTools: mockLoadDeclarativeTools,
+  findDeclarativeTool: mockFindDeclarativeTool,
+  parseDeclarativeTool: mockParseDeclarativeTool,
+}));
+
 const { ToolsStore } = await import("./tools.js");
 const { DEFAULT_BUILTIN_PROFILE } =
-  await import("../subsystems/providers/prompt-api-provider.js");
+  await import("../subsystems/tools/builtin-profiles.js");
 
 const db: any = {} as any;
 
 describe("ToolsStore — built-in Nano profile", () => {
-  let store;
+  let store: any;
 
   beforeEach(() => {
     jest.clearAllMocks();
-
     (mockGetConfig as any).mockResolvedValue(undefined);
-
     (mockSetConfig as any).mockResolvedValue(undefined);
     store = new ToolsStore();
   });
@@ -53,22 +60,22 @@ describe("ToolsStore — built-in Nano profile", () => {
 
   it("refuses to delete the built-in profile", async () => {
     await store.deleteProfile(db, DEFAULT_BUILTIN_PROFILE.id);
-    // Should still be in the list
     expect(
-      store.profiles.find((p) => p.id === DEFAULT_BUILTIN_PROFILE.id),
+      store.profiles.find((p: any) => p.id === DEFAULT_BUILTIN_PROFILE.id),
     ).toBeTruthy();
-    // setConfig should NOT have been called
     expect(mockSetConfig).not.toHaveBeenCalled();
   });
 
   it("findProfilesForProvider returns built-in for prompt_api", () => {
     const matches = store.findProfilesForProvider("prompt_api");
-    expect(matches.some((p) => p.id === DEFAULT_BUILTIN_PROFILE.id)).toBe(true);
+    expect(matches.some((p: any) => p.id === DEFAULT_BUILTIN_PROFILE.id)).toBe(
+      true,
+    );
   });
 
   it("does not return built-in for non-matching provider", () => {
     const matches = store.findProfilesForProvider("openai");
-    expect(matches.some((p) => p.id === DEFAULT_BUILTIN_PROFILE.id)).toBe(
+    expect(matches.some((p: any) => p.id === DEFAULT_BUILTIN_PROFILE.id)).toBe(
       false,
     );
   });
@@ -93,6 +100,119 @@ describe("ToolsStore — built-in Nano profile", () => {
   });
 });
 
+describe("ToolsStore — custom tools, cloning, profiles & web search config", () => {
+  let store: any;
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    (mockGetConfig as any).mockResolvedValue(undefined);
+    (mockSetConfig as any).mockResolvedValue(undefined);
+    store = new ToolsStore();
+  });
+
+  it("adds, removes, and clones custom tools", async () => {
+    const customTool = {
+      name: "custom_math",
+      description: "Perform math",
+      input_schema: { type: "object", properties: {} },
+    };
+
+    await store.addCustomTool(db, customTool);
+    expect(store.customTools).toHaveLength(1);
+    expect(store.enabledToolNames.has("custom_math")).toBe(true);
+
+    const cloned = await store.cloneTool(
+      db,
+      "custom_math",
+      "custom_math_v2",
+      "Perform advanced math",
+    );
+    expect(cloned).toBe(true);
+    expect(store.customTools).toHaveLength(2);
+
+    // Cannot clone with existing name
+    const cloneConflict = await store.cloneTool(
+      db,
+      "custom_math",
+      "custom_math_v2",
+    );
+    expect(cloneConflict).toBe(false);
+
+    // Remove custom tool
+    await store.removeCustomTool(db, "custom_math");
+    expect(store.customTools).toHaveLength(1);
+    expect(store.customTools[0].name).toBe("custom_math_v2");
+  });
+
+  it("manages custom tool profiles and updates", async () => {
+    const profile = {
+      id: "p1",
+      name: "Research Profile",
+      enabledToolNames: ["web_search", "read_file"],
+      customTools: [],
+      systemPromptOverride: "You are a researcher",
+    };
+
+    await store.addProfile(db, profile);
+    expect(store.profiles.find((p: any) => p.id === "p1")).toBeTruthy();
+
+    await store.activateProfile(db, "p1");
+    expect(store.activeProfileId).toBe("p1");
+    expect(store.systemPromptOverride).toBe("You are a researcher");
+
+    await store.setSystemPromptOverride(db, "Updated Prompt");
+    expect(store.systemPromptOverride).toBe("Updated Prompt");
+
+    await store.saveToActiveProfile(db);
+    expect(mockSetConfig).toHaveBeenCalled();
+
+    await store.deactivateProfile(db);
+    expect(store.activeProfileId).toBeNull();
+
+    await store.deleteProfile(db, "p1");
+    expect(store.profiles.find((p: any) => p.id === "p1")).toBeFalsy();
+  });
+
+  it("configures web search and search_files options", async () => {
+    await store.setWebSearchUseProxy(db, true);
+    expect(store.webSearchUseProxy).toBe(true);
+
+    await store.setWebSearchProxyUrl(db, "https://proxy.example.com");
+    expect(store.webSearchProxyUrl).toBe("https://proxy.example.com");
+
+    await store.setWebSearchUrl(db, "https://search.example.com?q={query}");
+    expect(store.webSearchUrl).toBe("https://search.example.com?q={query}");
+
+    await store.setSearchFilesMaxFileBytes(db, 1024 * 1024);
+    expect(store.searchFilesMaxFileBytes).toBe(1024 * 1024);
+
+    await store.setSearchFilesMaxFilesVisited(db, 2000);
+    expect(store.searchFilesMaxFilesVisited).toBe(2000);
+
+    await store.setSearchFilesSkipDirs(db, "dist,out,.git");
+    expect(store.searchFilesSkipDirs).toBe("dist,out,.git");
+    expect(store.searchFilesSkipDirsSet).toEqual(
+      new Set(["dist", "out", ".git"]),
+    );
+  });
+
+  it("loads config from DB on load()", async () => {
+    (mockGetConfig as any).mockImplementation(async (_db: any, key: string) => {
+      if (key === "enabled_tools") return ["read_file"];
+      if (key === "system_prompt_override") return "Loaded Prompt";
+      if (key === "web_search_use_proxy") return "true";
+      if (key === "search_files_max_file_bytes") return "2048";
+      return null;
+    });
+
+    await store.load(db);
+    expect(store.enabledToolNames.has("read_file")).toBe(true);
+    expect(store.systemPromptOverride).toBe("Loaded Prompt");
+    expect(store.webSearchUseProxy).toBe(true);
+    expect(store.searchFilesMaxFileBytes).toBe(2048);
+  });
+});
+
 describe("ToolsStore — declarative tools management", () => {
   let store: any;
 
@@ -149,4 +269,21 @@ describe("ToolsStore — declarative tools management", () => {
     expect(newStore.isDeclarativeToolEnabled("tool_x")).toBe(true);
     expect(newStore.isDeclarativeToolEnabled("tool_y")).toBe(false);
   });
+
+  it("refreshes declarative tools from loader", async () => {
+    (mockLoadDeclarativeTools as any).mockResolvedValueOnce({
+      tools: [
+        {
+          name: "custom_decl_tool",
+          description: "Declarative tool desc",
+          execution: { type: "javascript", script: "return 1;" },
+        },
+      ],
+    });
+
+    const refreshed = await store.refreshDeclarativeTools(db, "br:main");
+    expect(refreshed).toHaveLength(1);
+    expect(store.declarativeTools).toHaveLength(1);
+    expect(store.enabledDeclarativeTools).toHaveLength(1);
+  });
 });

package/src/subsystems/channels/imessage.test.ts

@@ -232,4 +232,63 @@ describe("IMessageChannel", () => {
     expect(legacySend).toBeDefined();
     expect(legacySend?.init.body instanceof FormData).toBe(true);
   });
+
+  it("handles start, stop, and polling cursor updates", async () => {
+    const channel: any = new IMessageChannel();
+    channel.configure("https://bridge.example", "secret", ["chat-1"]);
+
+    const seen: any[] = [];
+    channel.onMessage((msg: any) => seen.push(msg));
+
+    jest.spyOn(channel, "requestJson").mockImplementation(async () => {
+      channel.stop();
+      return {
+        nextCursor: "cursor-1",
+        messages: [
+          {
+            id: "msg-1",
+            conversationId: "chat-1",
+            sender: "User",
+            body: "Polled message",
+          },
+        ],
+      };
+    });
+
+    channel.start();
+    await new Promise((r) => setTimeout(r, 20));
+
+    expect(channel.cursor).toBe("cursor-1");
+    expect(seen).toHaveLength(1);
+    expect(seen[0].content).toBe("Polled message");
+    expect(channel.running).toBe(false);
+  });
+
+  it("sets typing indicators when typing is true", () => {
+    const channel = new IMessageChannel();
+    channel.configure("https://bridge.example", "secret", []);
+    const requestJsonSpy = jest
+      .spyOn(channel, "requestJson")
+      .mockResolvedValue({ ok: true } as any);
+
+    channel.setTyping("im:chat-xyz", true);
+    expect(requestJsonSpy).toHaveBeenCalledWith("/messages/typing", {
+      method: "POST",
+      body: JSON.stringify({ chatId: "chat-xyz", typing: true }),
+    });
+
+    channel.setTyping("im:chat-xyz", false);
+    expect(requestJsonSpy).toHaveBeenCalledTimes(1);
+  });
+
+  it("tests connection against /v1/info or /messages", async () => {
+    const channel = new IMessageChannel();
+    channel.configure("https://bridge.example", "secret", []);
+
+    jest
+      .spyOn(channel, "requestJson")
+      .mockResolvedValueOnce({ ok: true } as any);
+    const mode = await channel.ensureApiMode();
+    expect(mode).toBe("beeper-desktop");
+  });
 });