@clawling/clawchat-plugin-openclaw 2026.5.12-28

package/src/profile-sync.test.ts

@@ -0,0 +1,539 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import { readClawChatMemoryFile } from "./clawchat-memory.ts";
+import {
+  ensureGroupProfileForChat,
+  ensureUserProfileForSender,
+  refreshAgentBehaviorProfile,
+  refreshGroupProfile,
+  syncFirstSeenClawChatProfiles,
+} from "./profile-sync.ts";
+
+let roots: string[] = [];
+
+function tempRoot(): string {
+  const root = fs.mkdtempSync(path.join(os.tmpdir(), "clawchat-plugin-openclaw-profile-sync-"));
+  roots.push(root);
+  return root;
+}
+
+afterEach(() => {
+  for (const root of roots) fs.rmSync(root, { recursive: true, force: true });
+  roots = [];
+});
+
+describe("ClawChat first-seen profile sync", () => {
+  it("metadata refresh writes group and participant memory files instead of SQLite profile metadata", async () => {
+    const memoryRoot = tempRoot();
+    const api = {
+      getConversation: vi.fn().mockResolvedValue({
+        conversation: {
+          id: "grp_memory",
+          type: "group",
+          title: "Memory Group",
+          description: "Group description",
+          creator_id: "usr_owner",
+          created_at: "2026-05-24T10:00:00.000Z",
+          updated_at: "2026-05-24T10:01:00.000Z",
+          participants: [
+            {
+              conversation_id: "grp_memory",
+              user_id: "usr_participant",
+              role: "member",
+              user: {
+                id: "usr_participant",
+                type: "user",
+                nickname: "Participant",
+                avatar_url: "https://example.test/participant.png",
+                bio: "Participant bio",
+              },
+            },
+          ],
+        },
+      }),
+      getUserInfo: vi.fn().mockResolvedValue({
+        id: "usr_participant",
+        type: "user",
+        nickname: "Participant",
+        avatar_url: "https://example.test/participant.png",
+        bio: "Participant bio",
+      }),
+    };
+    const store = {};
+
+    await refreshGroupProfile({
+      platform: "openclaw",
+      accountId: "default",
+      chatId: "grp_memory",
+      api,
+      store,
+      memoryRoot,
+    });
+
+    await expect(readClawChatMemoryFile(memoryRoot, { targetType: "group", targetId: "grp_memory" }))
+      .resolves.toMatchObject({
+        metadata: expect.objectContaining({ group_id: "grp_memory", group_title: "Memory Group" }),
+      });
+    await expect(readClawChatMemoryFile(memoryRoot, { targetType: "user", targetId: "usr_participant" }))
+      .resolves.toMatchObject({
+        metadata: expect.objectContaining({ id: "usr_participant", nickname: "Participant" }),
+      });
+  });
+
+  it("metadata refresh logs visibly and skips SQLite profile metadata when memoryRoot is missing", async () => {
+    const api = {
+      getAgentDetail: vi.fn().mockResolvedValue({
+        agent: {
+          id: "agent_row_1",
+          user_id: "usr_self",
+          owner_id: "usr_owner",
+          type: "agent",
+          nickname: "Hermes",
+          behavior: "Act helpfully.",
+        },
+      }),
+    };
+    const store = {};
+    const log = { error: vi.fn() };
+
+    await refreshAgentBehaviorProfile({
+      platform: "openclaw",
+      accountId: "default",
+      agentId: "agent_row_1",
+      accountUserId: "usr_self",
+      accountOwnerUserId: "usr_owner",
+      api,
+      store,
+      log,
+    });
+
+    expect(api.getAgentDetail).not.toHaveBeenCalled();
+    expect(log.error).toHaveBeenCalledWith(expect.stringContaining("metadata refresh requires memoryRoot"));
+  });
+
+  it("group refresh logs visibly and skips metadata files when memoryRoot is missing", async () => {
+    const api = {
+      getConversation: vi.fn().mockResolvedValue({
+        conversation: {
+          id: "grp_no_memory_root",
+          type: "group",
+          title: "No Memory Root",
+          creator_id: "usr_owner",
+          created_at: "2026-05-24T10:00:00.000Z",
+          updated_at: "2026-05-24T10:01:00.000Z",
+          participants: [
+            {
+              conversation_id: "grp_no_memory_root",
+              user_id: "usr_member",
+              role: "member",
+              joined_at: "2026-05-24T10:00:30.000Z",
+            },
+          ],
+        },
+      }),
+    };
+    const store = {};
+    const log = { error: vi.fn() };
+
+    await refreshGroupProfile({
+      platform: "openclaw",
+      accountId: "default",
+      chatId: "grp_no_memory_root",
+      api,
+      store,
+      log,
+    });
+
+    expect(log.error).toHaveBeenCalledWith(expect.stringContaining("group metadata refresh requires memoryRoot"));
+    expect(api.getConversation).toHaveBeenCalledWith("grp_no_memory_root");
+  });
+
+  it("minimal-inserts new group/user profiles before fetching details", async () => {
+    const memoryRoot = tempRoot();
+    const api = {
+      getConversation: vi.fn().mockResolvedValue({
+        conversation: {
+          id: "grp_1",
+          type: "group",
+          title: "Launch Room",
+          description: "Planning",
+          creator_id: "usr_owner",
+          created_at: "2026-05-22T10:00:00.000Z",
+          updated_at: "2026-05-22T10:01:00.000Z",
+          participants: [
+            {
+              conversation_id: "grp_1",
+              user_id: "usr_participant",
+              role: "member",
+              joined_at: "2026-05-22T10:00:30.000Z",
+            },
+          ],
+        },
+      }),
+      getUserInfo: vi.fn().mockImplementation(async (userId: string) => ({
+        id: userId,
+        type: userId === "agt_peer" ? "agent" : "user",
+        nickname: userId === "agt_peer" ? "Peer Agent" : "Participant",
+        avatar_url: userId === "agt_peer"
+          ? "https://example.test/agent.png"
+          : "https://example.test/participant.png",
+        bio: userId === "agt_peer" ? "Agent bio" : "Participant bio",
+      })),
+    };
+    const store = {};
+
+    await syncFirstSeenClawChatProfiles({
+      platform: "openclaw",
+      accountId: "default",
+      agentId: "agent_row_1",
+      accountUserId: "usr_self",
+      accountOwnerUserId: "usr_owner",
+      chat: { id: "grp_1", type: "group", lastSeenAt: 1000 },
+      sender: { id: "agt_peer", nickname: "Fallback Nick" },
+      api,
+      store,
+      memoryRoot,
+    });
+
+    expect(api.getConversation).toHaveBeenCalledWith("grp_1");
+    expect(api.getUserInfo).toHaveBeenCalledWith("agt_peer");
+    await expect(readClawChatMemoryFile(memoryRoot, { targetType: "group", targetId: "grp_1" }))
+      .resolves.toMatchObject({ metadata: expect.objectContaining({ group_title: "Launch Room", group_description: "Planning" }) });
+    await expect(readClawChatMemoryFile(memoryRoot, { targetType: "user", targetId: "usr_participant" }))
+      .resolves.toMatchObject({
+        metadata: expect.objectContaining({ id: "usr_participant", nickname: "Participant" }),
+      });
+    await expect(readClawChatMemoryFile(memoryRoot, { targetType: "user", targetId: "agt_peer" }))
+      .resolves.toMatchObject({ metadata: expect.objectContaining({ id: "agt_peer", profile_type: "agent" }) });
+  });
+
+  it("refreshes direct user metadata even when the direct conversation is cached", async () => {
+    const memoryRoot = tempRoot();
+    const api = {
+      getConversation: vi.fn(),
+      getUserInfo: vi.fn().mockResolvedValue({
+        id: "usr_peer",
+        type: "user",
+        nickname: "Fetched Peer",
+      }),
+    };
+    const store = {
+    };
+
+    await syncFirstSeenClawChatProfiles({
+      platform: "openclaw",
+      accountId: "default",
+      agentId: "agent_row_1",
+      accountUserId: "usr_self",
+      accountOwnerUserId: "usr_owner",
+      chat: { id: "dm_1", type: "direct", lastSeenAt: 2000 },
+      sender: { id: "usr_peer", nickname: "Peer" },
+      api,
+      store,
+      memoryRoot,
+    });
+
+    expect(api.getConversation).not.toHaveBeenCalled();
+    expect(api.getUserInfo).toHaveBeenCalledWith("usr_peer");    await expect(readClawChatMemoryFile(memoryRoot, { targetType: "user", targetId: "usr_peer" }))
+      .resolves.toMatchObject({ metadata: expect.objectContaining({ nickname: "Fetched Peer" }) });
+  });
+
+  it("first direct message fetches user detail but not conversation detail", async () => {
+    const memoryRoot = tempRoot();
+    const api = {
+      getConversation: vi.fn(),
+      getUserInfo: vi.fn().mockResolvedValue({
+        id: "usr_peer",
+        type: "user",
+        nickname: "Peer",
+      }),
+    };
+    const store = {
+    };
+
+    await syncFirstSeenClawChatProfiles({
+      platform: "openclaw",
+      accountId: "default",
+      agentId: "agent_row_1",
+      accountUserId: "usr_self",
+      accountOwnerUserId: "usr_owner",
+      chat: { id: "dm_1", type: "direct", lastSeenAt: 2100 },
+      sender: { id: "usr_peer", nickname: "Peer" },
+      api,
+      store,
+      memoryRoot,
+    });
+
+    expect(api.getUserInfo).toHaveBeenCalledWith("usr_peer");
+    expect(api.getConversation).not.toHaveBeenCalled();
+    await expect(readClawChatMemoryFile(memoryRoot, { targetType: "user", targetId: "usr_peer" }))
+      .resolves.toMatchObject({ metadata: expect.objectContaining({ id: "usr_peer", nickname: "Peer" }) });
+  });
+
+  it("keeps minimal profiles and resolves when detail fetches fail", async () => {
+    const memoryRoot = tempRoot();
+    const api = {
+      getConversation: vi.fn().mockRejectedValue(new Error("conversation unavailable")),
+      getUserInfo: vi.fn().mockRejectedValue(new Error("user unavailable")),
+    };
+    const store = {
+    };
+
+    await expect(syncFirstSeenClawChatProfiles({
+      platform: "openclaw",
+      accountId: "default",
+      accountUserId: "usr_self",
+      accountOwnerUserId: "usr_owner",
+      chat: { id: "grp_2", type: "group", lastSeenAt: 3000 },
+      sender: { id: "usr_peer", nickname: "Peer" },
+      api,
+      store,
+      memoryRoot,
+    })).resolves.toBeUndefined();  });
+
+  it("omits null group description from metadata files and SQLite details", async () => {
+    const memoryRoot = tempRoot();
+    const api = {
+      getConversation: vi.fn().mockResolvedValue({
+        conversation: {
+          id: "grp_clear_description",
+          type: "group",
+          title: "Launch Room",
+          description: null,
+          creator_id: "usr_owner",
+          created_at: "2026-05-22T10:00:00.000Z",
+          updated_at: "2026-05-22T10:01:00.000Z",
+          participants: [],
+        },
+      }),
+    };
+    const store = {};
+
+    await refreshGroupProfile({
+      platform: "openclaw",
+      accountId: "default",
+      chatId: "grp_clear_description",
+      api,
+      store,
+      memoryRoot,
+    });
+
+    const file = await readClawChatMemoryFile(memoryRoot, { targetType: "group", targetId: "grp_clear_description" });
+    expect(file.metadata).toEqual({
+      updated_at: "2026-05-22T10:01:00.000Z",
+      group_id: "grp_clear_description",
+      group_type: "group",
+      group_title: "Launch Room",
+      group_owner_id: "usr_owner",
+      group_created_at: "2026-05-22T10:00:00.000Z",
+    });
+  });
+
+  it("omits null participant profile type from metadata files", async () => {
+    const memoryRoot = tempRoot();
+    const api = {
+      getConversation: vi.fn().mockResolvedValue({
+        conversation: {
+          id: "grp_participant_type_clear",
+          type: "group",
+          title: "Launch Room",
+          creator_id: "usr_owner",
+          created_at: "2026-05-22T10:00:00.000Z",
+          updated_at: "2026-05-22T10:01:00.000Z",
+          participants: [
+            {
+              conversation_id: "grp_participant_type_clear",
+              user_id: "usr_participant",
+              role: "member",
+              joined_at: "2026-05-22T10:00:30.000Z",
+              user: {
+                id: "usr_participant",
+                type: null,
+                nickname: "Participant",
+              },
+            },
+          ],
+        },
+      }),
+    };
+    const store = {};
+
+    await refreshGroupProfile({
+      platform: "openclaw",
+      accountId: "default",
+      chatId: "grp_participant_type_clear",
+      api,
+      store,
+      memoryRoot,
+    });
+
+    const file = await readClawChatMemoryFile(memoryRoot, { targetType: "user", targetId: "usr_participant" });
+    expect(Object.prototype.hasOwnProperty.call(file.metadata, "profile_type")).toBe(false);
+  });
+
+  it("omits null agent behavior from owner metadata files", async () => {
+    const memoryRoot = tempRoot();
+    const api = {
+      getAgentDetail: vi.fn().mockResolvedValue({
+        agent: {
+          user_id: "usr_self",
+          owner_id: "usr_owner",
+          type: "agent",
+          nickname: "Hermes",
+          behavior: null,
+        },
+      }),
+      getUserProfile: vi.fn().mockResolvedValue({
+        id: "usr_owner",
+        nickname: "Owner",
+      }),
+    };
+    const store = {};
+
+    await refreshAgentBehaviorProfile({
+      platform: "openclaw",
+      accountId: "default",
+      agentId: "agent_row_1",
+      accountUserId: "usr_self",
+      accountOwnerUserId: "usr_owner",
+      api,
+      store,
+      memoryRoot,
+    });
+
+    const file = await readClawChatMemoryFile(memoryRoot, { targetType: "owner", targetId: "owner" });
+    expect(file.metadata).toEqual(expect.objectContaining({
+      agent_id: "usr_self",
+      agent_owner_id: "usr_owner",
+      agent_owner_nickname: "Owner",
+    }));
+    expect(Object.prototype.hasOwnProperty.call(file.metadata, "agent_behavior")).toBe(false);
+  });
+
+  it("does not invent omitted user metadata fields", async () => {
+    const memoryRoot = tempRoot();
+    const api = {
+      getUserProfile: vi.fn().mockResolvedValue({
+        id: "usr_peer",
+        type: "user",
+        nickname: "Peer",
+      }),
+    };
+    const store = {};
+
+    await ensureUserProfileForSender({
+      platform: "openclaw",
+      accountId: "default",
+      agentId: "agent_row_1",
+      accountUserId: "usr_self",
+      accountOwnerUserId: "usr_owner",
+      sender: { id: "usr_peer", nickname: "Fallback" },
+      api,
+      store,
+      memoryRoot,
+    });
+
+    const file = await readClawChatMemoryFile(memoryRoot, { targetType: "user", targetId: "usr_peer" });
+    expect(file.metadata).toEqual(expect.objectContaining({ id: "usr_peer", nickname: "Peer" }));
+    expect(Object.prototype.hasOwnProperty.call(file.metadata, "avatar_url")).toBe(false);
+    expect(Object.prototype.hasOwnProperty.call(file.metadata, "bio")).toBe(false);
+  });
+
+  it("exposes planned profile sync functions", async () => {
+    const memoryRoot = tempRoot();
+    const api = {
+      getUserProfile: vi.fn().mockResolvedValue({
+        id: "usr_peer",
+        type: "agent",
+        nickname: "Peer Agent",
+        avatar_url: "https://example.test/peer.png",
+        bio: "Peer bio",
+      }),
+      getConversation: vi.fn().mockResolvedValue({
+        conversation: {
+          id: "grp_3",
+          type: "group",
+          title: "Group 3",
+          description: "Description 3",
+          creator_id: "usr_owner",
+          created_at: "2026-05-22T10:00:00.000Z",
+          updated_at: "2026-05-22T10:01:00.000Z",
+          participants: [],
+        },
+      }),
+      getAgentDetail: vi.fn().mockResolvedValue({
+        agent: {
+          user_id: "usr_self",
+          owner_id: "usr_owner",
+          type: "agent",
+          nickname: "Hermes",
+          avatar_url: "https://example.test/hermes.png",
+          bio: "Agent bio",
+          behavior: "Act as Hermes.",
+        },
+      }),
+    };
+    const store = {
+    };
+
+    await ensureUserProfileForSender({
+      platform: "openclaw",
+      accountId: "default",
+      accountUserId: "usr_self",
+      accountOwnerUserId: "usr_owner",
+      sender: { id: "usr_peer", nickname: "Fallback" },
+      lastSeenAt: 4000,
+      api,
+      store,
+      memoryRoot,
+    });
+    await ensureGroupProfileForChat({
+      platform: "openclaw",
+      accountId: "default",
+      chat: { id: "grp_3", type: "group", lastSeenAt: 4100 },
+      api,
+      store,
+      memoryRoot,
+    });
+    await refreshAgentBehaviorProfile({
+      platform: "openclaw",
+      accountId: "default",
+      agentId: "agent_row_1",
+      accountUserId: "usr_self",
+      accountOwnerUserId: "usr_owner",
+      metadataVersion: 7,
+      api,
+      store,
+      memoryRoot,
+    });
+    await refreshGroupProfile({
+      platform: "openclaw",
+      accountId: "default",
+      chatId: "grp_3",
+      metadataVersion: 8,
+      api,
+      store,
+      memoryRoot,
+    });
+
+    expect(api.getUserProfile).toHaveBeenCalledWith("usr_peer");
+    await expect(readClawChatMemoryFile(memoryRoot, { targetType: "user", targetId: "usr_peer" }))
+      .resolves.toMatchObject({
+        metadata: expect.objectContaining({
+          id: "usr_peer",
+          profile_type: "agent",
+          nickname: "Peer Agent",
+        }),
+      });
+    await expect(readClawChatMemoryFile(memoryRoot, { targetType: "owner", targetId: "owner" }))
+      .resolves.toMatchObject({
+        metadata: expect.objectContaining({ agent_id: "usr_self", agent_behavior: "Act as Hermes." }),
+      });
+    await expect(readClawChatMemoryFile(memoryRoot, { targetType: "group", targetId: "grp_3" }))
+      .resolves.toMatchObject({
+        metadata: expect.objectContaining({ group_id: "grp_3", group_title: "Group 3", group_description: "Description 3" }),
+      });
+  });
+});