shadow-claw 1.40.0 → 1.40.1

package/src/worker/tools/tasks/update-task.test.ts

@@ -1,15 +1,28 @@
-import { jest } from "@jest/globals";
+import { beforeEach, describe, expect, it, jest } from "@jest/globals";
+import type { ShadowClawDatabase } from "../../../db/types.js";
+
+interface TaskRecord {
+  id: string;
+  schedule?: string;
+  type?: string;
+  prompt?: string;
+  tools?: string[];
+  enabled?: boolean;
+  name?: string;
+}
+
+const mockPost =
+  jest.fn<(msg: { type: string; payload: { task: TaskRecord } }) => void>();
+const mockGetGroupTasks = jest.fn<() => Promise<TaskRecord[]>>();
 
 jest.unstable_mockModule("../../utils/post.js", () => ({
-  post: jest.fn(),
+  post: mockPost,
 }));
 
 jest.unstable_mockModule("./tasks-utils.js", () => ({
-  getGroupTasks: jest.fn(),
+  getGroupTasks: mockGetGroupTasks,
 }));
 
-const { post } = await import("../../utils/post.js");
-const { getGroupTasks } = await import("./tasks-utils.js");
 const { executeUpdateTask } = await import("./update-task.js");
 
 describe("executeUpdateTask", () => {
@@ -18,18 +31,18 @@ describe("executeUpdateTask", () => {
   });
 
   it("returns error if task not found", async () => {
-    (getGroupTasks as jest.Mock<any>).mockResolvedValue([{ id: "task-2" }]);
+    mockGetGroupTasks.mockResolvedValue([{ id: "task-2" }]);
     const result = await executeUpdateTask(
-      {} as any,
+      {} as ShadowClawDatabase,
       { id: "task-1" },
       "group-1",
     );
     expect(result).toBe("Error: Task with ID task-1 not found.");
-    expect(post).not.toHaveBeenCalled();
+    expect(mockPost).not.toHaveBeenCalled();
   });
 
-  it("updates task successfully", async () => {
-    const mockTask = {
+  it("updates all provided fields successfully", async () => {
+    const mockTask: TaskRecord = {
       id: "task-1",
       schedule: "* * * * *",
       type: "prompt",
@@ -38,10 +51,10 @@ describe("executeUpdateTask", () => {
       enabled: false,
       name: "old name",
     };
-    (getGroupTasks as jest.Mock<any>).mockResolvedValue([mockTask]);
+    mockGetGroupTasks.mockResolvedValue([mockTask]);
 
     const result = await executeUpdateTask(
-      {} as any,
+      {} as ShadowClawDatabase,
       {
         id: "task-1",
         schedule: "0 0 * * *",
@@ -49,7 +62,7 @@ describe("executeUpdateTask", () => {
         prompt: "new prompt",
         tools: ["tool1"],
         enabled: true,
-        name: "new name",
+        name: "  new name  ",
       },
       "group-1",
     );
@@ -61,10 +74,61 @@ describe("executeUpdateTask", () => {
     expect(mockTask.enabled).toBe(true);
     expect(mockTask.name).toBe("new name");
 
-    expect(post).toHaveBeenCalledWith({
+    expect(mockPost).toHaveBeenCalledWith({
       type: "update-task",
       payload: { task: mockTask },
     });
     expect(result).toBe("Task task-1 updated successfully.");
   });
+
+  it("preserves unchanged fields when optional fields are omitted or type is prompt/invalid", async () => {
+    const mockTask: TaskRecord = {
+      id: "task-1",
+      schedule: "original-schedule",
+      type: "tools",
+      prompt: "original-prompt",
+      tools: ["t0"],
+      enabled: true,
+      name: "original-name",
+    };
+    mockGetGroupTasks.mockResolvedValue([mockTask]);
+
+    // Update with type "prompt", tools not an array, non-string name
+    const result = await executeUpdateTask(
+      {} as ShadowClawDatabase,
+      {
+        id: "task-1",
+        type: "prompt",
+        name: null,
+      },
+      "group-1",
+    );
+
+    expect(mockTask.schedule).toBe("original-schedule");
+    expect(mockTask.type).toBe("prompt");
+    expect(mockTask.prompt).toBe("original-prompt");
+    expect(mockTask.tools).toEqual(["t0"]);
+    expect(mockTask.enabled).toBe(true);
+    expect(mockTask.name).toBeUndefined();
+    expect(result).toBe("Task task-1 updated successfully.");
+  });
+
+  it("ignores unknown type values", async () => {
+    const mockTask: TaskRecord = {
+      id: "task-1",
+      type: "tools",
+    };
+    mockGetGroupTasks.mockResolvedValue([mockTask]);
+
+    await executeUpdateTask(
+      {} as ShadowClawDatabase,
+      {
+        id: "task-1",
+        type: "unknown-type",
+      },
+      "group-1",
+    );
+
+    expect(mockTask.type).toBe("tools");
+  });
 });

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

@@ -1,32 +1,51 @@
-import { jest } from "@jest/globals";
+import { beforeEach, describe, expect, it, jest } from "@jest/globals";
+import type { ShadowClawDatabase } from "../../../db/types.js";
+
+interface SandboxedEvalResult {
+  ok: boolean;
+  value?: unknown;
+  error?: string;
+}
+
+const mockSandboxedEval =
+  jest.fn<
+    (
+      code?: string,
+      context?: unknown,
+      allowInternet?: boolean,
+      data?: unknown,
+    ) => Promise<SandboxedEvalResult | null>
+  >();
+const mockGetAllowFullInternetAccess = jest
+  .fn<() => Promise<boolean>>()
+  .mockResolvedValue(false);
 
 jest.unstable_mockModule("../../utils/sandboxedEval.js", () => ({
-  sandboxedEval: jest.fn(),
+  sandboxedEval: mockSandboxedEval,
 }));
 
 jest.unstable_mockModule("../utils/getAllowFullInternetAccess.js", () => ({
-  getAllowFullInternetAccess: jest.fn<any>().mockResolvedValue(false),
+  getAllowFullInternetAccess: mockGetAllowFullInternetAccess,
 }));
 
 const { executeJavascript } = await import("./javascript.js");
-const { sandboxedEval } = await import("../../utils/sandboxedEval.js");
 
 describe("executeJavascript", () => {
-  const mockDb: any = {};
+  const mockDb = {} as ShadowClawDatabase;
 
   beforeEach(() => {
     jest.clearAllMocks();
   });
 
   it("evaluates simple expression returning number", async () => {
-    (sandboxedEval as jest.Mock<any>).mockResolvedValue({
+    mockSandboxedEval.mockResolvedValue({
       ok: true,
       value: 42,
     });
 
     const result = await executeJavascript(mockDb, { code: "1 + 41" });
     expect(result).toBe("42");
-    expect(sandboxedEval).toHaveBeenCalledWith(
+    expect(mockSandboxedEval).toHaveBeenCalledWith(
       "return (1 + 41);",
       undefined,
       false,
@@ -35,7 +54,7 @@ describe("executeJavascript", () => {
   });
 
   it("handles explicit return statements", async () => {
-    (sandboxedEval as jest.Mock<any>).mockResolvedValue({
+    mockSandboxedEval.mockResolvedValue({
       ok: true,
       value: "hello",
     });
@@ -44,7 +63,7 @@ describe("executeJavascript", () => {
       code: "const x = 'hello'; return x;",
     });
     expect(result).toBe("hello");
-    expect(sandboxedEval).toHaveBeenCalledWith(
+    expect(mockSandboxedEval).toHaveBeenCalledWith(
       "const x = 'hello'; return x;",
       undefined,
       false,
@@ -53,7 +72,7 @@ describe("executeJavascript", () => {
   });
 
   it("handles object return values by formatting as JSON", async () => {
-    (sandboxedEval as jest.Mock<any>).mockResolvedValue({
+    mockSandboxedEval.mockResolvedValue({
       ok: true,
       value: { name: "Alice", age: 30 },
     });
@@ -64,8 +83,21 @@ describe("executeJavascript", () => {
     expect(JSON.parse(result)).toEqual({ name: "Alice", age: 30 });
   });
 
+  it("falls back to String representation when object serialization throws", async () => {
+    const circular: Record<string, unknown> = {};
+    circular.self = circular;
+
+    mockSandboxedEval.mockResolvedValue({
+      ok: true,
+      value: circular,
+    });
+
+    const result = await executeJavascript(mockDb, { code: "circular" });
+    expect(result).toBe("[object Object]");
+  });
+
   it("returns null representation for null values", async () => {
-    (sandboxedEval as jest.Mock<any>).mockResolvedValue({
+    mockSandboxedEval.mockResolvedValue({
       ok: true,
       value: null,
     });
@@ -74,8 +106,8 @@ describe("executeJavascript", () => {
     expect(result).toBe("null");
   });
 
-  it("provides hint when evaluation returns undefined", async () => {
-    (sandboxedEval as jest.Mock<any>).mockResolvedValue({
+  it("provides hint when evaluation returns undefined or __UNDEFINED__", async () => {
+    mockSandboxedEval.mockResolvedValue({
       ok: true,
       value: undefined,
     });
@@ -83,20 +115,41 @@ describe("executeJavascript", () => {
     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");
+
+    mockSandboxedEval.mockResolvedValue({
+      ok: true,
+      value: "__UNDEFINED__",
+    });
+
+    const resultUndefStr = await executeJavascript(mockDb, {
+      code: "undefined",
+    });
+    expect(resultUndefStr).toContain("(no return value)");
   });
 
-  it("reports JavaScript errors", async () => {
-    (sandboxedEval as jest.Mock<any>).mockResolvedValue({
+  it("reports JavaScript errors and falls back to Unknown error when error is missing", async () => {
+    mockSandboxedEval.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");
+
+    mockSandboxedEval.mockResolvedValue({
+      ok: false,
+    });
+
+    const resultUnknown = await executeJavascript(mockDb, { code: "fail" });
+    expect(resultUnknown).toBe("JavaScript error: Unknown error");
+
+    mockSandboxedEval.mockResolvedValue(null);
+    const resultNull = await executeJavascript(mockDb, { code: "fail" });
+    expect(resultNull).toBe("JavaScript error: Unknown error");
   });
 
   it("falls back to raw code when wrapping in return produces syntax error", async () => {
-    (sandboxedEval as jest.Mock<any>)
+    mockSandboxedEval
       .mockResolvedValueOnce({
         ok: false,
         error: "SyntaxError: Unexpected token 'for'",
@@ -110,7 +163,7 @@ describe("executeJavascript", () => {
       code: "for (let i = 0; i < 5; i++) { /* do work */ }",
     });
 
-    expect(sandboxedEval).toHaveBeenCalledTimes(2);
+    expect(mockSandboxedEval).toHaveBeenCalledTimes(2);
     expect(result).toContain("(no return value)");
   });
 });

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

@@ -1,28 +1,30 @@
-import { jest } from "@jest/globals";
+import { beforeEach, describe, expect, it, jest } from "@jest/globals";
+import type { ShadowClawDatabase } from "../../../db/types.js";
+
+const mockGetConfig = jest.fn<() => Promise<unknown>>();
 
 jest.unstable_mockModule("../../../db/getConfig.js", () => ({
-  getConfig: jest.fn(),
+  getConfig: mockGetConfig,
 }));
 
 const { executeListToolProfiles } = await import("./list-tool-profiles.js");
-const { getConfig } = await import("../../../db/getConfig.js");
 
 describe("executeListToolProfiles", () => {
-  const mockDb: any = {};
+  const mockDb = {} as ShadowClawDatabase;
 
   beforeEach(() => {
     jest.clearAllMocks();
   });
 
   it("lists default profile when no custom profiles in DB", async () => {
-    (getConfig as jest.Mock<any>).mockResolvedValue(null);
+    mockGetConfig.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 () => {
+  it("includes custom profiles when stored in DB as JSON string", async () => {
     const customProfiles = [
       {
         id: "coding",
@@ -30,13 +32,33 @@ describe("executeListToolProfiles", () => {
         enabledToolNames: ["bash", "read_file", "write_file"],
       },
     ];
-    (getConfig as jest.Mock<any>).mockResolvedValue(
-      JSON.stringify(customProfiles),
-    );
+    mockGetConfig.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");
   });
+
+  it("handles custom profiles when stored directly as an array in DB", async () => {
+    const customProfiles = [
+      {
+        id: "research",
+        name: "Research Profile",
+        enabledToolNames: ["web_search"],
+      },
+    ];
+    mockGetConfig.mockResolvedValue(customProfiles);
+
+    const result = await executeListToolProfiles(mockDb);
+    expect(result).toContain("[Profile ID: research] Research Profile");
+    expect(result).toContain("Tools: web_search");
+  });
+
+  it("handles corrupted JSON gracefully", async () => {
+    mockGetConfig.mockResolvedValue("{ not valid json");
+
+    const result = await executeListToolProfiles(mockDb);
+    expect(result).toContain("[Profile ID: __builtin_default]");
+  });
 });