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

shadow-claw 1.23.3 → 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 (286) 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/migrateLegacyOpfs.test.ts ADDED Viewed

@@ -0,0 +1,327 @@
+import { jest } from "@jest/globals";
+import { CONFIG_KEYS, LEGACY_OPFS_ROOT } from "../config/config.js";
+import type { ShadowClawDatabase } from "../db/types.js";
+const mockGetConfig = jest.fn() as any;
+const mockSetConfig = jest.fn() as any;
+const mockGetOpfsRootDirName = jest.fn() as any;
+const mockWriteFileHandle = jest.fn() as any;
+const mockWriteOpfsPathViaWorker = jest.fn() as any;
+jest.unstable_mockModule("../db/getConfig.js", () => ({
+  getConfig: mockGetConfig,
+}));
+jest.unstable_mockModule("../db/setConfig.js", () => ({
+  setConfig: mockSetConfig,
+}));
+jest.unstable_mockModule("./storage.js", () => ({
+  getOpfsRootDirName: mockGetOpfsRootDirName,
+}));
+jest.unstable_mockModule("./writeFileHandle.js", () => ({
+  writeFileHandle: mockWriteFileHandle,
+  writeOpfsPathViaWorker: mockWriteOpfsPathViaWorker,
+}));
+const { migrateLegacyOpfs } = await import("./migrateLegacyOpfs.js");
+describe("migrateLegacyOpfs", () => {
+  const originalNavigator = globalThis.navigator;
+  beforeEach(() => {
+    jest.clearAllMocks();
+    mockGetConfig.mockResolvedValue(null);
+    mockSetConfig.mockResolvedValue(undefined);
+    mockGetOpfsRootDirName.mockReturnValue("shadowclaw-shadow-claw");
+  });
+  afterEach(() => {
+    Object.defineProperty(globalThis, "navigator", {
+      value: originalNavigator,
+      configurable: true,
+      writable: true,
+    });
+  });
+  it("skips migration if already completed", async () => {
+    mockGetConfig.mockResolvedValue("true");
+    const mockDb = {} as ShadowClawDatabase;
+    await migrateLegacyOpfs(mockDb);
+    expect(mockGetConfig).toHaveBeenCalledWith(
+      mockDb,
+      CONFIG_KEYS.OPFS_MIGRATED_FROM_LEGACY,
+    );
+    expect(mockSetConfig).not.toHaveBeenCalled();
+  });
+  it("skips migration if target root is the legacy root", async () => {
+    mockGetOpfsRootDirName.mockReturnValue(LEGACY_OPFS_ROOT);
+    const mockDb = {} as ShadowClawDatabase;
+    await migrateLegacyOpfs(mockDb);
+    expect(mockSetConfig).not.toHaveBeenCalled();
+  });
+  it("handles when navigator.storage is undefined", async () => {
+    Object.defineProperty(globalThis, "navigator", {
+      value: {},
+      configurable: true,
+      writable: true,
+    });
+    const mockDb = {} as ShadowClawDatabase;
+    await expect(migrateLegacyOpfs(mockDb)).resolves.toBeUndefined();
+    expect(mockSetConfig).not.toHaveBeenCalled();
+  });
+  it("handles when legacy OPFS directory does not exist and sets flag", async () => {
+    const mockOpfsRoot: any = {
+      getDirectoryHandle: (jest.fn() as any).mockImplementation(
+        (name: string) => {
+          if (name === LEGACY_OPFS_ROOT) {
+            throw new DOMException("Directory not found", "NotFoundError");
+          }
+          return Promise.resolve({});
+        },
+      ),
+    };
+    Object.defineProperty(globalThis, "navigator", {
+      value: {
+        storage: {
+          getDirectory: (jest.fn() as any).mockResolvedValue(mockOpfsRoot),
+        },
+      },
+      configurable: true,
+      writable: true,
+    });
+    const mockDb = {} as ShadowClawDatabase;
+    await migrateLegacyOpfs(mockDb);
+    expect(mockSetConfig).toHaveBeenCalledWith(
+      mockDb,
+      CONFIG_KEYS.OPFS_MIGRATED_FROM_LEGACY,
+      "true",
+    );
+  });
+  it("recursively copies legacy files and directories into the namespaced target root", async () => {
+    const mockFile1 = new File(["notes content"], "note.md", {
+      type: "text/markdown",
+    });
+    const mockFile2 = new File(["memory content"], "MEMORY.md", {
+      type: "text/markdown",
+    });
+    const mockNotesWorkspaceDir = {
+      entries: async function* () {
+        yield [
+          "note.md",
+          {
+            kind: "file",
+            getFile: jest.fn(async () => mockFile1),
+          },
+        ];
+      },
+    };
+    const mockNotesGroupDir = {
+      entries: async function* () {
+        yield [
+          "workspace",
+          {
+            kind: "directory",
+            ...mockNotesWorkspaceDir,
+          },
+        ];
+      },
+    };
+    const mockMainWorkspaceDir = {
+      entries: async function* () {
+        yield [
+          "MEMORY.md",
+          {
+            kind: "file",
+            getFile: jest.fn(async () => mockFile2),
+          },
+        ];
+      },
+    };
+    const mockMainGroupDir = {
+      entries: async function* () {
+        yield [
+          "workspace",
+          {
+            kind: "directory",
+            ...mockMainWorkspaceDir,
+          },
+        ];
+      },
+    };
+    const mockLegacyGroupsDir = {
+      entries: async function* () {
+        yield [
+          "br-notes",
+          {
+            kind: "directory",
+            ...mockNotesGroupDir,
+          },
+        ];
+        yield [
+          "br-main",
+          {
+            kind: "directory",
+            ...mockMainGroupDir,
+          },
+        ];
+      },
+    };
+    const mockLegacyRoot = {
+      entries: async function* () {
+        yield [
+          "groups",
+          {
+            kind: "directory",
+            ...mockLegacyGroupsDir,
+          },
+        ];
+      },
+    };
+    const createdDirs = new Map<string, any>();
+    const createdFiles = new Map<string, any>();
+    function createMockTargetDir(path: string) {
+      const dirHandle = {
+        name: path.split("/").pop() || "",
+        getDirectoryHandle: (jest.fn() as any).mockImplementation(
+          async (name: string) => {
+            const childPath = `${path}/${name}`;
+            if (!createdDirs.has(childPath)) {
+              createdDirs.set(childPath, createMockTargetDir(childPath));
+            }
+            return createdDirs.get(childPath);
+          },
+        ),
+        getFileHandle: (jest.fn() as any).mockImplementation(
+          async (name: string) => {
+            const filePath = `${path}/${name}`;
+            if (!createdFiles.has(filePath)) {
+              createdFiles.set(filePath, { name, path: filePath });
+            }
+            return createdFiles.get(filePath);
+          },
+        ),
+      };
+      return dirHandle;
+    }
+    const mockTargetRoot = createMockTargetDir("shadowclaw-shadow-claw");
+    const mockOpfsRoot = {
+      getDirectoryHandle: (jest.fn() as any).mockImplementation(
+        async (name: string) => {
+          if (name === LEGACY_OPFS_ROOT) {
+            return mockLegacyRoot;
+          }
+          if (name === "shadowclaw-shadow-claw") {
+            return mockTargetRoot;
+          }
+          throw new DOMException("Not found", "NotFoundError");
+        },
+      ),
+    };
+    Object.defineProperty(globalThis, "navigator", {
+      value: {
+        storage: {
+          getDirectory: (jest.fn() as any).mockResolvedValue(mockOpfsRoot),
+        },
+      },
+      configurable: true,
+      writable: true,
+    });
+    const mockDb = {} as ShadowClawDatabase;
+    await migrateLegacyOpfs(mockDb);
+    expect(mockWriteFileHandle).toHaveBeenCalledTimes(2);
+    expect(mockSetConfig).toHaveBeenCalledWith(
+      mockDb,
+      CONFIG_KEYS.OPFS_MIGRATED_FROM_LEGACY,
+      "true",
+    );
+  });
+  it("falls back to writeOpfsPathViaWorker on Safari/iPad when writeFileHandle throws unsupported", async () => {
+    const mockFile = new File(["test content"], "doc.txt", {
+      type: "text/plain",
+    });
+    const mockLegacyRoot = {
+      entries: async function* () {
+        yield [
+          "doc.txt",
+          {
+            kind: "file",
+            getFile: jest.fn(async () => mockFile),
+          },
+        ];
+      },
+    };
+    const mockTargetFile = { name: "doc.txt" };
+    const mockTargetRoot = {
+      getDirectoryHandle: jest.fn(),
+      getFileHandle: (jest.fn() as any).mockResolvedValue(mockTargetFile),
+    };
+    const mockOpfsRoot = {
+      getDirectoryHandle: (jest.fn() as any).mockImplementation(
+        async (name: string) => {
+          if (name === LEGACY_OPFS_ROOT) return mockLegacyRoot;
+          if (name === "shadowclaw-shadow-claw") return mockTargetRoot;
+          throw new DOMException("Not found", "NotFoundError");
+        },
+      ),
+    };
+    Object.defineProperty(globalThis, "navigator", {
+      value: {
+        storage: {
+          getDirectory: (jest.fn() as any).mockResolvedValue(mockOpfsRoot),
+        },
+      },
+      configurable: true,
+      writable: true,
+    });
+    mockWriteFileHandle.mockRejectedValueOnce(
+      new Error("Writable file streams are not supported"),
+    );
+    const mockDb = {} as ShadowClawDatabase;
+    await migrateLegacyOpfs(mockDb);
+    expect(mockWriteFileHandle).toHaveBeenCalledTimes(1);
+    expect(mockWriteOpfsPathViaWorker).toHaveBeenCalledWith(
+      ["shadowclaw-shadow-claw", "doc.txt"],
+      mockFile,
+    );
+    expect(mockSetConfig).toHaveBeenCalledWith(
+      mockDb,
+      CONFIG_KEYS.OPFS_MIGRATED_FROM_LEGACY,
+      "true",
+    );
+  });
+});