shadow-claw 1.23.3 → 1.24.0

package/src/worker/tools/workspace/delete-file.test.ts

@@ -0,0 +1,73 @@
+import { jest } from "@jest/globals";
+
+jest.unstable_mockModule("../../../storage/deleteGroupFile.js", () => ({
+  deleteGroupFile: jest.fn(),
+}));
+
+jest.unstable_mockModule("../../../storage/deleteGroupDirectory.js", () => ({
+  deleteGroupDirectory: jest.fn(),
+}));
+
+const { executeDeleteFile } = await import("./delete-file.js");
+const { deleteGroupFile } = await import("../../../storage/deleteGroupFile.js");
+const { deleteGroupDirectory } =
+  await import("../../../storage/deleteGroupDirectory.js");
+
+describe("executeDeleteFile", () => {
+  const mockDb: any = {};
+  const groupId = "test-group";
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("throws error when path parameter is missing", async () => {
+    await expect(executeDeleteFile(mockDb, {}, groupId)).rejects.toThrow(
+      "Missing path parameter",
+    );
+  });
+
+  it("deletes a file when deleteGroupFile succeeds", async () => {
+    (deleteGroupFile as jest.Mock<any>).mockResolvedValue(undefined);
+
+    const result = await executeDeleteFile(
+      mockDb,
+      { path: "file.txt" },
+      groupId,
+    );
+    expect(result).toBe("Deleted file: file.txt");
+    expect(deleteGroupFile).toHaveBeenCalledWith(mockDb, groupId, "file.txt");
+    expect(deleteGroupDirectory).not.toHaveBeenCalled();
+  });
+
+  it("falls back to deleteGroupDirectory when deleteGroupFile fails", async () => {
+    (deleteGroupFile as jest.Mock<any>).mockRejectedValueOnce(
+      new Error("Is a directory"),
+    );
+    (deleteGroupDirectory as jest.Mock<any>).mockResolvedValueOnce(undefined);
+
+    const result = await executeDeleteFile(
+      mockDb,
+      { path: "some-dir" },
+      groupId,
+    );
+    expect(result).toBe("Deleted directory: some-dir");
+    expect(deleteGroupDirectory).toHaveBeenCalledWith(
+      mockDb,
+      groupId,
+      "some-dir",
+    );
+  });
+
+  it("re-throws original error if both file and directory delete fail", async () => {
+    const fileError = new Error("File delete error");
+    (deleteGroupFile as jest.Mock<any>).mockRejectedValueOnce(fileError);
+    (deleteGroupDirectory as jest.Mock<any>).mockRejectedValueOnce(
+      new Error("Dir error"),
+    );
+
+    await expect(
+      executeDeleteFile(mockDb, { path: "bad-path" }, groupId),
+    ).rejects.toThrow("File delete error");
+  });
+});

package/src/worker/tools/workspace/diff-files.test.ts

@@ -0,0 +1,94 @@
+import { jest } from "@jest/globals";
+
+jest.unstable_mockModule("../../../storage/readGroupFile.js", () => ({
+  readGroupFile: jest.fn(),
+}));
+
+const { executeDiffFiles } = await import("./diff-files.js");
+const { readGroupFile } = await import("../../../storage/readGroupFile.js");
+
+describe("executeDiffFiles", () => {
+  const mockDb: any = {};
+  const groupId = "test-group";
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("returns error if path_a or path_b is missing", async () => {
+    const result1 = await executeDiffFiles(
+      mockDb,
+      { path_a: "a.txt" },
+      groupId,
+    );
+    expect(result1).toBe("Error: path_a and path_b are required.");
+
+    const result2 = await executeDiffFiles(
+      mockDb,
+      { path_b: "b.txt" },
+      groupId,
+    );
+    expect(result2).toBe("Error: path_a and path_b are required.");
+  });
+
+  it("returns error when reading path_a fails", async () => {
+    (readGroupFile as jest.Mock<any>).mockRejectedValueOnce(
+      new Error("File A not found"),
+    );
+
+    const result = await executeDiffFiles(
+      mockDb,
+      { path_a: "missing_a.txt", path_b: "b.txt" },
+      groupId,
+    );
+
+    expect(result).toContain(
+      "Error reading missing_a.txt: Error: File A not found",
+    );
+  });
+
+  it("returns error when reading path_b fails", async () => {
+    (readGroupFile as jest.Mock<any>)
+      .mockResolvedValueOnce("content a")
+      .mockRejectedValueOnce(new Error("File B not found"));
+
+    const result = await executeDiffFiles(
+      mockDb,
+      { path_a: "a.txt", path_b: "missing_b.txt" },
+      groupId,
+    );
+
+    expect(result).toContain(
+      "Error reading missing_b.txt: Error: File B not found",
+    );
+  });
+
+  it("returns identical message when files match exactly", async () => {
+    (readGroupFile as jest.Mock<any>)
+      .mockResolvedValueOnce("line 1\nline 2")
+      .mockResolvedValueOnce("line 1\nline 2");
+
+    const result = await executeDiffFiles(
+      mockDb,
+      { path_a: "a.txt", path_b: "b.txt" },
+      groupId,
+    );
+
+    expect(result).toBe("Files are identical.");
+  });
+
+  it("produces unified-like line diff when files differ", async () => {
+    (readGroupFile as jest.Mock<any>)
+      .mockResolvedValueOnce("line 1\nline 2 original\nline 3")
+      .mockResolvedValueOnce("line 1\nline 2 modified\nline 3");
+
+    const result = await executeDiffFiles(
+      mockDb,
+      { path_a: "a.txt", path_b: "b.txt" },
+      groupId,
+    );
+
+    expect(result).toContain("- [Line 2] line 2 original");
+    expect(result).toContain("+ [Line 2] line 2 modified");
+  });
+});

package/src/worker/tools/workspace/list-files.test.ts

@@ -0,0 +1,36 @@
+import { jest } from "@jest/globals";
+
+jest.unstable_mockModule("../../../storage/listGroupFiles.js", () => ({
+  listGroupFiles: jest.fn(),
+}));
+
+const { executeListFiles } = await import("./list-files.js");
+const { listGroupFiles } = await import("../../../storage/listGroupFiles.js");
+
+describe("executeListFiles", () => {
+  const mockDb: any = {};
+  const groupId = "test-group";
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("lists entries when directory has files", async () => {
+    (listGroupFiles as jest.Mock<any>).mockResolvedValue([
+      "index.ts",
+      "utils/",
+    ]);
+
+    const result = await executeListFiles(mockDb, { path: "src" }, groupId);
+    expect(result).toBe("index.ts\nutils/");
+    expect(listGroupFiles).toHaveBeenCalledWith(mockDb, groupId, "src");
+  });
+
+  it("defaults path to '.' and returns empty directory message when no files", async () => {
+    (listGroupFiles as jest.Mock<any>).mockResolvedValue([]);
+
+    const result = await executeListFiles(mockDb, {}, groupId);
+    expect(result).toBe("(empty directory)");
+    expect(listGroupFiles).toHaveBeenCalledWith(mockDb, groupId, ".");
+  });
+});

package/src/worker/tools/workspace/move-file.test.ts

@@ -0,0 +1,66 @@
+import { jest } from "@jest/globals";
+
+jest.unstable_mockModule("../../../storage/moveGroupEntry.js", () => ({
+  moveGroupEntry: jest.fn(),
+}));
+
+const { executeMoveFile } = await import("./move-file.js");
+const { moveGroupEntry } = await import("../../../storage/moveGroupEntry.js");
+
+describe("executeMoveFile", () => {
+  const mockDb: any = {};
+  const groupId = "test-group";
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("throws error when source_path or target_path is missing", async () => {
+    await expect(
+      executeMoveFile(mockDb, { source_path: "a" }, groupId),
+    ).rejects.toThrow("Missing source_path or target_path parameter");
+  });
+
+  it("moves entry within same group", async () => {
+    (moveGroupEntry as jest.Mock<any>).mockResolvedValue(undefined);
+
+    const result = await executeMoveFile(
+      mockDb,
+      { source_path: "old.md", target_path: "new.md" },
+      groupId,
+    );
+
+    expect(result).toBe("Moved old.md to new.md");
+    expect(moveGroupEntry).toHaveBeenCalledWith(
+      mockDb,
+      groupId,
+      groupId,
+      "old.md",
+      "new.md",
+    );
+  });
+
+  it("moves entry across different groups", async () => {
+    (moveGroupEntry as jest.Mock<any>).mockResolvedValue(undefined);
+
+    const result = await executeMoveFile(
+      mockDb,
+      {
+        source_path: "old.md",
+        target_path: "new.md",
+        source_group_id: "group-a",
+        target_group_id: "group-b",
+      },
+      groupId,
+    );
+
+    expect(result).toBe("Moved old.md to new.md (from group-a to group-b)");
+    expect(moveGroupEntry).toHaveBeenCalledWith(
+      mockDb,
+      "group-a",
+      "group-b",
+      "old.md",
+      "new.md",
+    );
+  });
+});

package/src/worker/tools/workspace/open-file.test.ts

@@ -0,0 +1,57 @@
+import { jest } from "@jest/globals";
+
+jest.unstable_mockModule("../../../storage/groupFileExists.js", () => ({
+  groupFileExists: jest.fn(),
+}));
+
+jest.unstable_mockModule("../../utils/post.js", () => ({
+  post: jest.fn(),
+}));
+
+const { executeOpenFile } = await import("./open-file.js");
+const { groupFileExists } = await import("../../../storage/groupFileExists.js");
+const { post } = await import("../../utils/post.js");
+
+describe("executeOpenFile", () => {
+  const mockDb: any = {};
+  const groupId = "test-group";
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("returns error if path is missing or invalid", async () => {
+    const result1 = await executeOpenFile(mockDb, {}, groupId);
+    expect(result1).toBe("Error: open_file requires a valid path string.");
+
+    const result2 = await executeOpenFile(mockDb, { path: 123 }, groupId);
+    expect(result2).toBe("Error: open_file requires a valid path string.");
+  });
+
+  it("returns error if file does not exist", async () => {
+    (groupFileExists as jest.Mock<any>).mockResolvedValue(false);
+
+    const result = await executeOpenFile(
+      mockDb,
+      { path: "missing.txt" },
+      groupId,
+    );
+    expect(result).toBe("Error: file not found: missing.txt");
+    expect(post).not.toHaveBeenCalled();
+  });
+
+  it("posts open-file event and returns success when file exists", async () => {
+    (groupFileExists as jest.Mock<any>).mockResolvedValue(true);
+
+    const result = await executeOpenFile(
+      mockDb,
+      { path: "document.pdf" },
+      groupId,
+    );
+    expect(result).toBe("Opening file in viewer: document.pdf");
+    expect(post).toHaveBeenCalledWith({
+      type: "open-file",
+      payload: { groupId, path: "document.pdf" },
+    });
+  });
+});

package/src/worker/tools/workspace/patch-file.test.ts

@@ -0,0 +1,81 @@
+import { jest } from "@jest/globals";
+
+jest.unstable_mockModule("../../../storage/readGroupFile.js", () => ({
+  readGroupFile: jest.fn(),
+}));
+
+jest.unstable_mockModule("../../../storage/writeGroupFile.js", () => ({
+  writeGroupFile: jest.fn(),
+}));
+
+const { executePatchFile } = await import("./patch-file.js");
+const { readGroupFile } = await import("../../../storage/readGroupFile.js");
+const { writeGroupFile } = await import("../../../storage/writeGroupFile.js");
+
+describe("executePatchFile", () => {
+  const mockDb: any = {};
+  const groupId = "test-group";
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("patches file successfully when match is unique", async () => {
+    (readGroupFile as jest.Mock<any>).mockResolvedValue(
+      "const x = 1;\nconst y = 2;\n",
+    );
+    (writeGroupFile as jest.Mock<any>).mockResolvedValue(undefined);
+
+    const result = await executePatchFile(
+      mockDb,
+      {
+        path: "test.ts",
+        old_string: "const x = 1;",
+        new_string: "const x = 42;",
+      },
+      groupId,
+    );
+
+    expect(result).toBe("Patched test.ts (12 chars replaced with 13 chars)");
+    expect(writeGroupFile).toHaveBeenCalledWith(
+      mockDb,
+      groupId,
+      "test.ts",
+      "const x = 42;\nconst y = 2;\n",
+    );
+  });
+
+  it("returns error when old_string is not found", async () => {
+    (readGroupFile as jest.Mock<any>).mockResolvedValue("const a = 1;");
+
+    const result = await executePatchFile(
+      mockDb,
+      {
+        path: "test.ts",
+        old_string: "const missing = true;",
+        new_string: "const fixed = true;",
+      },
+      groupId,
+    );
+
+    expect(result).toBe("patch_file failed: old_string not found in test.ts");
+    expect(writeGroupFile).not.toHaveBeenCalled();
+  });
+
+  it("returns error when old_string matches multiple locations", async () => {
+    (readGroupFile as jest.Mock<any>).mockResolvedValue("foo bar foo baz");
+
+    const result = await executePatchFile(
+      mockDb,
+      {
+        path: "test.txt",
+        old_string: "foo",
+        new_string: "qux",
+      },
+      groupId,
+    );
+
+    expect(result).toContain("matches multiple locations in test.txt");
+    expect(writeGroupFile).not.toHaveBeenCalled();
+  });
+});

package/src/worker/tools/workspace/read-file.test.ts

@@ -0,0 +1,116 @@
+import { jest } from "@jest/globals";
+
+jest.unstable_mockModule("../../../storage/readGroupFileBytes.js", () => ({
+  readGroupFileBytes: jest.fn(),
+}));
+
+const { executeReadFile } = await import("./read-file.js");
+const { readGroupFileBytes } =
+  await import("../../../storage/readGroupFileBytes.js");
+
+describe("executeReadFile", () => {
+  const mockDb: any = {};
+  const groupId = "test-group";
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("returns error when neither path nor paths is provided", async () => {
+    const result = await executeReadFile(mockDb, {}, groupId);
+    expect(result).toBe("Error: read_file requires path or paths.");
+  });
+
+  it("reads a single text file successfully", async () => {
+    (readGroupFileBytes as jest.Mock<any>).mockResolvedValue(
+      new TextEncoder().encode("Hello from file!"),
+    );
+
+    const result = await executeReadFile(
+      mockDb,
+      { path: "hello.txt" },
+      groupId,
+    );
+    expect(result).toBe("Hello from file!");
+    expect(readGroupFileBytes).toHaveBeenCalledWith(
+      mockDb,
+      groupId,
+      "hello.txt",
+    );
+  });
+
+  it("handles single text file read error", async () => {
+    (readGroupFileBytes as jest.Mock<any>).mockRejectedValue(
+      new Error("File not found"),
+    );
+
+    const result = await executeReadFile(
+      mockDb,
+      { path: "missing.txt" },
+      groupId,
+    );
+    expect(result).toBe("Error reading missing.txt: File not found");
+  });
+
+  it("returns error for single binary content", async () => {
+    (readGroupFileBytes as jest.Mock<any>).mockResolvedValue(
+      new Uint8Array([0x00, 0x01, 0x02, 0x00, 0xff]),
+    );
+
+    const result = await executeReadFile(
+      mockDb,
+      { path: "program.exe" },
+      groupId,
+    );
+    expect(result).toContain(
+      "is a binary file and cannot be displayed as text",
+    );
+  });
+
+  it("reads a single image file as multimodal content blocks", async () => {
+    const imageBytes = new Uint8Array([137, 80, 78, 71, 13, 10, 26, 10]);
+    (readGroupFileBytes as jest.Mock<any>).mockResolvedValue(imageBytes);
+
+    const result = await executeReadFile(
+      mockDb,
+      { path: "photo.png" },
+      groupId,
+    );
+    expect(Array.isArray(result)).toBe(true);
+    const blocks = result as any[];
+    expect(blocks).toHaveLength(2);
+    expect(blocks[0].type).toBe("text");
+    expect(blocks[1].type).toBe("image");
+    expect(blocks[1].media_type).toBe("image/png");
+  });
+
+  it("handles multiple files across text, image, binary, and errors", async () => {
+    (readGroupFileBytes as jest.Mock<any>).mockImplementation(
+      async (_db, _gid, path) => {
+        if (path === "file1.txt") return new TextEncoder().encode("Content 1");
+        if (path === "file2.bin")
+          return new Uint8Array([0x00, 0x01, 0x02, 0x00]);
+        throw new Error("Disk error");
+      },
+    );
+
+    const result = await executeReadFile(
+      mockDb,
+      { paths: ["file1.txt", "file2.bin", "image.jpg", "error.txt"] },
+      groupId,
+    );
+
+    expect(typeof result).toBe("string");
+    const text = result as string;
+    expect(text).toContain("--- file1.txt ---\nContent 1");
+    expect(text).toContain(
+      "--- file2.bin ---\n[Binary file: cannot display as text]",
+    );
+    expect(text).toContain(
+      "--- image.jpg ---\n[Image file: use read_file with a single path to see this image]",
+    );
+    expect(text).toContain(
+      "--- error.txt ---\nError reading error.txt: Disk error",
+    );
+  });
+});

package/src/worker/tools/workspace/send-file.test.ts

@@ -0,0 +1,82 @@
+import { jest } from "@jest/globals";
+
+const mockGroupFileExists = jest.fn() as any;
+const mockPost = jest.fn() as any;
+
+jest.unstable_mockModule("../../../storage/groupFileExists.js", () => ({
+  groupFileExists: mockGroupFileExists,
+}));
+
+jest.unstable_mockModule("../../utils/post.js", () => ({
+  post: mockPost,
+}));
+
+const { executeSendFile } = await import("./send-file.js");
+
+describe("executeSendFile", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("returns error if path is missing or not a string", async () => {
+    const res1 = await executeSendFile({} as any, {}, "peer:abc");
+    expect(res1).toBe("Error: send_file requires a valid path string.");
+
+    const res2 = await executeSendFile({} as any, { path: 123 }, "peer:abc");
+    expect(res2).toBe("Error: send_file requires a valid path string.");
+  });
+
+  it("returns error if groupId is not a peer conversation", async () => {
+    const res = await executeSendFile({} as any, { path: "doc.txt" }, "main");
+    expect(res).toContain("Error: send_file only works in peer conversations");
+  });
+
+  it("returns error on empty path after normalization", async () => {
+    const res = await executeSendFile({} as any, { path: "   " }, "peer:user1");
+    expect(res).toBe("Error: send_file received an empty file path.");
+  });
+
+  it("returns error if path contains path traversal segments", async () => {
+    const res = await executeSendFile(
+      {} as any,
+      { path: "../secret.txt" },
+      "peer:user1",
+    );
+    expect(res).toBe("Error: send_file path cannot contain '..' segments.");
+  });
+
+  it("returns error if file does not exist in the workspace", async () => {
+    mockGroupFileExists.mockResolvedValue(false);
+
+    const res = await executeSendFile(
+      {} as any,
+      { path: "photos/pic.png" },
+      "peer:user1",
+    );
+    expect(res).toBe(
+      "Error: send_file could not find photos/pic.png in the workspace.",
+    );
+    expect(mockPost).not.toHaveBeenCalled();
+  });
+
+  it("posts send-file message and returns success response on valid peer transfer", async () => {
+    mockGroupFileExists.mockResolvedValue(true);
+
+    const res = await executeSendFile(
+      {} as any,
+      { path: "shared/report.pdf" },
+      "peer:node-42",
+    );
+
+    expect(mockPost).toHaveBeenCalledWith({
+      type: "send-file",
+      payload: {
+        groupId: "peer:node-42",
+        path: "shared/report.pdf",
+      },
+    });
+    expect(res).toBe(
+      "Sending file to peer: shared/report.pdf. The transfer will proceed in the background — you can continue chatting.",
+    );
+  });
+});

package/src/worker/tools/workspace/update-memory.test.ts

@@ -0,0 +1,29 @@
+import { jest } from "@jest/globals";
+
+jest.unstable_mockModule("../../../storage/writeGroupFile.js", () => ({
+  writeGroupFile: jest.fn(),
+}));
+
+const { executeUpdateMemory } = await import("./update-memory.js");
+const { writeGroupFile } = await import("../../../storage/writeGroupFile.js");
+
+describe("executeUpdateMemory", () => {
+  it("writes memory content to MEMORY.md and returns confirmation", async () => {
+    (writeGroupFile as jest.Mock<any>).mockResolvedValue(undefined);
+    const mockDb: any = {};
+
+    const result = await executeUpdateMemory(
+      mockDb,
+      { content: "# User Preferences\n- Prefers dark mode" },
+      "test-group",
+    );
+
+    expect(result).toBe("Memory updated successfully.");
+    expect(writeGroupFile).toHaveBeenCalledWith(
+      mockDb,
+      "test-group",
+      "MEMORY.md",
+      "# User Preferences\n- Prefers dark mode",
+    );
+  });
+});

package/src/worker/tools/workspace/write-file.test.ts

@@ -0,0 +1,28 @@
+import { jest } from "@jest/globals";
+
+jest.unstable_mockModule("../../../storage/writeGroupFile.js", () => ({
+  writeGroupFile: jest.fn(),
+}));
+
+const { executeWriteFile } = await import("./write-file.js");
+const { writeGroupFile } = await import("../../../storage/writeGroupFile.js");
+
+describe("executeWriteFile", () => {
+  it("writes file content and returns summary", async () => {
+    (writeGroupFile as jest.Mock<any>).mockResolvedValue(undefined);
+    const mockDb: any = {};
+    const result = await executeWriteFile(
+      mockDb,
+      { path: "src/main.ts", content: "console.log('hi');" },
+      "test-group",
+    );
+
+    expect(result).toBe("Written 18 bytes to src/main.ts");
+    expect(writeGroupFile).toHaveBeenCalledWith(
+      mockDb,
+      "test-group",
+      "src/main.ts",
+      "console.log('hi');",
+    );
+  });
+});