shadow-claw 1.23.3 → 1.24.0

package/src/worker/tools/ui/render-component.test.ts

@@ -0,0 +1,346 @@
+import { jest } from "@jest/globals";
+import { A2UI_BASIC_CATALOG_ID } from "../../../ui/a2ui/types.js";
+
+jest.unstable_mockModule("../../utils/post.js", () => ({
+  post: jest.fn(),
+}));
+
+const { post } = await import("../../utils/post.js");
+const { executeRenderComponent } = await import("./render-component.js");
+
+describe("executeRenderComponent", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("returns error when surfaceId is missing or not a string", () => {
+    const res1 = executeRenderComponent({ action: "createSurface" }, "g1");
+    expect(res1).toBe("Error: render_component requires a surfaceId string.");
+
+    const res2 = executeRenderComponent(
+      { action: "createSurface", surfaceId: 123 },
+      "g1",
+    );
+    expect(res2).toBe("Error: render_component requires a surfaceId string.");
+  });
+
+  it("returns error on unknown action", () => {
+    const res = executeRenderComponent(
+      { surfaceId: "s1", action: "invalidAction" },
+      "g1",
+    );
+    expect(res).toContain("Error: Unknown render_component action");
+  });
+
+  describe("createSurface", () => {
+    it("returns error if components is missing", () => {
+      const res = executeRenderComponent(
+        { surfaceId: "s1", action: "createSurface" },
+        "g1",
+      );
+      expect(res).toBe(
+        "Error: createSurface requires a components array (or legacy map).",
+      );
+    });
+
+    it("returns error if components is primitive or null", () => {
+      const res = executeRenderComponent(
+        {
+          surfaceId: "s1",
+          action: "createSurface",
+          components: 123 as any,
+        },
+        "g1",
+      );
+      expect(res).toContain(
+        'Error: createSurface requires a component with id "root".',
+      );
+    });
+
+    it("returns error if no component with id root exists", () => {
+      const res = executeRenderComponent(
+        {
+          surfaceId: "s1",
+          action: "createSurface",
+          components: [{ id: "btn", component: "Button" }],
+        },
+        "g1",
+      );
+      expect(res).toContain(
+        'Error: createSurface requires a component with id "root".',
+      );
+    });
+
+    it("successfully posts createSurface with array components and flattens properties", () => {
+      const res = executeRenderComponent(
+        {
+          surfaceId: "s1",
+          action: "createSurface",
+          components: [
+            { id: "root", component: "Column", properties: { spacing: "md" } },
+            { id: "btn", component: "Button", text: "Click" },
+          ],
+          dataModel: { count: 0 },
+          sendDataModel: true,
+          surfaceProperties: { theme: "dark" },
+        },
+        "group-123",
+      );
+
+      expect(res).toBe('A2UI surface "s1" rendered (action: createSurface).');
+      expect(post).toHaveBeenCalledWith({
+        type: "render-component",
+        payload: {
+          groupId: "group-123",
+          envelope: {
+            version: "v1.0",
+            type: "createSurface",
+            surfaceId: "s1",
+            catalogId: A2UI_BASIC_CATALOG_ID,
+            components: [
+              { id: "root", component: "Column", spacing: "md" },
+              { id: "btn", component: "Button", text: "Click" },
+            ],
+            dataModel: { count: 0 },
+            sendDataModel: true,
+            surfaceProperties: { theme: "dark" },
+          },
+        },
+      });
+    });
+
+    it("successfully converts legacy map format to components array", () => {
+      const res = executeRenderComponent(
+        {
+          surfaceId: "s1",
+          action: "createSurface",
+          components: {
+            root: { component: "Column", properties: { padding: 4 } },
+            item1: { component: "Text", properties: { text: "Hello" } },
+          },
+        },
+        "group-123",
+      );
+
+      expect(res).toBe('A2UI surface "s1" rendered (action: createSurface).');
+      expect(post).toHaveBeenCalledWith({
+        type: "render-component",
+        payload: {
+          groupId: "group-123",
+          envelope: {
+            version: "v1.0",
+            type: "createSurface",
+            surfaceId: "s1",
+            catalogId: A2UI_BASIC_CATALOG_ID,
+            components: [
+              { id: "root", component: "Column", padding: 4 },
+              { id: "item1", component: "Text", text: "Hello" },
+            ],
+            dataModel: undefined,
+            sendDataModel: undefined,
+            surfaceProperties: undefined,
+          },
+        },
+      });
+    });
+  });
+
+  describe("updateComponents", () => {
+    it("returns error if components is missing", () => {
+      const res = executeRenderComponent(
+        { surfaceId: "s1", action: "updateComponents" },
+        "g1",
+      );
+      expect(res).toBe(
+        "Error: updateComponents requires a components array (or legacy map).",
+      );
+    });
+
+    it("successfully posts updateComponents envelope", () => {
+      const res = executeRenderComponent(
+        {
+          surfaceId: "s1",
+          action: "updateComponents",
+          components: [
+            {
+              id: "btn",
+              component: "Button",
+              properties: { label: "Updated" },
+            },
+          ],
+        },
+        "group-123",
+      );
+
+      expect(res).toBe(
+        'A2UI surface "s1" rendered (action: updateComponents).',
+      );
+      expect(post).toHaveBeenCalledWith({
+        type: "render-component",
+        payload: {
+          groupId: "group-123",
+          envelope: {
+            version: "v1.0",
+            type: "updateComponents",
+            surfaceId: "s1",
+            components: [{ id: "btn", component: "Button", label: "Updated" }],
+          },
+        },
+      });
+    });
+  });
+
+  describe("updateDataModel", () => {
+    it("handles spec-compliant path and value", () => {
+      const res = executeRenderComponent(
+        {
+          surfaceId: "s1",
+          action: "updateDataModel",
+          path: "/user/name",
+          value: "Alice",
+        },
+        "group-123",
+      );
+
+      expect(res).toBe('A2UI surface "s1" rendered (action: updateDataModel).');
+      expect(post).toHaveBeenCalledWith({
+        type: "render-component",
+        payload: {
+          groupId: "group-123",
+          envelope: {
+            version: "v1.0",
+            type: "updateDataModel",
+            surfaceId: "s1",
+            path: "/user/name",
+            value: "Alice",
+          },
+        },
+      });
+    });
+
+    it("handles deprecated patches map with single key", () => {
+      const res = executeRenderComponent(
+        {
+          surfaceId: "s1",
+          action: "updateDataModel",
+          patches: {
+            "/user/age": 30,
+          },
+        },
+        "group-123",
+      );
+
+      expect(res).toBe('A2UI surface "s1" rendered (action: updateDataModel).');
+      expect(post).toHaveBeenCalledWith({
+        type: "render-component",
+        payload: {
+          groupId: "group-123",
+          envelope: {
+            version: "v1.0",
+            type: "updateDataModel",
+            surfaceId: "s1",
+            path: "/user/age",
+            value: 30,
+          },
+        },
+      });
+    });
+
+    it("handles deprecated patches map with multiple keys posting separate envelopes", () => {
+      const res = executeRenderComponent(
+        {
+          surfaceId: "s1",
+          action: "updateDataModel",
+          patches: {
+            "/user/k1": "v1",
+            "/user/k2": "v2",
+            "/user/k3": "v3",
+          },
+        },
+        "group-123",
+      );
+
+      expect(res).toBe('A2UI surface "s1" rendered (action: updateDataModel).');
+      // Total 3 post calls (2 in loop, 1 final)
+      expect(post).toHaveBeenCalledTimes(3);
+      expect(post).toHaveBeenNthCalledWith(1, {
+        type: "render-component",
+        payload: {
+          groupId: "group-123",
+          envelope: {
+            version: "v1.0",
+            type: "updateDataModel",
+            surfaceId: "s1",
+            path: "/user/k2",
+            value: "v2",
+          },
+        },
+      });
+      expect(post).toHaveBeenNthCalledWith(2, {
+        type: "render-component",
+        payload: {
+          groupId: "group-123",
+          envelope: {
+            version: "v1.0",
+            type: "updateDataModel",
+            surfaceId: "s1",
+            path: "/user/k3",
+            value: "v3",
+          },
+        },
+      });
+      expect(post).toHaveBeenNthCalledWith(3, {
+        type: "render-component",
+        payload: {
+          groupId: "group-123",
+          envelope: {
+            version: "v1.0",
+            type: "updateDataModel",
+            surfaceId: "s1",
+            path: "/user/k1",
+            value: "v1",
+          },
+        },
+      });
+    });
+
+    it("returns error on empty patches object", () => {
+      const res = executeRenderComponent(
+        {
+          surfaceId: "s1",
+          action: "updateDataModel",
+          patches: {},
+        },
+        "group-123",
+      );
+
+      expect(res).toBe("Error: updateDataModel patches object is empty.");
+      expect(post).not.toHaveBeenCalled();
+    });
+  });
+
+  describe("deleteSurface", () => {
+    it("successfully posts deleteSurface envelope", () => {
+      const res = executeRenderComponent(
+        {
+          surfaceId: "s1",
+          action: "deleteSurface",
+        },
+        "group-123",
+      );
+
+      expect(res).toBe('A2UI surface "s1" rendered (action: deleteSurface).');
+      expect(post).toHaveBeenCalledWith({
+        type: "render-component",
+        payload: {
+          groupId: "group-123",
+          envelope: {
+            version: "v1.0",
+            type: "deleteSurface",
+            surfaceId: "s1",
+          },
+        },
+      });
+    });
+  });
+});

package/src/worker/tools/ui/send-notification.test.ts

@@ -0,0 +1,40 @@
+import { jest } from "@jest/globals";
+
+jest.unstable_mockModule("../../utils/post.js", () => ({
+  post: jest.fn(),
+}));
+
+const { executeSendNotification } = await import("./send-notification.js");
+const { post } = await import("../../utils/post.js");
+
+describe("executeSendNotification", () => {
+  it("posts send-notification event and returns confirmation", () => {
+    const result = executeSendNotification(
+      { body: "Task completed successfully", title: "Build Notification" },
+      "group-789",
+    );
+
+    expect(result).toBe("Push notification sent: Task completed successfully");
+    expect(post).toHaveBeenCalledWith({
+      type: "send-notification",
+      payload: {
+        body: "Task completed successfully",
+        groupId: "group-789",
+        title: "Build Notification",
+      },
+    });
+  });
+
+  it("uses default title when title is omitted", () => {
+    executeSendNotification({ body: "Ping" }, "group-789");
+
+    expect(post).toHaveBeenCalledWith({
+      type: "send-notification",
+      payload: {
+        body: "Ping",
+        groupId: "group-789",
+        title: "ShadowClaw",
+      },
+    });
+  });
+});

package/src/worker/tools/ui/utils/getAllowFullInternetAccess.test.ts

@@ -0,0 +1,31 @@
+import { jest } from "@jest/globals";
+
+jest.unstable_mockModule("../../../../db/getConfig.js", () => ({
+  getConfig: jest.fn(),
+}));
+
+const { getAllowFullInternetAccess } =
+  await import("./getAllowFullInternetAccess.js");
+const { getConfig } = await import("../../../../db/getConfig.js");
+
+describe("getAllowFullInternetAccess", () => {
+  const mockDb: any = {};
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("returns true when config is 'true'", async () => {
+    (getConfig as jest.Mock<any>).mockResolvedValue("true");
+    const result = await getAllowFullInternetAccess(mockDb);
+    expect(result).toBe(true);
+  });
+
+  it("returns false when config is false or missing", async () => {
+    (getConfig as jest.Mock<any>).mockResolvedValue("false");
+    expect(await getAllowFullInternetAccess(mockDb)).toBe(false);
+
+    (getConfig as jest.Mock<any>).mockResolvedValue(null);
+    expect(await getAllowFullInternetAccess(mockDb)).toBe(false);
+  });
+});

package/src/worker/tools/ui/utils/parseBooleanConfig.test.ts

@@ -0,0 +1,25 @@
+import { parseBooleanConfig } from "./parseBooleanConfig.js";
+
+describe("parseBooleanConfig", () => {
+  it("parses truthy boolean strings", () => {
+    expect(parseBooleanConfig("true")).toBe(true);
+    expect(parseBooleanConfig("1")).toBe(true);
+    expect(parseBooleanConfig("yes")).toBe(true);
+    expect(parseBooleanConfig("on")).toBe(true);
+    expect(parseBooleanConfig("  TRUE  ")).toBe(true);
+  });
+
+  it("parses falsy boolean strings", () => {
+    expect(parseBooleanConfig("false")).toBe(false);
+    expect(parseBooleanConfig("0")).toBe(false);
+    expect(parseBooleanConfig("no")).toBe(false);
+    expect(parseBooleanConfig("off")).toBe(false);
+    expect(parseBooleanConfig("  FALSE  ")).toBe(false);
+  });
+
+  it("returns null for null, undefined, or unrecognized strings", () => {
+    expect(parseBooleanConfig(null)).toBeNull();
+    expect(parseBooleanConfig(undefined)).toBeNull();
+    expect(parseBooleanConfig("other")).toBeNull();
+  });
+});

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

@@ -0,0 +1,84 @@
+import { jest } from "@jest/globals";
+
+jest.unstable_mockModule("../../../storage/readGroupFile.js", () => ({
+  readGroupFile: jest.fn(),
+}));
+
+const { executeAttachFile } = await import("./attach-file.js");
+const { readGroupFile } = await import("../../../storage/readGroupFile.js");
+
+describe("executeAttachFile", () => {
+  const mockDb: any = {};
+  const groupId = "test-group";
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("returns error if path is missing or not a string", async () => {
+    const result1 = await executeAttachFile(mockDb, {}, groupId);
+    expect(result1).toBe(
+      "Error: attach_file_to_chat requires a valid path string.",
+    );
+
+    const result2 = await executeAttachFile(mockDb, { path: 42 }, groupId);
+    expect(result2).toBe(
+      "Error: attach_file_to_chat requires a valid path string.",
+    );
+  });
+
+  it("returns error if path is empty", async () => {
+    const result = await executeAttachFile(mockDb, { path: "   " }, groupId);
+    expect(result).toBe(
+      "Error: attach_file_to_chat received an empty file path.",
+    );
+  });
+
+  it("returns error if path contains traversal '..' segments", async () => {
+    const result = await executeAttachFile(
+      mockDb,
+      { path: "../secret.txt" },
+      groupId,
+    );
+    expect(result).toBe(
+      "Error: attach_file_to_chat path cannot contain '..' segments.",
+    );
+  });
+
+  it("returns error when file does not exist", async () => {
+    (readGroupFile as jest.Mock<any>).mockRejectedValue(new Error("Not found"));
+
+    const result = await executeAttachFile(
+      mockDb,
+      { path: "missing.md" },
+      groupId,
+    );
+    expect(result).toContain("could not find missing.md: Not found");
+  });
+
+  it("prepares standard markdown link for regular file", async () => {
+    (readGroupFile as jest.Mock<any>).mockResolvedValue("file content");
+
+    const result = await executeAttachFile(
+      mockDb,
+      { path: "docs/guide.md", alt: "User Guide" },
+      groupId,
+    );
+
+    expect(result).toContain("Attachment prepared: docs/guide.md");
+    expect(result).toContain("[User Guide](docs/guide.md)");
+  });
+
+  it("prepares image markdown syntax for image file", async () => {
+    (readGroupFile as jest.Mock<any>).mockResolvedValue("image data");
+
+    const result = await executeAttachFile(
+      mockDb,
+      { path: "images/banner.png" },
+      groupId,
+    );
+
+    expect(result).toContain("Attachment prepared: images/banner.png");
+    expect(result).toContain("![banner.png](images/banner.png)");
+  });
+});

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

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

package/src/worker/tools/workspace/create-directory.test.ts

@@ -0,0 +1,40 @@
+import { jest } from "@jest/globals";
+
+jest.unstable_mockModule("../../../storage/createGroupDirectory.js", () => ({
+  createGroupDirectory: jest.fn(),
+}));
+
+const { executeCreateDirectory } = await import("./create-directory.js");
+const { createGroupDirectory } =
+  await import("../../../storage/createGroupDirectory.js");
+
+describe("executeCreateDirectory", () => {
+  const mockDb: any = {};
+  const groupId = "test-group";
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("throws error when path parameter is missing", async () => {
+    await expect(executeCreateDirectory(mockDb, {}, groupId)).rejects.toThrow(
+      "Missing path parameter",
+    );
+  });
+
+  it("creates directory successfully", async () => {
+    (createGroupDirectory as jest.Mock<any>).mockResolvedValue(undefined);
+
+    const result = await executeCreateDirectory(
+      mockDb,
+      { path: "docs/images" },
+      groupId,
+    );
+    expect(result).toBe("Created directory docs/images");
+    expect(createGroupDirectory).toHaveBeenCalledWith(
+      mockDb,
+      groupId,
+      "docs/images",
+    );
+  });
+});