shadow-claw 1.23.4 → 1.24.0

package/src/worker/tools/bash/utils/waitForVMReady.test.ts

@@ -0,0 +1,40 @@
+import { jest } from "@jest/globals";
+
+const mockIsVMReady = jest.fn() as any;
+
+jest.unstable_mockModule("../../../../shell/vm.js", () => ({
+  isVMReady: mockIsVMReady,
+}));
+
+const { waitForVMReady } = await import("./waitForVMReady.js");
+
+describe("waitForVMReady", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("returns true immediately if VM is already ready", async () => {
+    mockIsVMReady.mockReturnValue(true);
+
+    const result = await waitForVMReady(1000);
+    expect(result).toBe(true);
+    expect(mockIsVMReady).toHaveBeenCalledTimes(1);
+  });
+
+  it("polls and returns true once VM becomes ready", async () => {
+    mockIsVMReady
+      .mockReturnValueOnce(false)
+      .mockReturnValueOnce(false)
+      .mockReturnValue(true);
+
+    const result = await waitForVMReady(500);
+    expect(result).toBe(true);
+  });
+
+  it("times out and returns false if VM never becomes ready", async () => {
+    mockIsVMReady.mockReturnValue(false);
+
+    const result = await waitForVMReady(50);
+    expect(result).toBe(false);
+  });
+});

package/src/worker/tools/email/email.test.ts

@@ -30,9 +30,14 @@ describe("worker/tools/email", () => {
             id: "imap",
             name: "IMAP",
             protocol: "imap",
-            actions: ["messages.read", "messages.send"],
+            actions: [
+              "messages.read",
+              "messages.send",
+              "messages.mark_read",
+              "messages.delete",
+            ],
             authTypes: ["basic_userpass", "oauth"],
-            configurableFields: [],
+            configurableFields: ["host", "port"],
           }
         : null,
     );
@@ -44,7 +49,7 @@ describe("worker/tools/email", () => {
         protocol: "imap",
         actions: ["messages.read", "messages.send"],
         authTypes: ["basic_userpass", "oauth"],
-        configurableFields: [],
+        configurableFields: ["host", "port"],
       },
     ]);
 
@@ -119,10 +124,52 @@ describe("worker/tools/email", () => {
 
   it("returns validation error when action is missing", async () => {
     const result = await executeManageEmailTool({} as any, {}, "group-1");
-
     expect(result).toContain("requires action");
   });
 
+  it("lists plugins, connections and status", async () => {
+    const plugins = await executeManageEmailTool(
+      {} as any,
+      { action: "list_plugins" },
+      "group-1",
+    );
+    expect(plugins).toContain("IMAP");
+
+    mockListEmailConnections.mockResolvedValueOnce([
+      {
+        id: "conn-1",
+        label: "Office 365",
+        pluginId: "imap",
+        enabled: true,
+        config: { host: "outlook.office365.com" },
+      },
+    ]);
+
+    const connections = await executeManageEmailTool(
+      {} as any,
+      { action: "list_connections" },
+      "group-1",
+    );
+    expect(connections).toContain("conn-1 (Office 365)");
+
+    mockListEmailConnections.mockResolvedValueOnce([
+      {
+        id: "conn-1",
+        label: "Office 365",
+        pluginId: "imap",
+        enabled: true,
+        config: {},
+      },
+    ]);
+
+    const status = await executeManageEmailTool(
+      {} as any,
+      { action: "status" },
+      "group-1",
+    );
+    expect(status).toContain("Configured plugin connections: 1");
+  });
+
   it("connect stores encrypted basic credentials", async () => {
     mockUpsertEmailConnection.mockResolvedValueOnce({
       id: "conn-1",
@@ -156,6 +203,70 @@ describe("worker/tools/email", () => {
     expect(result).toContain("Email connection created: conn-1");
   });
 
+  it("configure, enable, disable, delete and test connections", async () => {
+    const existingConn = {
+      id: "conn-cfg",
+      label: "Old Label",
+      pluginId: "imap",
+      enabled: false,
+      config: { host: "old.host" },
+      credentialRef: {
+        username: "user@mail.com",
+        encryptedSecret: "enc:oldpw",
+      },
+    };
+
+    mockGetEmailConnection.mockResolvedValue(existingConn);
+    mockUpsertEmailConnection.mockImplementation(
+      async (_db: any, val: any) => val,
+    );
+
+    // configure
+    const cfgResult = await executeManageEmailTool(
+      {} as any,
+      {
+        action: "configure",
+        connection_id: "conn-cfg",
+        label: "New Label",
+        enabled: true,
+      },
+      "group-1",
+    );
+    expect(cfgResult).toContain("Integration connection updated: conn-cfg");
+
+    // enable
+    const enableResult = await executeManageEmailTool(
+      {} as any,
+      { action: "enable", connection_id: "conn-cfg" },
+      "group-1",
+    );
+    expect(enableResult).toContain("enabled");
+
+    // disable
+    const disableResult = await executeManageEmailTool(
+      {} as any,
+      { action: "disable", connection_id: "conn-cfg" },
+      "group-1",
+    );
+    expect(disableResult).toContain("disabled");
+
+    // test
+    const testResult = await executeManageEmailTool(
+      {} as any,
+      { action: "test", connection_id: "conn-cfg" },
+      "group-1",
+    );
+    expect(testResult).toContain("passed for conn-cfg");
+
+    // delete
+    const deleteResult = await executeManageEmailTool(
+      {} as any,
+      { action: "delete", connection_id: "conn-cfg" },
+      "group-1",
+    );
+    expect(deleteResult).toContain("Integration connection deleted: conn-cfg");
+  });
+
   it("read_messages retries once after oauth 401", async () => {
     mockGetEmailConnection.mockResolvedValueOnce({
       id: "conn-oauth",
@@ -294,8 +405,8 @@ describe("worker/tools/email", () => {
     expect(parsed.saved_paths).toEqual(["downloads/email/x.txt"]);
   });
 
-  it("mark_as_read validates message_uids", async () => {
-    mockGetEmailConnection.mockResolvedValueOnce({
+  it("mark_as_read and delete_messages execute flag modifications and delete requests", async () => {
+    mockGetEmailConnection.mockResolvedValue({
       id: "conn-mark",
       pluginId: "imap",
       enabled: true,
@@ -307,15 +418,89 @@ describe("worker/tools/email", () => {
       },
     });
 
-    const result = await executeManageEmailTool(
+    // mark_as_read missing uids
+    const noUidResult = await executeManageEmailTool(
+      {} as any,
+      { action: "mark_as_read", connection_id: "conn-mark" },
+      "group-1",
+    );
+    expect(noUidResult).toContain("requires message_uids");
+
+    // mark_as_read success
+    (global.fetch as any).mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: async () => ({ updated: [101] }),
+    });
+
+    const markResult = await executeManageEmailTool(
       {} as any,
       {
         action: "mark_as_read",
         connection_id: "conn-mark",
+        message_uids: [101],
       },
       "group-1",
     );
+    expect(markResult).toContain('"updated": [');
+
+    // delete_messages success
+    (global.fetch as any).mockResolvedValueOnce({
+      ok: true,
+      status: 200,
+      json: async () => ({ deleted: [102] }),
+    });
+
+    const deleteMsgResult = await executeManageEmailTool(
+      {} as any,
+      {
+        action: "delete_messages",
+        connection_id: "conn-mark",
+        message_uids: [102],
+      },
+      "group-1",
+    );
+    expect(deleteMsgResult).toContain('"deleted": [');
+  });
+
+  it("parses email attachment inputs and guesses mime types correctly", async () => {
+    const { asEmailAttachmentInputs } =
+      await import("./utils/asEmailAttachmentInputs.js");
+    const { guessMimeTypeFromFilename } =
+      await import("./utils/guessMimeTypeFromFilename.js");
+
+    // asEmailAttachmentInputs
+    expect(asEmailAttachmentInputs(null)).toEqual([]);
+    expect(
+      asEmailAttachmentInputs([
+        "file1.txt",
+        "   ",
+        {
+          path: "file2.pdf",
+          filename: "doc.pdf",
+          content_type: "application/pdf",
+        },
+        { path: "" },
+        123,
+      ]),
+    ).toEqual([
+      { path: "file1.txt" },
+      {
+        path: "file2.pdf",
+        filename: "doc.pdf",
+        contentType: "application/pdf",
+      },
+    ]);
 
-    expect(result).toContain("requires message_uids");
+    // guessMimeTypeFromFilename
+    expect(guessMimeTypeFromFilename("photo.png")).toBe("image/png");
+    expect(guessMimeTypeFromFilename("photo.jpg")).toBe("image/jpeg");
+    expect(guessMimeTypeFromFilename("photo.jpeg")).toBe("image/jpeg");
+    expect(guessMimeTypeFromFilename("anim.gif")).toBe("image/gif");
+    expect(guessMimeTypeFromFilename("pic.webp")).toBe("image/webp");
+    expect(guessMimeTypeFromFilename("doc.pdf")).toBe("application/pdf");
+    expect(guessMimeTypeFromFilename("notes.txt")).toBe("text/plain");
+    expect(guessMimeTypeFromFilename("readme.md")).toBe("text/plain");
+    expect(guessMimeTypeFromFilename("archive.zip")).toBeUndefined();
   });
 });

package/src/worker/tools/email/utils/asEmailAttachmentInputs.test.ts

@@ -0,0 +1,47 @@
+import { asEmailAttachmentInputs } from "./asEmailAttachmentInputs.js";
+
+describe("asEmailAttachmentInputs", () => {
+  it("returns empty array for non-array inputs", () => {
+    expect(asEmailAttachmentInputs(null)).toEqual([]);
+    expect(asEmailAttachmentInputs(undefined)).toEqual([]);
+    expect(asEmailAttachmentInputs("file.txt")).toEqual([]);
+    expect(asEmailAttachmentInputs({ path: "file.txt" })).toEqual([]);
+  });
+
+  it("parses string attachment items", () => {
+    const input = ["file1.txt", "  ", "folder/file2.pdf"];
+    const result = asEmailAttachmentInputs(input);
+    expect(result).toEqual([
+      { path: "file1.txt" },
+      { path: "folder/file2.pdf" },
+    ]);
+  });
+
+  it("parses object attachment items with filename and content_type", () => {
+    const input = [
+      {
+        path: "docs/spec.pdf",
+        filename: "specs.pdf",
+        content_type: "application/pdf",
+      },
+      { path: "images/logo.png" },
+      { path: "   ", filename: "ignored.txt" },
+      null,
+      123,
+      { notPath: "ignored" },
+    ];
+    const result = asEmailAttachmentInputs(input);
+    expect(result).toEqual([
+      {
+        path: "docs/spec.pdf",
+        filename: "specs.pdf",
+        contentType: "application/pdf",
+      },
+      {
+        path: "images/logo.png",
+        filename: undefined,
+        contentType: undefined,
+      },
+    ]);
+  });
+});

package/src/worker/tools/git/git.test.ts

@@ -6,7 +6,11 @@ function makeDeps(overrides: Record<string, unknown> = {}) {
   return {
     getConfig: jest.fn(async () => undefined),
     getProxyUrl: jest.fn(() => "https://proxy.local"),
-    resolveGitCredentials: jest.fn(async () => ({ token: "tok" })),
+    resolveGitCredentials: jest.fn(async () => ({
+      token: "tok",
+      authorName: "Dev",
+      authorEmail: "dev@example.com",
+    })),
     gitClone: jest.fn(async () => "demo"),
     gitCheckout: jest.fn(async () => "checked out"),
     gitBranch: jest.fn(async () => "branched"),
@@ -22,6 +26,15 @@ function makeDeps(overrides: Record<string, unknown> = {}) {
     gitPush: jest.fn(async () => "pushed"),
     gitMerge: jest.fn(async () => "merged"),
     gitReset: jest.fn(async () => "reset"),
+    gitFetch: jest.fn(async () => "fetched"),
+    gitInit: jest.fn(async () => "initialized"),
+    gitTag: jest.fn(async () => "tagged"),
+    gitDeleteBranch: jest.fn(async () => "deleted branch"),
+    gitRemote: jest.fn(async () => "remote info"),
+    gitConfig: jest.fn(async () => "config val"),
+    gitUnstage: jest.fn(async () => "unstaged"),
+    gitShow: jest.fn(async () => "commit info"),
+    gitReadFileAtRef: jest.fn(async () => "file content"),
     getRemoteUrl: jest.fn(async () => "https://example.com/repo.git"),
     readGroupFile: jest.fn(async () => ""),
     getGroupDir: jest.fn(async () => ({}) as any),
@@ -131,7 +144,7 @@ describe("worker/tools/git", () => {
     expect(result).toBe("M file.ts");
   });
 
-  it("calls gitCommit directly", async () => {
+  it("calls gitCommit directly and passes author info", async () => {
     const deps = makeDeps({
       gitCommit: jest.fn(async () => "Committed abc1234: msg"),
     });
@@ -145,9 +158,16 @@ describe("worker/tools/git", () => {
     );
 
     expect(result).toContain("Committed");
+    expect(deps.gitCommit).toHaveBeenCalledWith(
+      expect.objectContaining({
+        authorName: "Dev",
+        authorEmail: "dev@example.com",
+        message: "msg",
+      }),
+    );
   });
 
-  it("returns missing-credentials message for git_push", async () => {
+  it("returns missing-credentials message for git_push when credentials missing", async () => {
     const deps = makeDeps({
       resolveGitCredentials: jest.fn(async () => ({})),
     });
@@ -163,6 +183,23 @@ describe("worker/tools/git", () => {
     expect(result).toContain("No git credentials configured");
   });
 
+  it("calls git_push with valid credentials", async () => {
+    const deps = makeDeps({
+      gitPush: jest.fn(async () => "Pushed main successfully"),
+    });
+
+    const result = await executeGitTool(
+      {} as any,
+      "git_push",
+      { repo: "demo", branch: "main" },
+      "group-1",
+      deps,
+    );
+
+    expect(result).toBe("Pushed main successfully");
+    expect(deps.gitPush).toHaveBeenCalled();
+  });
+
   it("formats merge conflicts with inline regions", async () => {
     const deps = makeDeps({
       gitMerge: jest.fn(async () => {
@@ -197,4 +234,178 @@ describe("worker/tools/git", () => {
     expect(result).toContain("Resolution steps:");
     expect(result).toContain("<<<<<<< ours");
   });
+
+  it("executes remaining git tool operations (add, branch, branches, checkout, config, etc.)", async () => {
+    const deps = makeDeps();
+
+    // git_add
+    await executeGitTool(
+      {} as any,
+      "git_add",
+      { repo: "demo", filepath: "file.txt" },
+      "group-1",
+      deps,
+    );
+    expect(deps.gitAdd).toHaveBeenCalled();
+
+    // git_branch
+    await executeGitTool(
+      {} as any,
+      "git_branch",
+      { repo: "demo", name: "feat" },
+      "group-1",
+      deps,
+    );
+    expect(deps.gitBranch).toHaveBeenCalled();
+
+    // git_branches
+    await executeGitTool(
+      {} as any,
+      "git_branches",
+      { repo: "demo" },
+      "group-1",
+      deps,
+    );
+    expect(deps.gitListBranches).toHaveBeenCalled();
+
+    // git_checkout
+    await executeGitTool(
+      {} as any,
+      "git_checkout",
+      { repo: "demo", ref: "main" },
+      "group-1",
+      deps,
+    );
+    expect(deps.gitCheckout).toHaveBeenCalled();
+
+    // git_config
+    await executeGitTool(
+      {} as any,
+      "git_config",
+      { repo: "demo", command: "get", key: "user.name" },
+      "group-1",
+      deps,
+    );
+    expect(deps.gitConfig).toHaveBeenCalled();
+
+    // git_delete_branch
+    await executeGitTool(
+      {} as any,
+      "git_delete_branch",
+      { repo: "demo", name: "old" },
+      "group-1",
+      deps,
+    );
+    expect(deps.gitDeleteBranch).toHaveBeenCalled();
+
+    // git_diff
+    await executeGitTool(
+      {} as any,
+      "git_diff",
+      { repo: "demo" },
+      "group-1",
+      deps,
+    );
+    expect(deps.gitDiff).toHaveBeenCalled();
+
+    // git_fetch
+    await executeGitTool(
+      {} as any,
+      "git_fetch",
+      { repo: "demo" },
+      "group-1",
+      deps,
+    );
+    expect(deps.gitFetch).toHaveBeenCalled();
+
+    // git_init
+    await executeGitTool(
+      {} as any,
+      "git_init",
+      { repo: "demo" },
+      "group-1",
+      deps,
+    );
+    expect(deps.gitInit).toHaveBeenCalled();
+
+    // git_log
+    await executeGitTool(
+      {} as any,
+      "git_log",
+      { repo: "demo" },
+      "group-1",
+      deps,
+    );
+    expect(deps.gitLog).toHaveBeenCalled();
+
+    // git_pull
+    await executeGitTool(
+      {} as any,
+      "git_pull",
+      { repo: "demo" },
+      "group-1",
+      deps,
+    );
+    expect(deps.gitPull).toHaveBeenCalled();
+
+    // git_read_file_at_ref
+    await executeGitTool(
+      {} as any,
+      "git_read_file_at_ref",
+      { repo: "demo", ref: "main", filepath: "a.ts" },
+      "group-1",
+      deps,
+    );
+    expect(deps.gitReadFileAtRef).toHaveBeenCalled();
+
+    // git_remote
+    await executeGitTool(
+      {} as any,
+      "git_remote",
+      { repo: "demo", command: "list" },
+      "group-1",
+      deps,
+    );
+    expect(deps.gitRemote).toHaveBeenCalled();
+
+    // git_reset
+    await executeGitTool(
+      {} as any,
+      "git_reset",
+      { repo: "demo", ref: "HEAD~1" },
+      "group-1",
+      deps,
+    );
+    expect(deps.gitReset).toHaveBeenCalled();
+
+    // git_show
+    await executeGitTool(
+      {} as any,
+      "git_show",
+      { repo: "demo", ref: "HEAD" },
+      "group-1",
+      deps,
+    );
+    expect(deps.gitShow).toHaveBeenCalled();
+
+    // git_tag
+    await executeGitTool(
+      {} as any,
+      "git_tag",
+      { repo: "demo", tag: "v1.0" },
+      "group-1",
+      deps,
+    );
+    expect(deps.gitTag).toHaveBeenCalled();
+
+    // git_unstage
+    await executeGitTool(
+      {} as any,
+      "git_unstage",
+      { repo: "demo", filepath: "a.ts" },
+      "group-1",
+      deps,
+    );
+    expect(deps.gitUnstage).toHaveBeenCalled();
+  });
 });

package/src/worker/tools/rooms/invite-to-room.test.ts

@@ -0,0 +1,54 @@
+import { jest } from "@jest/globals";
+
+jest.unstable_mockModule("../../utils/post.js", () => ({
+  post: jest.fn(),
+}));
+
+const { executeInviteToRoom } = await import("./invite-to-room.js");
+const { post } = await import("../../utils/post.js");
+
+describe("executeInviteToRoom", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("returns error when peer_id is missing", () => {
+    const result = executeInviteToRoom({}, "br:room-123");
+    expect(result).toBe("Error: peer_id is required to invite a participant.");
+    expect(post).not.toHaveBeenCalled();
+  });
+
+  it("returns error when room_id is missing and groupId is not a room", () => {
+    const result = executeInviteToRoom({ peer_id: "peer-abc" }, "default");
+    expect(result).toBe(
+      "Error: no room_id provided and the current conversation is not a room.",
+    );
+    expect(post).not.toHaveBeenCalled();
+  });
+
+  it("invites peer using explicit room_id", () => {
+    const result = executeInviteToRoom(
+      { peer_id: "peer-abc", room_id: "custom-room" },
+      "default",
+    );
+
+    expect(result).toBe("Invited peer peer-abc to room custom-room.");
+    expect(post).toHaveBeenCalledWith({
+      payload: { action: "invite", roomId: "custom-room", peerId: "peer-abc" },
+      type: "room-action",
+    });
+  });
+
+  it("invites peer inferring room from room groupId", () => {
+    const result = executeInviteToRoom(
+      { peer_id: "peer-xyz" },
+      "room:active-room",
+    );
+
+    expect(result).toBe("Invited peer peer-xyz to room active-room.");
+    expect(post).toHaveBeenCalledWith({
+      payload: { action: "invite", roomId: "active-room", peerId: "peer-xyz" },
+      type: "room-action",
+    });
+  });
+});

package/src/worker/tools/rooms/leave-room.test.ts

@@ -0,0 +1,40 @@
+import { jest } from "@jest/globals";
+
+jest.unstable_mockModule("../../utils/post.js", () => ({
+  post: jest.fn(),
+}));
+
+const { executeLeaveRoom } = await import("./leave-room.js");
+const { post } = await import("../../utils/post.js");
+
+describe("executeLeaveRoom", () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it("returns error when room_id is missing and groupId is not a room", () => {
+    const result = executeLeaveRoom({}, "main-group");
+    expect(result).toBe(
+      "Error: no room_id provided and the current conversation is not a room.",
+    );
+    expect(post).not.toHaveBeenCalled();
+  });
+
+  it("leaves room with explicit room_id", () => {
+    const result = executeLeaveRoom({ room_id: "room-abc" }, "main-group");
+    expect(result).toBe("Leaving room room-abc.");
+    expect(post).toHaveBeenCalledWith({
+      payload: { action: "leave", roomId: "room-abc" },
+      type: "room-action",
+    });
+  });
+
+  it("leaves room inferring room from room groupId", () => {
+    const result = executeLeaveRoom({}, "room:current-room");
+    expect(result).toBe("Leaving room current-room.");
+    expect(post).toHaveBeenCalledWith({
+      payload: { action: "leave", roomId: "current-room" },
+      type: "room-action",
+    });
+  });
+});