npm - shadow-claw - Versions diffs - 1.23.4 → 1.24.0 - Mend

shadow-claw 1.23.4 → 1.24.0

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (255) hide show

package/src/storage/ensureMainGroupIndex.test.ts ADDED Viewed

@@ -0,0 +1,153 @@
+import { jest } from "@jest/globals";
+import { DEFAULT_MAIN_GROUP_INDEX_CONTENT } from "./defaultIndexContent.mjs";
+const mockGroupFileExists = jest.fn() as any;
+const mockWriteGroupFile = jest.fn() as any;
+const mockGetConfig = jest.fn() as any;
+const mockSetConfig = jest.fn() as any;
+jest.unstable_mockModule("./groupFileExists.js", () => ({
+  groupFileExists: mockGroupFileExists,
+}));
+jest.unstable_mockModule("./writeGroupFile.js", () => ({
+  writeGroupFile: mockWriteGroupFile,
+}));
+jest.unstable_mockModule("../db/getConfig.js", () => ({
+  getConfig: mockGetConfig,
+}));
+jest.unstable_mockModule("../db/setConfig.js", () => ({
+  setConfig: mockSetConfig,
+}));
+const {
+  ensureMainGroupIndex,
+  STATIC_MAIN_GROUP_INDEX_PATH,
+  resolveStaticMainGroupIndexUrl,
+  isMainGroupIndexSuppressed,
+  setMainGroupIndexSuppressed,
+} = await import("./ensureMainGroupIndex.js");
+const { DEFAULT_GROUP_ID } = await import("../config/config.js");
+describe("ensureMainGroupIndex", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    (mockGroupFileExists as any).mockReset();
+    (mockWriteGroupFile as any).mockReset();
+    (mockGetConfig as any).mockReset();
+    (mockSetConfig as any).mockReset();
+    (mockGetConfig as any).mockResolvedValue(undefined);
+    (mockSetConfig as any).mockResolvedValue(undefined);
+    (globalThis as any).fetch = (jest.fn() as any).mockRejectedValue(
+      new Error("no static template"),
+    );
+  });
+  it("returns true immediately if index.html already exists", async () => {
+    mockGroupFileExists.mockResolvedValue(true);
+    const res = await ensureMainGroupIndex({} as any, "group-1");
+    expect(res).toBe(true);
+    expect(mockWriteGroupFile).not.toHaveBeenCalled();
+  });
+  it("returns false if index.html is suppressed for DEFAULT_GROUP_ID", async () => {
+    mockGroupFileExists.mockResolvedValue(false);
+    mockGetConfig.mockResolvedValue(true);
+    const res = await ensureMainGroupIndex({} as any, DEFAULT_GROUP_ID);
+    expect(res).toBe(false);
+    expect(mockWriteGroupFile).not.toHaveBeenCalled();
+  });
+  it("creates index.html with custom content if supplied", async () => {
+    mockGroupFileExists.mockResolvedValue(false);
+    mockWriteGroupFile.mockResolvedValue(undefined);
+    const res = await ensureMainGroupIndex(
+      {} as any,
+      "custom-group",
+      "<h1>Custom Title</h1>",
+    );
+    expect(res).toBe(true);
+    expect(mockWriteGroupFile).toHaveBeenCalledWith(
+      {},
+      "custom-group",
+      "index.html",
+      "<h1>Custom Title</h1>",
+    );
+  });
+  it("fetches static template if available", async () => {
+    mockGroupFileExists.mockResolvedValue(false);
+    (globalThis as any).fetch = (jest.fn() as any).mockResolvedValue({
+      ok: true,
+      text: async () => "<html>Static Template</html>",
+    });
+    const res = await ensureMainGroupIndex({} as any, DEFAULT_GROUP_ID);
+    expect(res).toBe(true);
+    expect(mockWriteGroupFile).toHaveBeenCalledWith(
+      {},
+      DEFAULT_GROUP_ID,
+      "index.html",
+      "<html>Static Template</html>",
+    );
+  });
+  it("falls back to DEFAULT_MAIN_GROUP_INDEX_CONTENT when fetch fails", async () => {
+    mockGroupFileExists.mockResolvedValue(false);
+    mockWriteGroupFile.mockResolvedValue(undefined);
+    const res = await ensureMainGroupIndex({} as any, DEFAULT_GROUP_ID);
+    expect(res).toBe(true);
+    expect(mockWriteGroupFile).toHaveBeenCalledWith(
+      {},
+      DEFAULT_GROUP_ID,
+      "index.html",
+      DEFAULT_MAIN_GROUP_INDEX_CONTENT,
+    );
+  });
+  it("returns false if writeGroupFile throws an error", async () => {
+    mockGroupFileExists.mockResolvedValue(false);
+    mockWriteGroupFile.mockRejectedValue(new Error("Storage write failure"));
+    const warnSpy = jest.spyOn(console, "warn").mockImplementation(() => {});
+    const res = await ensureMainGroupIndex({} as any, DEFAULT_GROUP_ID);
+    expect(res).toBe(false);
+    warnSpy.mockRestore();
+  });
+  it("tests isMainGroupIndexSuppressed and setMainGroupIndexSuppressed", async () => {
+    mockGetConfig.mockResolvedValueOnce("true").mockResolvedValueOnce(false);
+    expect(await isMainGroupIndexSuppressed({} as any)).toBe(true);
+    expect(await isMainGroupIndexSuppressed({} as any)).toBe(false);
+    await setMainGroupIndexSuppressed({} as any, true);
+    expect(mockSetConfig).toHaveBeenCalledWith(
+      {},
+      "main_group_index_suppressed",
+      true,
+    );
+  });
+  it("resolves static main group index url with and without window.location.origin", () => {
+    const url = resolveStaticMainGroupIndexUrl();
+    expect(url).toContain(STATIC_MAIN_GROUP_INDEX_PATH);
+    const originalLocation = window.location;
+    try {
+      delete (window as any).location;
+      expect(resolveStaticMainGroupIndexUrl()).toContain(
+        STATIC_MAIN_GROUP_INDEX_PATH,
+      );
+    } finally {
+      (window as any).location = originalLocation;
+    }
+  });
+});

package/src/storage/getGroupFile.test.ts ADDED Viewed

@@ -0,0 +1,66 @@
+import { jest } from "@jest/globals";
+jest.unstable_mockModule("./getGroupDir.js", () => ({
+  getGroupDir: jest.fn(),
+}));
+jest.unstable_mockModule("./parsePath.js", () => ({
+  parsePath: jest.fn(),
+}));
+const { getGroupFile } = await import("./getGroupFile.js");
+const { getGroupDir } = await import("./getGroupDir.js");
+const { parsePath } = await import("./parsePath.js");
+describe("getGroupFile", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+  it("retrieves native File object from nested directory structure", async () => {
+    const mockFile = new File(["test data"], "report.pdf", {
+      type: "application/pdf",
+    });
+    const fileHandle: any = {
+      getFile: (jest.fn() as any).mockResolvedValue(mockFile),
+    };
+    const subDir: any = {
+      getFileHandle: (jest.fn() as any).mockResolvedValue(fileHandle),
+    };
+    const rootDir: any = {
+      getDirectoryHandle: (jest.fn() as any).mockResolvedValue(subDir),
+    };
+    (getGroupDir as any).mockResolvedValue(rootDir);
+    (parsePath as any).mockReturnValue({
+      dirs: ["docs"],
+      filename: "report.pdf",
+    });
+    const result = await getGroupFile({} as any, "group-1", "docs/report.pdf");
+    expect(getGroupDir).toHaveBeenCalledWith({}, "group-1");
+    expect(rootDir.getDirectoryHandle).toHaveBeenCalledWith("docs");
+    expect(subDir.getFileHandle).toHaveBeenCalledWith("report.pdf");
+    expect(fileHandle.getFile).toHaveBeenCalled();
+    expect(result).toBe(mockFile);
+  });
+  it("retrieves native File from root workspace directory", async () => {
+    const mockFile = new File(["hello"], "README.md");
+    const fileHandle: any = {
+      getFile: (jest.fn() as any).mockResolvedValue(mockFile),
+    };
+    const rootDir: any = {
+      getFileHandle: (jest.fn() as any).mockResolvedValue(fileHandle),
+    };
+    (getGroupDir as any).mockResolvedValue(rootDir);
+    (parsePath as any).mockReturnValue({ dirs: [], filename: "README.md" });
+    const result = await getGroupFile({} as any, "group-2", "README.md");
+    expect(rootDir.getFileHandle).toHaveBeenCalledWith("README.md");
+    expect(result).toBe(mockFile);
+  });
+});

package/src/storage/memoryStorage.test.ts CHANGED Viewed

@@ -1,7 +1,9 @@
 import {
   MemoryDirectoryHandle,
   MemoryFileHandle,
+  MemorySyncAccessHandle,
   getMemoryOpfsRoot,
+  isMemoryStorageFallbackActive,
   resetMemoryOpfsRoot,
 } from "./memoryStorage.js";
@@ -65,6 +67,41 @@ describe("memoryStorage", () => {
       expect(await file2.text()).toBe("AB");
     });
+    it("supports MemorySyncAccessHandle read, write, truncate, getSize, flush and close", async () => {
+      const fileHandle = new MemoryFileHandle("sync.dat");
+      const syncHandle: MemorySyncAccessHandle =
+        await fileHandle.createSyncAccessHandle();
+      expect(syncHandle.getSize()).toBe(0);
+      const writeData = new Uint8Array([10, 20, 30, 40]);
+      const written = syncHandle.write(writeData, { at: 0 });
+      expect(written).toBe(4);
+      expect(syncHandle.getSize()).toBe(4);
+      syncHandle.flush(); // No-op
+      const readBuffer = new Uint8Array(4);
+      const readBytes = syncHandle.read(readBuffer, { at: 0 });
+      expect(readBytes).toBe(4);
+      expect(Array.from(readBuffer)).toEqual([10, 20, 30, 40]);
+      // Read past end
+      const emptyBuffer = new Uint8Array(2);
+      expect(syncHandle.read(emptyBuffer, { at: 100 })).toBe(0);
+      // Truncate
+      syncHandle.truncate(2);
+      expect(syncHandle.getSize()).toBe(2);
+      // Close and verify operations throw
+      syncHandle.close();
+      expect(() => syncHandle.getSize()).toThrow();
+      expect(() => syncHandle.read(readBuffer)).toThrow();
+      expect(() => syncHandle.write(writeData)).toThrow();
+      expect(() => syncHandle.truncate(1)).toThrow();
+    });
     it("handles permissions and equality", async () => {
       const fileHandle = new MemoryFileHandle("test.txt");
       expect(await fileHandle.queryPermission()).toBe("granted");
@@ -94,6 +131,14 @@ describe("memoryStorage", () => {
       expect(existingFile).toBe(file);
     });
+    it("handles special directory names (. and ..)", async () => {
+      const dir = new MemoryDirectoryHandle("root");
+      const current = await dir.getDirectoryHandle(".");
+      expect(current).toBe(dir);
+      await expect(dir.getDirectoryHandle("..")).rejects.toThrow();
+    });
     it("throws NotFoundError when entry does not exist and create is false", async () => {
       const dir = new MemoryDirectoryHandle("root");
       await expect(dir.getDirectoryHandle("missing")).rejects.toThrow();
@@ -109,6 +154,28 @@ describe("memoryStorage", () => {
       await expect(dir.getDirectoryHandle("file.txt")).rejects.toThrow();
     });
+    it("resolves descendant handle paths", async () => {
+      const root = new MemoryDirectoryHandle("root");
+      const folderA = await root.getDirectoryHandle("folderA", {
+        create: true,
+      });
+      const folderB = await folderA.getDirectoryHandle("folderB", {
+        create: true,
+      });
+      const file = await folderB.getFileHandle("item.txt", { create: true });
+      expect(await root.resolve(root)).toEqual([]);
+      expect(await root.resolve(folderA)).toEqual(["folderA"]);
+      expect(await root.resolve(file)).toEqual([
+        "folderA",
+        "folderB",
+        "item.txt",
+      ]);
+      const unrelated = new MemoryFileHandle("unrelated.txt");
+      expect(await root.resolve(unrelated)).toBeNull();
+    });
     it("iterates entries, keys, and values", async () => {
       const dir = new MemoryDirectoryHandle("root");
       await dir.getDirectoryHandle("b_dir", { create: true });
@@ -131,6 +198,13 @@ describe("memoryStorage", () => {
         values.push(v.name);
       }
       expect(values).toEqual(["b_dir", "a_file.txt"]);
+      // async iterator fallback
+      const directEntries: string[] = [];
+      for await (const [name, handle] of dir) {
+        directEntries.push(`${name}:${handle.kind}`);
+      }
+      expect(directEntries).toEqual(["b_dir:directory", "a_file.txt:file"]);
     });
     it("removes files and empty/recursive directories", async () => {
@@ -149,12 +223,18 @@ describe("memoryStorage", () => {
     });
   });
-  describe("getMemoryOpfsRoot", () => {
-    it("returns a singleton OPFS root child", () => {
+  describe("getMemoryOpfsRoot & isMemoryStorageFallbackActive", () => {
+    it("returns a singleton OPFS root child and reports fallback active", () => {
+      expect(isMemoryStorageFallbackActive()).toBe(false);
       const root1 = getMemoryOpfsRoot();
+      expect(isMemoryStorageFallbackActive()).toBe(true);
       const root2 = getMemoryOpfsRoot();
       expect(root1).toBe(root2);
       expect(root1.name).toBeTruthy();
+      resetMemoryOpfsRoot();
+      expect(isMemoryStorageFallbackActive()).toBe(false);
     });
   });
 });

package/src/storage/writeGroupFileBytes.test.ts ADDED Viewed

@@ -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 CHANGED Viewed

@@ -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 CHANGED Viewed

@@ -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([]);
+    });
   });
 });