shadow-claw 1.23.3 → 1.24.0

package/src/storage/migrateLegacyOpfs.ts

@@ -0,0 +1,117 @@
+import { CONFIG_KEYS, LEGACY_OPFS_ROOT } from "../config/config.js";
+import { getConfig } from "../db/getConfig.js";
+import { setConfig } from "../db/setConfig.js";
+import { getOpfsRootDirName } from "./storage.js";
+import { writeFileHandle, writeOpfsPathViaWorker } from "./writeFileHandle.js";
+import type { ShadowClawDatabase } from "../db/types.js";
+
+/**
+ * Recursively copy entries from a source OPFS directory to a target OPFS directory.
+ */
+async function copyOpfsEntriesRecursively(
+  sourceDir: FileSystemDirectoryHandle,
+  targetDir: FileSystemDirectoryHandle,
+  pathSegments: string[],
+): Promise<void> {
+  for await (const [name, handle] of (sourceDir as any).entries()) {
+    if (handle.kind === "directory") {
+      const nextTargetDir = await targetDir.getDirectoryHandle(name, {
+        create: true,
+      });
+      await copyOpfsEntriesRecursively(handle, nextTargetDir, [
+        ...pathSegments,
+        name,
+      ]);
+    } else if (handle.kind === "file") {
+      const file = await handle.getFile();
+      const targetFileHandle = await targetDir.getFileHandle(name, {
+        create: true,
+      });
+
+      try {
+        await writeFileHandle(targetFileHandle, file);
+      } catch (writeErr) {
+        const message =
+          writeErr instanceof Error ? writeErr.message : String(writeErr);
+        const needsOpfsWorkerFallback = message.includes(
+          "Writable file streams are not supported",
+        );
+
+        if (!needsOpfsWorkerFallback) {
+          throw writeErr;
+        }
+
+        await writeOpfsPathViaWorker([...pathSegments, name], file);
+      }
+    }
+  }
+}
+
+/**
+ * Perform a one-time migration of OPFS workspace files and directories from the
+ * legacy unnamespaced root directory ("shadowclaw") to the active namespaced
+ * deployment root directory if not already done.
+ */
+export async function migrateLegacyOpfs(db: ShadowClawDatabase): Promise<void> {
+  if (!db) {
+    return;
+  }
+
+  try {
+    const alreadyMigrated = await getConfig(
+      db,
+      CONFIG_KEYS.OPFS_MIGRATED_FROM_LEGACY,
+    );
+    if (alreadyMigrated === "true") {
+      return;
+    }
+  } catch {
+    // ignore read error
+  }
+
+  const targetRootName = getOpfsRootDirName();
+  if (targetRootName === LEGACY_OPFS_ROOT) {
+    return;
+  }
+
+  if (
+    typeof navigator === "undefined" ||
+    !navigator.storage ||
+    typeof navigator.storage.getDirectory !== "function"
+  ) {
+    return;
+  }
+
+  try {
+    const opfsRoot = await navigator.storage.getDirectory();
+    let legacyRootHandle: FileSystemDirectoryHandle;
+
+    try {
+      legacyRootHandle = await opfsRoot.getDirectoryHandle(LEGACY_OPFS_ROOT);
+    } catch {
+      // Legacy OPFS folder does not exist (fresh installation or already cleaned up)
+      try {
+        await setConfig(db, CONFIG_KEYS.OPFS_MIGRATED_FROM_LEGACY, "true");
+      } catch {
+        // ignore write error
+      }
+      return;
+    }
+
+    const targetRootHandle = await opfsRoot.getDirectoryHandle(targetRootName, {
+      create: true,
+    });
+
+    await copyOpfsEntriesRecursively(legacyRootHandle, targetRootHandle, [
+      targetRootName,
+    ]);
+  } catch (err) {
+    console.warn("Legacy OPFS migration warning:", err);
+  } finally {
+    try {
+      await setConfig(db, CONFIG_KEYS.OPFS_MIGRATED_FROM_LEGACY, "true");
+    } catch {
+      // ignore write error
+    }
+  }
+}

package/src/storage/writeGroupFileBytes.test.ts

@@ -0,0 +1,143 @@
+import { jest } from "@jest/globals";
+
+jest.unstable_mockModule("./getGroupDir.js", () => ({
+  getGroupDir: jest.fn(),
+}));
+
+jest.unstable_mockModule("./parsePath.js", () => ({ parsePath: jest.fn() }));
+
+jest.unstable_mockModule("./storage.js", () => ({
+  getOpfsRootDirName: jest.fn().mockReturnValue("shadowclaw"),
+  getStorageStatus: (jest.fn() as any).mockResolvedValue({
+    type: "opfs",
+    permission: "granted",
+    name: "OPFS",
+  }),
+  invalidateStorageRoot: jest.fn(),
+  isStaleHandleError: jest.fn(),
+}));
+
+jest.unstable_mockModule("./writeFileHandle.js", () => ({
+  writeFileHandle: (jest.fn() as any).mockResolvedValue(undefined),
+  writeOpfsPathViaWorker: (jest.fn() as any).mockResolvedValue(undefined),
+}));
+
+const { writeGroupFileBytes } = await import("./writeGroupFileBytes.js");
+const { getGroupDir } = await import("./getGroupDir.js");
+const { parsePath } = await import("./parsePath.js");
+const { getStorageStatus, invalidateStorageRoot, isStaleHandleError } =
+  await import("./storage.js");
+const { writeFileHandle, writeOpfsPathViaWorker } =
+  await import("./writeFileHandle.js");
+
+describe("writeGroupFileBytes", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    (isStaleHandleError as any).mockReturnValue(false);
+  });
+
+  it("writes binary Uint8Array content to target file", async () => {
+    const fileHandle: any = {};
+    const nested: any = {
+      getFileHandle: (jest.fn() as any).mockResolvedValue(fileHandle),
+    };
+    const root: any = {
+      getDirectoryHandle: (jest.fn() as any).mockResolvedValue(nested),
+    };
+
+    (getGroupDir as any).mockResolvedValue(root);
+    (parsePath as any).mockReturnValue({
+      dirs: ["images"],
+      filename: "photo.png",
+    });
+
+    const content = new Uint8Array([1, 2, 3, 4]);
+    await writeGroupFileBytes({} as any, "g1", "images/photo.png", content);
+
+    expect(root.getDirectoryHandle).toHaveBeenCalledWith("images", {
+      create: true,
+    });
+    expect(nested.getFileHandle).toHaveBeenCalledWith("photo.png", {
+      create: true,
+    });
+    expect(writeFileHandle).toHaveBeenCalledWith(fileHandle, content);
+  });
+
+  it("falls back to OPFS worker write when stream writing is unsupported in OPFS", async () => {
+    const fileHandle: any = {};
+    const nested: any = {
+      getFileHandle: (jest.fn() as any).mockResolvedValue(fileHandle),
+    };
+    const root: any = {
+      getDirectoryHandle: (jest.fn() as any).mockResolvedValue(nested),
+    };
+
+    (getGroupDir as any).mockResolvedValue(root);
+    (parsePath as any).mockReturnValue({ dirs: ["sub"], filename: "bin.dat" });
+
+    (writeFileHandle as any).mockRejectedValueOnce(
+      new Error(
+        "Writable file streams are not supported by this browser/storage backend.",
+      ),
+    );
+
+    const content = new Uint8Array([10, 20]);
+    await writeGroupFileBytes(
+      {} as any,
+      "peer:abc:123",
+      "sub/bin.dat",
+      content,
+    );
+
+    expect(getStorageStatus).toHaveBeenCalled();
+    expect(writeOpfsPathViaWorker).toHaveBeenCalledWith(
+      ["shadowclaw", "groups", "peer-abc-123", "sub", "bin.dat"],
+      content,
+    );
+  });
+
+  it("retries on stale handle error", async () => {
+    const fileHandle: any = {};
+    const root: any = {
+      getFileHandle: (jest.fn() as any).mockResolvedValue(fileHandle),
+    };
+
+    (parsePath as any).mockReturnValue({ dirs: [], filename: "file.txt" });
+    (isStaleHandleError as any)
+      .mockReturnValueOnce(true)
+      .mockReturnValue(false);
+
+    (getGroupDir as any)
+      .mockRejectedValueOnce(new Error("Stale handle"))
+      .mockResolvedValueOnce(root);
+
+    const content = new Uint8Array([5, 6]);
+    await writeGroupFileBytes({} as any, "g1", "file.txt", content);
+
+    expect(invalidateStorageRoot).toHaveBeenCalledTimes(1);
+    expect(writeFileHandle).toHaveBeenCalledWith(fileHandle, content);
+  });
+
+  it("throws error when non-OPFS storage backend fails with unsupported stream error", async () => {
+    const fileHandle: any = {};
+    const root: any = {
+      getFileHandle: (jest.fn() as any).mockResolvedValue(fileHandle),
+    };
+
+    (getGroupDir as any).mockResolvedValue(root);
+    (parsePath as any).mockReturnValue({ dirs: [], filename: "file.txt" });
+    (getStorageStatus as any).mockResolvedValueOnce({
+      type: "local",
+      permission: "granted",
+      name: "Folder",
+    });
+
+    (writeFileHandle as any).mockRejectedValueOnce(
+      new Error("Writable file streams are not supported"),
+    );
+
+    await expect(
+      writeGroupFileBytes({} as any, "g1", "file.txt", new Uint8Array([1])),
+    ).rejects.toThrow("Writable file streams are not supported");
+  });
+});

package/src/stores/chat-ui.test.ts

@@ -31,4 +31,24 @@ describe("ChatUiStore", () => {
 
     (URL as any).revokeObjectURL = originalRevoke;
   });
+
+  it("manages group scroll states and snapshots", () => {
+    const store = new ChatUiStore();
+
+    expect(store.getGroupScrollState("group-1")).toBeNull();
+
+    store.setGroupScrollState("group-1", 120, false);
+    expect(store.getGroupScrollState("group-1")).toEqual({
+      distanceFromBottom: 120,
+      nearBottom: false,
+    });
+
+    store.setNearBottom(false);
+    expect(store.nearBottomSnapshot).toBe(false);
+
+    store.reset();
+    expect(store.getGroupScrollState("group-1")).toBeNull();
+    expect(store.isNearBottom).toBe(true);
+    expect(store.nearBottomSnapshot).toBe(true);
+  });
 });

package/src/stores/orchestrator.test.ts

@@ -2887,5 +2887,139 @@ describe("OrchestratorStore", () => {
         configElement.remove();
       }
     });
+
+    it("handles sendMessage with and without a2uiAction", async () => {
+      const store = new OrchestratorStore();
+      const mockSubmit = jest.fn();
+      const orch: any = {
+        browserChat: { submit: mockSubmit },
+        events: createEvents(),
+      };
+      await store.init({} as any, orch);
+
+      store.sendMessage("plain message", []);
+      expect(mockSubmit).toHaveBeenCalledWith(
+        "plain message",
+        DEFAULT_GROUP_ID,
+        [],
+      );
+
+      const action = {
+        actionId: "btn-click",
+        surfaceId: "surf-1",
+        componentId: "btn-1",
+      };
+      store.sendMessage("action message", [], action as any);
+      expect(mockSubmit).toHaveBeenCalledWith(
+        "action message",
+        DEFAULT_GROUP_ID,
+        [],
+        action,
+      );
+    });
+
+    it("manages remote agent status, typing status, and ready state", () => {
+      const store = new OrchestratorStore();
+      expect(store.ready).toBe(false);
+
+      store.setReady(true);
+      expect(store.ready).toBe(true);
+
+      store.setRemoteAgentStatus("peer:agent-1", "running" as any);
+      expect(store._remoteAgentStatusByGroup.get().get("peer:agent-1")).toBe(
+        "running",
+      );
+
+      store.setRemoteAgentTyping("peer:agent-1", true);
+      expect(store._remoteAgentTypingByGroup.get().get("peer:agent-1")).toBe(
+        true,
+      );
+
+      store.setRemoteAgentTyping("peer:agent-1", false);
+      expect(
+        store._remoteAgentTypingByGroup.get().get("peer:agent-1"),
+      ).toBeUndefined();
+    });
+
+    it("handles folder navigation and proxy/network settings", async () => {
+      const store = new OrchestratorStore();
+      const mockDb: any = {};
+      const orch: any = {
+        browserChat: { submit: jest.fn() },
+        events: createEvents(),
+      };
+      await store.init(mockDb, orch);
+
+      // 1. Folder navigation
+      await store.navigateIntoFolder(mockDb, "docs");
+      expect(store.currentPath).toBe("docs");
+
+      await store.navigateIntoFolder(mockDb, "sub");
+      expect(store.currentPath).toBe("docs/sub");
+
+      await store.navigateBackFolder(mockDb);
+      expect(store.currentPath).toBe("docs");
+
+      await store.resetToRootFolder(mockDb);
+      expect(store.currentPath).toBe(".");
+
+      // 2. Proxy & network settings
+      await store.setGitProxyUrl(mockDb, "https://git-proxy.example.com");
+      expect(store.gitProxyUrl).toBe("https://git-proxy.example.com");
+
+      await store.setProxyUrl(mockDb, "https://proxy.example.com");
+      expect(store.proxyUrl).toBe("https://proxy.example.com");
+
+      await store.setUseProxy(mockDb, true);
+      expect(store.useProxy).toBe(true);
+
+      await store.setVMBashFullInternetAccess(mockDb, true);
+      expect(store.vmBashFullInternetAccess).toBe(true);
+    });
+
+    it("handles task management helpers (clearAllTasks, restoreTasksFromBackup, toggleTask)", async () => {
+      const store = new OrchestratorStore();
+      const mockDb: any = {};
+      const orch: any = {
+        browserChat: { submit: jest.fn() },
+        events: createEvents(),
+      };
+      await store.init(mockDb, orch);
+
+      const task: any = {
+        id: "task-123",
+        groupId: DEFAULT_GROUP_ID,
+        name: "Test Task",
+        enabled: true,
+      };
+      mockGetAllTasks.mockResolvedValue([task]);
+      await store.loadTasks(mockDb);
+      expect(store.tasks.length).toBe(1);
+
+      // 1. toggleTask
+      mockGetAllTasks.mockResolvedValue([{ ...task, enabled: false }]);
+      await store.toggleTask(mockDb, task, false);
+      expect(store.tasks.find((t) => t.id === "task-123")?.enabled).toBe(false);
+
+      // 2. restoreTasksFromBackup
+      mockGetAllTasks.mockResolvedValue([
+        task,
+        {
+          id: "task-new",
+          groupId: DEFAULT_GROUP_ID,
+          name: "New Task",
+          enabled: true,
+        },
+      ]);
+      await store.restoreTasksFromBackup(mockDb, [
+        { id: "task-new", name: "New Task", enabled: true } as any,
+      ]);
+      expect(store.tasks.some((t) => t.id === "task-new")).toBe(true);
+
+      // 3. clearAllTasks
+      mockGetAllTasks.mockResolvedValue([]);
+      await store.clearAllTasks(mockDb);
+      expect(store.tasks).toEqual([]);
+    });
   });
 });

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