shadow-claw 1.23.3 → 1.24.0

package/src/worker/tools/rooms/list-room-members.test.ts

@@ -0,0 +1,75 @@
+import { jest } from "@jest/globals";
+
+jest.unstable_mockModule("../../../db/rooms.js", () => ({
+  ROOM_PREFIX: "room:",
+  roomIdFromGroupId: (g: string) => g.replace(/^room:/, ""),
+  getRoomMetadata: jest.fn(),
+}));
+
+const { executeListRoomMembers } = await import("./list-room-members.js");
+const { getRoomMetadata } = await import("../../../db/rooms.js");
+
+describe("executeListRoomMembers", () => {
+  const mockDb: any = {};
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("returns error when room_id is missing and groupId is not a room", async () => {
+    const result = await executeListRoomMembers(mockDb, {}, "not-a-room");
+    expect(result).toBe(
+      "Error: no room_id provided and the current conversation is not a room.",
+    );
+  });
+
+  it("returns error when room is not found in database", async () => {
+    (getRoomMetadata as jest.Mock<any>).mockResolvedValue([]);
+
+    const result = await executeListRoomMembers(
+      mockDb,
+      { room_id: "missing-room" },
+      "default",
+    );
+    expect(result).toBe("Error: room missing-room was not found.");
+  });
+
+  it("handles room with no members", async () => {
+    (getRoomMetadata as jest.Mock<any>).mockResolvedValue([
+      { roomId: "room-1", name: "Empty Room", members: [] },
+    ]);
+
+    const result = await executeListRoomMembers(
+      mockDb,
+      { room_id: "room-1" },
+      "default",
+    );
+    expect(result).toBe('Room "Empty Room" (room-1) has no members yet.');
+  });
+
+  it("formats members list including agents and hosts", async () => {
+    (getRoomMetadata as jest.Mock<any>).mockResolvedValue([
+      {
+        roomId: "room-1",
+        name: "Dev Team",
+        hostPeerId: "peer-host",
+        members: [
+          { peerId: "peer-host", alias: "Host Alice", kind: "human" },
+          {
+            peerId: "peer-bot",
+            alias: "Assistant Bot",
+            kind: "agent",
+            agentName: "coder",
+          },
+        ],
+      },
+    ]);
+
+    const result = await executeListRoomMembers(mockDb, {}, "room:room-1");
+    expect(result).toContain('Room "Dev Team" (room-1) members:');
+    expect(result).toContain("- Host Alice — human [host] (peer: peer-host)");
+    expect(result).toContain(
+      "- Assistant Bot — agent (@coder) (peer: peer-bot)",
+    );
+  });
+});

package/src/worker/tools/tasks/tasks-utils.test.ts

@@ -0,0 +1,22 @@
+import { jest } from "@jest/globals";
+
+jest.unstable_mockModule("../../../db/getAllTasks.js", () => ({
+  getAllTasks: jest.fn(),
+}));
+
+const { getGroupTasks } = await import("./tasks-utils.js");
+const { getAllTasks } = await import("../../../db/getAllTasks.js");
+
+describe("getGroupTasks", () => {
+  it("filters tasks by groupId", async () => {
+    (getAllTasks as jest.Mock<any>).mockResolvedValue([
+      { id: "task-1", groupId: "group-a", title: "Task 1" },
+      { id: "task-2", groupId: "group-b", title: "Task 2" },
+      { id: "task-3", groupId: "group-a", title: "Task 3" },
+    ]);
+
+    const result = await getGroupTasks({} as any, "group-a");
+    expect(result).toHaveLength(2);
+    expect(result.map((t) => t.id)).toEqual(["task-1", "task-3"]);
+  });
+});

package/src/worker/tools/ui/ask-user.test.ts

@@ -0,0 +1,50 @@
+import { jest } from "@jest/globals";
+
+jest.unstable_mockModule("../../utils/post.js", () => ({
+  post: jest.fn(),
+}));
+
+jest.unstable_mockModule("../../../utils/ulid.js", () => ({
+  ulid: jest.fn(() => "mock-ask-id"),
+}));
+
+const { executeAskUser } = await import("./ask-user.js");
+const { post } = await import("../../utils/post.js");
+
+describe("executeAskUser", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+    (globalThis as any).pendingAskUserResolvers = {};
+  });
+
+  it("returns error when question is missing", async () => {
+    const result = await executeAskUser({}, "group-1");
+    expect(result).toBe("Error: question is required.");
+    expect(post).not.toHaveBeenCalled();
+  });
+
+  it("posts ask-user message and resolves when resolver is invoked", async () => {
+    const askPromise = executeAskUser(
+      { question: "Do you want to proceed?", options: ["Yes", "No"] },
+      "group-1",
+    );
+
+    expect(post).toHaveBeenCalledWith({
+      type: "ask-user",
+      payload: {
+        id: "mock-ask-id",
+        groupId: "group-1",
+        question: "Do you want to proceed?",
+        options: ["Yes", "No"],
+      },
+    });
+
+    const resolver = (globalThis as any).pendingAskUserResolvers["mock-ask-id"];
+    expect(typeof resolver).toBe("function");
+
+    resolver("User selected: Yes");
+
+    const result = await askPromise;
+    expect(result).toBe("User selected: Yes");
+  });
+});

package/src/worker/tools/ui/clear-chat.test.ts

@@ -0,0 +1,19 @@
+import { jest } from "@jest/globals";
+
+jest.unstable_mockModule("../../utils/post.js", () => ({
+  post: jest.fn(),
+}));
+
+const { executeClearChat } = await import("./clear-chat.js");
+const { post } = await import("../../utils/post.js");
+
+describe("executeClearChat", () => {
+  it("posts clear-chat message and returns confirmation", () => {
+    const result = executeClearChat("group-123");
+    expect(result).toContain("Chat history cleared successfully");
+    expect(post).toHaveBeenCalledWith({
+      type: "clear-chat",
+      payload: { groupId: "group-123" },
+    });
+  });
+});

package/src/worker/tools/ui/get-current-time.test.ts

@@ -0,0 +1,19 @@
+import { executeGetCurrentTime } from "./get-current-time.js";
+
+describe("executeGetCurrentTime", () => {
+  it("returns ISO string when timezone is not provided", () => {
+    const result = executeGetCurrentTime({});
+    expect(result).toMatch(/^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/);
+  });
+
+  it("returns formatted date and time when valid timezone is provided", () => {
+    const result = executeGetCurrentTime({ timezone: "America/New_York" });
+    expect(typeof result).toBe("string");
+    expect(result.length).toBeGreaterThan(0);
+  });
+
+  it("returns error string when invalid timezone is provided", () => {
+    const result = executeGetCurrentTime({ timezone: "NonExistent/Timezone" });
+    expect(result).toContain("Error: Invalid timezone NonExistent/Timezone");
+  });
+});

package/src/worker/tools/ui/javascript.test.ts

@@ -0,0 +1,116 @@
+import { jest } from "@jest/globals";
+
+jest.unstable_mockModule("../../utils/sandboxedEval.js", () => ({
+  sandboxedEval: jest.fn(),
+}));
+
+jest.unstable_mockModule("./utils/getAllowFullInternetAccess.js", () => ({
+  getAllowFullInternetAccess: jest.fn<any>().mockResolvedValue(false),
+}));
+
+const { executeJavascript } = await import("./javascript.js");
+const { sandboxedEval } = await import("../../utils/sandboxedEval.js");
+
+describe("executeJavascript", () => {
+  const mockDb: any = {};
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("evaluates simple expression returning number", async () => {
+    (sandboxedEval as jest.Mock<any>).mockResolvedValue({
+      ok: true,
+      value: 42,
+    });
+
+    const result = await executeJavascript(mockDb, { code: "1 + 41" });
+    expect(result).toBe("42");
+    expect(sandboxedEval).toHaveBeenCalledWith(
+      "return (1 + 41);",
+      undefined,
+      false,
+      undefined,
+    );
+  });
+
+  it("handles explicit return statements", async () => {
+    (sandboxedEval as jest.Mock<any>).mockResolvedValue({
+      ok: true,
+      value: "hello",
+    });
+
+    const result = await executeJavascript(mockDb, {
+      code: "const x = 'hello'; return x;",
+    });
+    expect(result).toBe("hello");
+    expect(sandboxedEval).toHaveBeenCalledWith(
+      "const x = 'hello'; return x;",
+      undefined,
+      false,
+      undefined,
+    );
+  });
+
+  it("handles object return values by formatting as JSON", async () => {
+    (sandboxedEval as jest.Mock<any>).mockResolvedValue({
+      ok: true,
+      value: { name: "Alice", age: 30 },
+    });
+
+    const result = await executeJavascript(mockDb, {
+      code: "({ name: 'Alice', age: 30 })",
+    });
+    expect(JSON.parse(result)).toEqual({ name: "Alice", age: 30 });
+  });
+
+  it("returns null representation for null values", async () => {
+    (sandboxedEval as jest.Mock<any>).mockResolvedValue({
+      ok: true,
+      value: null,
+    });
+
+    const result = await executeJavascript(mockDb, { code: "null" });
+    expect(result).toBe("null");
+  });
+
+  it("provides hint when evaluation returns undefined", async () => {
+    (sandboxedEval as jest.Mock<any>).mockResolvedValue({
+      ok: true,
+      value: undefined,
+    });
+
+    const result = await executeJavascript(mockDb, { code: "const a = 1;" });
+    expect(result).toContain("(no return value)");
+    expect(result).toContain("Hint: Your code did not return a value");
+  });
+
+  it("reports JavaScript errors", async () => {
+    (sandboxedEval as jest.Mock<any>).mockResolvedValue({
+      ok: false,
+      error: "ReferenceError: foo is not defined",
+    });
+
+    const result = await executeJavascript(mockDb, { code: "foo" });
+    expect(result).toBe("JavaScript error: ReferenceError: foo is not defined");
+  });
+
+  it("falls back to raw code when wrapping in return produces syntax error", async () => {
+    (sandboxedEval as jest.Mock<any>)
+      .mockResolvedValueOnce({
+        ok: false,
+        error: "SyntaxError: Unexpected token 'for'",
+      })
+      .mockResolvedValueOnce({
+        ok: true,
+        value: undefined,
+      });
+
+    const result = await executeJavascript(mockDb, {
+      code: "for (let i = 0; i < 5; i++) { /* do work */ }",
+    });
+
+    expect(sandboxedEval).toHaveBeenCalledTimes(2);
+    expect(result).toContain("(no return value)");
+  });
+});

package/src/worker/tools/ui/list-components.test.ts

@@ -0,0 +1,10 @@
+import { BASIC_CATALOG_REFERENCE } from "../../../ui/a2ui/types.js";
+import { executeListComponents } from "./list-components.js";
+
+describe("executeListComponents", () => {
+  it("returns the basic catalog reference string", () => {
+    const result = executeListComponents();
+    expect(result).toBe(BASIC_CATALOG_REFERENCE);
+    expect(result).toContain("A2UI Basic Catalog");
+  });
+});

package/src/worker/tools/ui/list-tool-profiles.test.ts

@@ -0,0 +1,42 @@
+import { jest } from "@jest/globals";
+
+jest.unstable_mockModule("../../../db/getConfig.js", () => ({
+  getConfig: jest.fn(),
+}));
+
+const { executeListToolProfiles } = await import("./list-tool-profiles.js");
+const { getConfig } = await import("../../../db/getConfig.js");
+
+describe("executeListToolProfiles", () => {
+  const mockDb: any = {};
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("lists default profile when no custom profiles in DB", async () => {
+    (getConfig as jest.Mock<any>).mockResolvedValue(null);
+
+    const result = await executeListToolProfiles(mockDb);
+    expect(result).toContain("[Profile ID: __builtin_default]");
+    expect(result).toContain("Tools:");
+  });
+
+  it("includes custom profiles when stored in DB as JSON string or array", async () => {
+    const customProfiles = [
+      {
+        id: "coding",
+        name: "Coding Profile",
+        enabledToolNames: ["bash", "read_file", "write_file"],
+      },
+    ];
+    (getConfig as jest.Mock<any>).mockResolvedValue(
+      JSON.stringify(customProfiles),
+    );
+
+    const result = await executeListToolProfiles(mockDb);
+    expect(result).toContain("[Profile ID: __builtin_default]");
+    expect(result).toContain("[Profile ID: coding] Coding Profile");
+    expect(result).toContain("Tools: bash, read_file, write_file");
+  });
+});

package/src/worker/tools/ui/manage-tools.test.ts

@@ -0,0 +1,34 @@
+import { jest } from "@jest/globals";
+
+jest.unstable_mockModule("../../utils/post.js", () => ({
+  post: jest.fn(),
+}));
+
+const { executeManageTools } = await import("./manage-tools.js");
+const { post } = await import("../../utils/post.js");
+
+describe("executeManageTools", () => {
+  it("posts manage-tools message with action and tool details", () => {
+    const result = executeManageTools(
+      {
+        action: "enable",
+        tool_names: ["git_status", "git_commit"],
+        profile_id: "git-dev",
+      },
+      "group-456",
+    );
+
+    expect(result).toContain(
+      "Tool management request sent: enable git-dev (git_status, git_commit)",
+    );
+    expect(post).toHaveBeenCalledWith({
+      type: "manage-tools",
+      payload: {
+        action: "enable",
+        groupId: "group-456",
+        profileId: "git-dev",
+        toolNames: ["git_status", "git_commit"],
+      },
+    });
+  });
+});