@clawling/clawchat-plugin-openclaw 2026.5.12-28

package/src/clawchat-metadata.test.ts

@@ -0,0 +1,477 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { readClawChatMemoryFile } from "./clawchat-memory.ts";
+import {
+  pullGroupMetadata,
+  pullOwnerMetadata,
+  pullUserMetadata,
+  pushMetadata,
+  updateMetadata,
+} from "./clawchat-metadata.ts";
+
+let roots: string[] = [];
+
+function tempRoot(): string {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "clawchat-plugin-openclaw-metadata-"));
+  roots.push(root);
+  return root;
+}
+
+afterEach(() => {
+  for (const root of roots) fs.rmSync(root, { recursive: true, force: true });
+  roots = [];
+});
+
+describe("clawchat metadata mapping", () => {
+  it("combines agent detail behavior with owner user profile in owner.md", async () => {
+    const root = tempRoot();
+    const api = {
+      getAgentDetail: vi.fn().mockResolvedValue({
+        agent: {
+          id: "agent_row_1",
+          user_id: "usr_self",
+          owner_id: "usr_owner",
+          type: "agent",
+          nickname: "Hermes Agent",
+          avatar_url: "https://example.test/agent.png",
+          bio: "Agent line 1\r\nAgent line 2",
+          behavior: "Be concise\rBe kind",
+          visibility: "public",
+          status: "online",
+          raw: { ignored: true },
+          updated_at: "2026-05-24T10:00:00.000Z",
+        },
+      }),
+      getUserProfile: vi.fn().mockResolvedValue({
+        id: "usr_owner",
+        nickname: "Owner\nName",
+        avatar_url: "https://example.test/owner.png",
+        bio: "Owner line 1\r\nOwner line 2",
+        type: "user",
+      }),
+    };
+
+    const result = await pullOwnerMetadata({
+      memoryRoot: root,
+      agentId: "agent_row_1",
+      accountUserId: "usr_self",
+      accountOwnerUserId: "usr_owner",
+      api,
+    });
+
+    expect(result).toMatchObject({ ok: true, failures: [] });
+    expect(api.getAgentDetail).toHaveBeenCalledWith("agent_row_1");
+    expect(api.getUserProfile).toHaveBeenCalledWith("usr_owner");
+    await expect(readClawChatMemoryFile(root, { targetType: "owner", targetId: "owner" }))
+      .resolves.toMatchObject({
+        metadata: {
+          updated_at: "2026-05-24T10:00:00.000Z",
+          agent_id: "usr_self",
+          agent_owner_id: "usr_owner",
+          agent_nickname: "Hermes Agent",
+          agent_avatar_url: "https://example.test/agent.png",
+          agent_bio: "Agent line 1 Agent line 2",
+          agent_owner_nickname: "Owner Name",
+          agent_owner_avatar_url: "https://example.test/owner.png",
+          agent_owner_bio: "Owner line 1 Owner line 2",
+          agent_behavior: "Be concise Be kind",
+        },
+      });
+    const file = fs.readFileSync(path.join(root, "owner.md"), "utf8");
+    expect(file).toContain("agent_nickname: Hermes Agent");
+    expect(file).toContain("agent_bio: Agent line 1 Agent line 2");
+    expect(file).not.toContain("visibility");
+    expect(file).not.toContain("status");
+    expect(file).not.toContain("raw");
+    expect(file).not.toContain("type:");
+  });
+
+  it("maps user profile to users/<id>.md metadata fields and drops unknown fields", async () => {
+    const root = tempRoot();
+    const api = {
+      getUserProfile: vi.fn().mockResolvedValue({
+        id: "usr_peer",
+        type: "user",
+        nickname: "Peer",
+        avatar_url: "https://example.test/peer.png",
+        bio: "",
+        display_name: "Dropped display name",
+        kind: "dropped",
+        updated_at: "2026-05-24T10:01:00.000Z",
+      }),
+    };
+
+    await pullUserMetadata({ memoryRoot: root, userId: "usr_peer", api });
+
+    const file = await readClawChatMemoryFile(root, { targetType: "user", targetId: "usr_peer" });
+    expect(file.metadata).toEqual({
+      updated_at: "2026-05-24T10:01:00.000Z",
+      id: "usr_peer",
+      nickname: "Peer",
+      avatar_url: "https://example.test/peer.png",
+      bio: "",
+      profile_type: "user",
+    });
+  });
+
+  it("maps conversation detail to groups/<id>.md participant ids and participant users", async () => {
+    const root = tempRoot();
+    const api = {
+      getConversation: vi.fn().mockResolvedValue({
+        conversation: {
+          id: "grp_1",
+          type: "group",
+          title: "Launch\nRoom",
+          description: "Planning\r\nNotes",
+          creator_id: "usr_owner",
+          created_at: "2026-05-24T09:59:00.000Z",
+          updated_at: "2026-05-24T10:02:00.000Z",
+          visibility: "private",
+          participants: [
+            {
+              conversation_id: "grp_1",
+              user_id: "usr_participant",
+              role: "member",
+              joined_at: "2026-05-24T10:03:00.000Z",
+            },
+          ],
+        },
+      }),
+      getUserProfile: vi.fn(async (userId: string) => userId === "usr_owner"
+        ? {
+            id: "usr_owner",
+            nickname: "Owner",
+            type: "user",
+          }
+        : {
+            id: "usr_participant",
+            nickname: "Participant",
+            avatar_url: "https://example.test/usr-participant.png",
+            bio: "Product lead",
+            type: "user",
+          }),
+    };
+
+    const result = await pullGroupMetadata({ memoryRoot: root, groupId: "grp_1", api });
+
+    expect(result).toMatchObject({ ok: true, failures: [] });
+    expect(api.getUserProfile).toHaveBeenCalledWith("usr_participant");
+    const groupFile = await readClawChatMemoryFile(root, { targetType: "group", targetId: "grp_1" });
+    expect(groupFile.metadata).toEqual({
+      updated_at: "2026-05-24T10:02:00.000Z",
+      group_id: "grp_1",
+      group_type: "group",
+      group_title: "Launch Room",
+      group_description: "Planning Notes",
+      group_owner_id: "usr_owner",
+      group_owner_nickname: "Owner",
+      group_owner_profile_type: "user",
+      group_created_at: "2026-05-24T09:59:00.000Z",
+      participant_ids: "usr_participant",
+    });
+
+    await expect(readClawChatMemoryFile(root, { targetType: "user", targetId: "usr_participant" }))
+      .resolves.toMatchObject({
+        metadata: {
+          id: "usr_participant",
+          nickname: "Participant",
+          avatar_url: "https://example.test/usr-participant.png",
+          bio: "Product lead",
+          profile_type: "user",
+        },
+      });
+  });
+
+  it("skips direct conversations when pulling group metadata", async () => {
+    const root = tempRoot();
+    const api = {
+      getConversation: vi.fn().mockResolvedValue({
+        conversation: {
+          id: "direct_1",
+          type: "direct",
+          title: "Owner DM",
+          participants: [{ user_id: "usr_owner", role: "owner" }],
+        },
+      }),
+      getUserProfile: vi.fn(),
+    };
+
+    const result = await pullGroupMetadata({ memoryRoot: root, groupId: "direct_1", api });
+
+    expect(result).toMatchObject({ ok: true, writes: [], failures: [] });
+    expect(result.conversation?.type).toBe("direct");
+    expect(api.getConversation).toHaveBeenCalledWith("direct_1");
+    expect(api.getUserProfile).not.toHaveBeenCalled();
+    await expect(readClawChatMemoryFile(root, { targetType: "group", targetId: "direct_1" }))
+      .resolves.toMatchObject({ exists: false });
+    await expect(readClawChatMemoryFile(root, { targetType: "user", targetId: "usr_owner" }))
+      .resolves.toMatchObject({ exists: false });
+  });
+
+  it("skips owner and connected agent participants during group metadata pulls", async () => {
+    const root = tempRoot();
+    const api = {
+      getConversation: vi.fn().mockResolvedValue({
+        conversation: {
+          id: "grp_1",
+          type: "group",
+          participants: [
+            { user_id: "usr_owner", role: "owner" },
+            { user_id: "usr_self", role: "member" },
+            { user_id: "usr_peer", role: "member" },
+          ],
+        },
+      }),
+      getUserProfile: vi.fn(async (userId: string) => ({
+        id: userId,
+        nickname: `User ${userId}`,
+        type: "user",
+      })),
+    };
+
+    const result = await pullGroupMetadata({
+      memoryRoot: root,
+      groupId: "grp_1",
+      api,
+      skipUserIds: ["usr_owner", "usr_self"],
+    });
+
+    expect(result).toMatchObject({ ok: true, failures: [] });
+    expect(result.writes).toEqual([
+      { targetType: "group", targetId: "grp_1" },
+      { targetType: "user", targetId: "usr_peer" },
+    ]);
+    expect(api.getUserProfile).toHaveBeenCalledTimes(1);
+    expect(api.getUserProfile).toHaveBeenCalledWith("usr_peer");
+    await expect(readClawChatMemoryFile(root, { targetType: "user", targetId: "usr_owner" }))
+      .resolves.toMatchObject({ exists: false });
+    await expect(readClawChatMemoryFile(root, { targetType: "user", targetId: "usr_self" }))
+      .resolves.toMatchObject({ exists: false });
+    await expect(readClawChatMemoryFile(root, { targetType: "user", targetId: "usr_peer" }))
+      .resolves.toMatchObject({
+        exists: true,
+        metadata: expect.objectContaining({ id: "usr_peer", nickname: "User usr_peer" }),
+      });
+  });
+
+  it("writes requested group target even when the response id differs", async () => {
+    const root = tempRoot();
+    const api = {
+      getConversation: vi.fn().mockResolvedValue({
+        conversation: {
+          id: "grp_response",
+          type: "group",
+          title: "Launch Room",
+          participants: [],
+        },
+      }),
+    };
+
+    await pullGroupMetadata({ memoryRoot: root, groupId: "grp_requested", api });
+
+    await expect(readClawChatMemoryFile(root, { targetType: "group", targetId: "grp_requested" }))
+      .resolves.toMatchObject({
+        exists: true,
+        metadata: { group_id: "grp_requested", group_type: "group", group_title: "Launch Room" },
+      });
+    await expect(readClawChatMemoryFile(root, { targetType: "group", targetId: "grp_response" }))
+      .resolves.toMatchObject({ exists: false });
+  });
+
+  it("does not overwrite an existing participant user metadata file during group pull", async () => {
+    const root = tempRoot();
+    fs.mkdirSync(path.join(root, "users"), { recursive: true });
+    fs.writeFileSync(
+      path.join(root, "users", "usr_participant.md"),
+      [
+        "<!-- clawchat:metadata:start -->",
+        "id: usr_participant",
+        "nickname: Existing",
+        "bio: Existing bio",
+        "<!-- clawchat:metadata:end -->",
+        "",
+        "Existing body.",
+      ].join("\n"),
+    );
+    const api = {
+      getConversation: vi.fn().mockResolvedValue({
+        conversation: {
+          id: "grp_1",
+          type: "group",
+          title: "Launch Room",
+          participants: [{ user_id: "usr_participant", role: "member" }],
+        },
+      }),
+      getUserProfile: vi.fn(),
+    };
+
+    await pullGroupMetadata({ memoryRoot: root, groupId: "grp_1", api });
+
+    expect(api.getUserProfile).not.toHaveBeenCalled();
+    await expect(readClawChatMemoryFile(root, { targetType: "user", targetId: "usr_participant" }))
+      .resolves.toMatchObject({
+        metadata: { id: "usr_participant", nickname: "Existing", bio: "Existing bio" },
+        body: "Existing body.",
+      });
+  });
+
+  it("returns partial participant write failures without rolling back group metadata", async () => {
+    const root = tempRoot();
+    fs.symlinkSync(os.tmpdir(), path.join(root, "users"));
+    const api = {
+      getConversation: vi.fn().mockResolvedValue({
+        conversation: {
+          id: "grp_partial",
+          type: "group",
+          title: "Partial",
+          creator_id: "usr_owner",
+          created_at: "2026-05-24T09:59:00.000Z",
+          updated_at: "2026-05-24T10:02:00.000Z",
+          participants: [{ user_id: "usr_blocked", user: { id: "usr_blocked", nickname: "Blocked" } }],
+        },
+      }),
+      getUserProfile: vi.fn(async (userId: string) => {
+        if (userId === "usr_owner") return { id: "usr_owner", nickname: "Owner", type: "user" };
+        throw new Error("user unavailable");
+      }),
+    };
+
+    const result = await pullGroupMetadata({ memoryRoot: root, groupId: "grp_partial", api });
+
+    expect(result.ok).toBe(false);
+    expect(result.failures).toEqual([
+      expect.objectContaining({ targetType: "user", targetId: "usr_blocked" }),
+    ]);
+    await expect(readClawChatMemoryFile(root, { targetType: "group", targetId: "grp_partial" }))
+      .resolves.toMatchObject({
+        metadata: expect.objectContaining({ group_id: "grp_partial", group_title: "Partial" }),
+      });
+  });
+});
+
+describe("clawchat metadata push and update", () => {
+  let root: string;
+
+  beforeEach(() => {
+    root = tempRoot();
+  });
+
+  it("pushes agent behavior from owner.md to the server before rewriting owner.md from owner profile", async () => {
+    fs.writeFileSync(
+      path.join(root, "owner.md"),
+      [
+        "<!-- clawchat:metadata:start -->",
+        "agent_owner_nickname: Local",
+        "agent_owner_avatar_url: https://example.test/local.png",
+        "agent_owner_bio: Local bio",
+        "agent_behavior: local-only",
+        "<!-- clawchat:metadata:end -->",
+        "",
+        "Keep body.",
+      ].join("\n"),
+    );
+    const api = {
+      updateAgentBehavior: vi.fn().mockResolvedValue({
+        agent: {
+          id: "agent_row_1",
+          user_id: "usr_self",
+          owner_id: "usr_owner",
+          nickname: "Agent Server",
+          avatar_url: "https://example.test/agent-server.png",
+          bio: "Agent server bio",
+          behavior: "Server behavior",
+          updated_at: "2026-05-24T10:05:00.000Z",
+        },
+      }),
+      getUserProfile: vi.fn().mockResolvedValue({
+        id: "usr_owner",
+        nickname: "Owner Server",
+        avatar_url: "https://example.test/owner-server.png",
+        bio: "Owner server bio",
+      }),
+    };
+
+    await pushMetadata({
+      memoryRoot: root,
+      targetType: "owner",
+      targetId: "owner",
+      fields: ["agent_behavior"],
+      agentId: "agent_row_1",
+      accountUserId: "usr_self",
+      api,
+    });
+
+    expect(api.updateAgentBehavior).toHaveBeenCalledWith("local-only");
+    expect(api.getUserProfile).toHaveBeenCalledWith("usr_owner");
+    await expect(readClawChatMemoryFile(root, { targetType: "owner", targetId: "owner" }))
+      .resolves.toMatchObject({
+        metadata: expect.objectContaining({
+          agent_owner_nickname: "Owner Server",
+          agent_owner_avatar_url: "https://example.test/owner-server.png",
+          agent_owner_bio: "Owner server bio",
+          agent_nickname: "Agent Server",
+          agent_avatar_url: "https://example.test/agent-server.png",
+          agent_bio: "Agent server bio",
+          agent_behavior: "Server behavior",
+        }),
+        body: "Keep body.",
+      });
+  });
+
+  it("rejects agent_owner_nickname push because owner display metadata is not agent metadata", async () => {
+    fs.writeFileSync(
+      path.join(root, "owner.md"),
+      [
+        "<!-- clawchat:metadata:start -->",
+        "agent_owner_nickname: Local Owner",
+        "<!-- clawchat:metadata:end -->",
+        "",
+      ].join("\n"),
+    );
+
+    await expect(pushMetadata({
+      memoryRoot: root,
+      targetType: "owner",
+      targetId: "owner",
+      fields: ["agent_owner_nickname"],
+      agentId: "agent_row_1",
+      accountUserId: "usr_self",
+      api: {},
+    })).rejects.toThrow("fields contain non-pushable metadata field: agent_owner_nickname");
+  });
+
+  it("updates group metadata through the server and leaves the local file unchanged on failure", async () => {
+    fs.mkdirSync(path.join(root, "groups"));
+    fs.writeFileSync(
+      path.join(root, "groups", "grp_1.md"),
+      [
+        "<!-- clawchat:metadata:start -->",
+        "group_id: grp_1",
+        "group_title: Old",
+        "<!-- clawchat:metadata:end -->",
+        "",
+        "Group body.",
+      ].join("\n"),
+    );
+    const before = fs.readFileSync(path.join(root, "groups", "grp_1.md"), "utf8");
+    const api = {
+      patchConversation: vi.fn().mockRejectedValue(new Error("server refused")),
+    };
+
+    await expect(updateMetadata({
+      memoryRoot: root,
+      targetType: "group",
+      targetId: "grp_1",
+      patch: { group_title: "New", group_description: "New description", visibility: "dropped" },
+      api,
+    })).rejects.toThrow("server refused");
+
+    expect(api.patchConversation).toHaveBeenCalledWith("grp_1", {
+      title: "New",
+      description: "New description",
+    });
+    expect(fs.readFileSync(path.join(root, "groups", "grp_1.md"), "utf8")).toBe(before);
+  });
+});