Vendor OpenClaw source as Adolf fork baseline

Adolf is a fork/vendored clone of github.com/openclaw/openclaw (v2026.6.11),
free to diverge. Tree copied sans upstream .git; upstream remote added for
future syncs. Node pinned to 24 (.nvmrc); engines already require >=22.19.
Preserves docs/ARCHITECTURE.md.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01LeqyaxJF2nbRXJtae2kNB2

extensions/feishu/src/chat.test.ts

@@ -0,0 +1,295 @@
+// Feishu tests cover chat plugin behavior.
+import { createTestPluginApi } from "openclaw/plugin-sdk/plugin-test-api";
+import { afterAll, beforeAll, beforeEach, describe, expect, it, vi } from "vitest";
+import type { OpenClawPluginApi, PluginRuntime } from "../runtime-api.js";
+
+const createFeishuClientMock = vi.hoisted(() => vi.fn());
+const chatGetMock = vi.hoisted(() => vi.fn());
+const chatMembersGetMock = vi.hoisted(() => vi.fn());
+const contactUserGetMock = vi.hoisted(() => vi.fn());
+
+vi.mock("./client.js", () => ({
+  createFeishuClient: createFeishuClientMock,
+}));
+
+let registerFeishuChatTools: typeof import("./chat.js").registerFeishuChatTools;
+
+function createFeishuToolRuntime(): PluginRuntime {
+  return {} as PluginRuntime;
+}
+
+describe("registerFeishuChatTools", () => {
+  function createChatToolApi(params: {
+    config: OpenClawPluginApi["config"];
+    registerTool: OpenClawPluginApi["registerTool"];
+  }): OpenClawPluginApi {
+    return createTestPluginApi({
+      id: "feishu-test",
+      name: "Feishu Test",
+      source: "local",
+      config: params.config,
+      runtime: createFeishuToolRuntime(),
+      logger: { debug: vi.fn(), info: vi.fn(), warn: vi.fn(), error: vi.fn() },
+      registerTool: params.registerTool,
+    });
+  }
+
+  beforeAll(async () => {
+    ({ registerFeishuChatTools } = await import("./chat.js"));
+  });
+
+  afterAll(() => {
+    vi.doUnmock("./client.js");
+    vi.resetModules();
+  });
+
+  beforeEach(() => {
+    vi.clearAllMocks();
+    createFeishuClientMock.mockReturnValue({
+      im: {
+        chat: { get: chatGetMock },
+        chatMembers: { get: chatMembersGetMock },
+      },
+      contact: {
+        user: { get: contactUserGetMock },
+      },
+    });
+  });
+
+  it("registers feishu_chat and handles info/members actions", async () => {
+    const registerTool = vi.fn();
+    registerFeishuChatTools(
+      createChatToolApi({
+        config: {
+          channels: {
+            feishu: {
+              enabled: true,
+              appId: "app_id",
+              appSecret: "app_secret", // pragma: allowlist secret
+              tools: { chat: true },
+            },
+          },
+        },
+        registerTool,
+      }),
+    );
+
+    expect(registerTool).toHaveBeenCalledTimes(1);
+    const tool = registerTool.mock.calls[0]?.[0];
+    expect(tool?.name).toBe("feishu_chat");
+
+    chatGetMock.mockResolvedValueOnce({
+      code: 0,
+      data: { name: "group name", user_count: 3 },
+    });
+    const infoResult = await tool.execute("tc_1", { action: "info", chat_id: "oc_1" });
+    expect(infoResult.details).toEqual({
+      chat_id: "oc_1",
+      name: "group name",
+      description: undefined,
+      owner_id: undefined,
+      tenant_key: undefined,
+      user_count: 3,
+      chat_mode: undefined,
+      chat_type: undefined,
+      join_message_visibility: undefined,
+      leave_message_visibility: undefined,
+      membership_approval: undefined,
+      moderation_permission: undefined,
+      avatar: undefined,
+    });
+
+    chatMembersGetMock.mockResolvedValueOnce({
+      code: 0,
+      data: {
+        has_more: false,
+        page_token: "",
+        items: [{ member_id: "ou_1", name: "member1", member_id_type: "open_id" }],
+      },
+    });
+    const membersResult = await tool.execute("tc_2", { action: "members", chat_id: "oc_1" });
+    expect(membersResult.details).toEqual({
+      chat_id: "oc_1",
+      has_more: false,
+      page_token: "",
+      members: [
+        {
+          member_id: "ou_1",
+          name: "member1",
+          tenant_key: undefined,
+          member_id_type: "open_id",
+        },
+      ],
+    });
+
+    contactUserGetMock.mockResolvedValueOnce({
+      code: 0,
+      data: {
+        user: {
+          open_id: "ou_1",
+          name: "member1",
+          email: "member1@example.com",
+          department_ids: ["od_1"],
+        },
+      },
+    });
+    const memberInfoResult = await tool.execute("tc_3", {
+      action: "member_info",
+      member_id: "ou_1",
+    });
+    expect(memberInfoResult.details).toEqual({
+      member_id: "ou_1",
+      member_id_type: "open_id",
+      open_id: "ou_1",
+      user_id: undefined,
+      union_id: undefined,
+      name: "member1",
+      en_name: undefined,
+      nickname: undefined,
+      email: "member1@example.com",
+      enterprise_email: undefined,
+      mobile: undefined,
+      mobile_visible: undefined,
+      status: undefined,
+      avatar: undefined,
+      department_ids: ["od_1"],
+      department_path: undefined,
+      leader_user_id: undefined,
+      city: undefined,
+      country: undefined,
+      work_station: undefined,
+      join_time: undefined,
+      is_tenant_manager: undefined,
+      employee_no: undefined,
+      employee_type: undefined,
+      description: undefined,
+      job_title: undefined,
+      geo: undefined,
+    });
+  });
+
+  it("advertises and validates member page_size as a positive integer", async () => {
+    const registerTool = vi.fn();
+    registerFeishuChatTools(
+      createChatToolApi({
+        config: {
+          channels: {
+            feishu: {
+              enabled: true,
+              appId: "app_id",
+              appSecret: "app_secret", // pragma: allowlist secret
+              tools: { chat: true },
+            },
+          },
+        },
+        registerTool,
+      }),
+    );
+
+    const tool = registerTool.mock.calls[0]?.[0];
+    expect(tool?.parameters.properties.page_size).toMatchObject({
+      type: "integer",
+      minimum: 1,
+      maximum: 100,
+    });
+
+    chatMembersGetMock.mockResolvedValueOnce({
+      code: 0,
+      data: { has_more: false, items: [] },
+    });
+    await tool.execute("tc_page_size_string", {
+      action: "members",
+      chat_id: "oc_1",
+      page_size: "25",
+    });
+    expect(chatMembersGetMock).toHaveBeenLastCalledWith({
+      path: { chat_id: "oc_1" },
+      params: {
+        page_size: 25,
+        page_token: undefined,
+        member_id_type: "open_id",
+      },
+    });
+
+    const invalidResult = await tool.execute("tc_page_size_invalid", {
+      action: "members",
+      chat_id: "oc_1",
+      page_size: 0,
+    });
+    expect(invalidResult.details.error).toContain(
+      "page_size must be a positive integer between 1 and 100",
+    );
+    expect(chatMembersGetMock).toHaveBeenCalledTimes(1);
+  });
+
+  it("skips registration when chat tool is disabled", () => {
+    const registerTool = vi.fn();
+    registerFeishuChatTools(
+      createChatToolApi({
+        config: {
+          channels: {
+            feishu: {
+              enabled: true,
+              appId: "app_id",
+              appSecret: "app_secret", // pragma: allowlist secret
+              tools: { chat: false },
+            },
+          },
+        },
+        registerTool,
+      }),
+    );
+    expect(registerTool).not.toHaveBeenCalled();
+  });
+
+  it("preserves Feishu diagnostics from rejected member lookups", async () => {
+    const registerTool = vi.fn();
+    registerFeishuChatTools(
+      createChatToolApi({
+        config: {
+          channels: {
+            feishu: {
+              enabled: true,
+              appId: "app_id",
+              appSecret: "app_secret", // pragma: allowlist secret
+              tools: { chat: true },
+            },
+          },
+        },
+        registerTool,
+      }),
+    );
+
+    const tool = registerTool.mock.calls[0]?.[0];
+    contactUserGetMock.mockRejectedValueOnce(
+      Object.assign(new Error("Request failed with status code 400"), {
+        response: {
+          status: 400,
+          data: {
+            code: 99992360,
+            msg: "The request you send is not a valid {user_id} or not exists",
+            error: {
+              log_id: "20260429124800CHAT",
+              troubleshooter: "https://open.feishu.cn/search?log_id=20260429124800CHAT",
+            },
+          },
+        },
+      }),
+    );
+
+    const result = await tool.execute("tc_4", {
+      action: "member_info",
+      member_id: "ou_1",
+    });
+
+    expect(result.details.error).toContain('"http_status":400');
+    expect(result.details.error).toContain('"feishu_code":99992360');
+    expect(result.details.error).toContain(
+      '"feishu_msg":"The request you send is not a valid {user_id} or not exists"',
+    );
+    expect(result.details.error).toContain('"feishu_log_id":"20260429124800CHAT"');
+    expect(result.details.error).toContain(
+      '"feishu_troubleshooter":"https://open.feishu.cn/search?log_id=20260429124800CHAT"',
+    );
+  });
+});