@clawling/clawchat-plugin-openclaw 2026.5.12-28

package/src/clawchat-memory.test.ts

@@ -0,0 +1,480 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { afterEach, describe, expect, it, vi } from "vitest";
+import {
+  editClawChatMemoryBody,
+  ensureClawChatMemoryTargetSafe,
+  readClawChatMemoryFile,
+  resolveClawChatMemoryPath,
+  searchClawChatMemory,
+  writeClawChatMemoryBody,
+  writeClawChatMetadata,
+} from "./clawchat-memory.ts";
+
+const metadataStart = "<!-- clawchat:metadata:start -->";
+const metadataEnd = "<!-- clawchat:metadata:end -->";
+
+const tempRoots: string[] = [];
+
+function tempMemoryRoot(): string {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "clawchat-plugin-openclaw-memory-"));
+  tempRoots.push(dir);
+  return dir;
+}
+
+afterEach(() => {
+  vi.restoreAllMocks();
+  for (const dir of tempRoots.splice(0)) {
+    fs.rmSync(dir, { recursive: true, force: true });
+  }
+});
+
+describe("clawchat memory path safety", () => {
+  it("resolves owner target to owner.md", () => {
+    const root = tempMemoryRoot();
+
+    expect(resolveClawChatMemoryPath(root, { targetType: "owner", targetId: "owner" })).toBe(
+      path.join(root, "owner.md"),
+    );
+  });
+
+  it("resolves user target to users file", () => {
+    const root = tempMemoryRoot();
+
+    expect(resolveClawChatMemoryPath(root, { targetType: "user", targetId: "usr_1" })).toBe(
+      path.join(root, "users", "usr_1.md"),
+    );
+  });
+
+  it("resolves group target to groups file", () => {
+    const root = tempMemoryRoot();
+
+    expect(resolveClawChatMemoryPath(root, { targetType: "group", targetId: "grp_1" })).toBe(
+      path.join(root, "groups", "grp_1.md"),
+    );
+  });
+
+  it("rejects owner target with non-owner target id", () => {
+    const root = tempMemoryRoot();
+
+    expect(() => resolveClawChatMemoryPath(root, { targetType: "owner", targetId: "usr_1" })).toThrow(
+      /owner targetId/i,
+    );
+  });
+
+  it("rejects invalid target types at runtime", () => {
+    const root = tempMemoryRoot();
+    const target = { targetType: "channel", targetId: "chn_1" } as unknown as Parameters<
+      typeof resolveClawChatMemoryPath
+    >[1];
+
+    expect(() => resolveClawChatMemoryPath(root, target)).toThrow(/targetType/i);
+  });
+
+  it.each([
+    ["empty", ""],
+    ["dot", "."],
+    ["dot-dot", ".."],
+    ["embedded dot-dot", "usr_.._1"],
+    ["slash", "usr/1"],
+    ["backslash", "usr\\1"],
+    ["NUL", "usr\0 1"],
+    ["control char", "usr\n1"],
+    ["C1 control char", "usr\u00851"],
+  ])("rejects %s target ids", (_label, targetId) => {
+    const root = tempMemoryRoot();
+
+    expect(() => resolveClawChatMemoryPath(root, { targetType: "user", targetId })).toThrow(/targetId/i);
+  });
+
+  it.each([
+    ["number", 123],
+    ["null", null],
+    ["object", { id: "usr_1" }],
+  ])("rejects %s target ids at runtime", (_label, targetId) => {
+    const root = tempMemoryRoot();
+    const target = { targetType: "user", targetId } as unknown as Parameters<typeof resolveClawChatMemoryPath>[1];
+
+    expect(() => resolveClawChatMemoryPath(root, target)).toThrow(/targetId must be a string/i);
+  });
+
+  it("rejects an existing target symlink before reading or writing", async () => {
+    const root = tempMemoryRoot();
+    const outside = tempMemoryRoot();
+    fs.mkdirSync(path.join(root, "users"));
+    fs.writeFileSync(path.join(outside, "usr_1.md"), "outside");
+    fs.symlinkSync(path.join(outside, "usr_1.md"), path.join(root, "users", "usr_1.md"));
+
+    await expect(ensureClawChatMemoryTargetSafe(root, { targetType: "user", targetId: "usr_1" })).rejects.toThrow(
+      /symlink/i,
+    );
+  });
+
+  it.each([
+    ["users", "user", "usr_1"],
+    ["groups", "group", "grp_1"],
+  ] as const)("rejects an existing %s symlink", async (_dirName, targetType, targetId) => {
+    const root = tempMemoryRoot();
+    const outside = tempMemoryRoot();
+    fs.symlinkSync(outside, path.join(root, targetType === "user" ? "users" : "groups"), "dir");
+
+    await expect(ensureClawChatMemoryTargetSafe(root, { targetType, targetId })).rejects.toThrow(/symlink/i);
+  });
+
+  it("rejects users parent when it exists as a regular file", async () => {
+    const root = tempMemoryRoot();
+    fs.writeFileSync(path.join(root, "users"), "not a directory");
+
+    await expect(ensureClawChatMemoryTargetSafe(root, { targetType: "user", targetId: "usr_1" })).rejects.toThrow(
+      /not a directory/i,
+    );
+  });
+
+  it("rejects an existing target directory", async () => {
+    const root = tempMemoryRoot();
+    fs.mkdirSync(path.join(root, "groups"), { recursive: true });
+    fs.mkdirSync(path.join(root, "groups", "grp_1.md"));
+
+    await expect(ensureClawChatMemoryTargetSafe(root, { targetType: "group", targetId: "grp_1" })).rejects.toThrow(
+      /not a regular file/i,
+    );
+  });
+
+  it("rejects a resolved target path outside the root", async () => {
+    const root = tempMemoryRoot();
+    const outside = tempMemoryRoot();
+    const targetPath = path.join(root, "owner.md");
+    fs.writeFileSync(targetPath, "owner");
+
+    const realpath = fs.promises.realpath.bind(fs.promises);
+    vi.spyOn(fs.promises, "realpath").mockImplementation(async (candidate) => {
+      if (String(candidate) === targetPath) {
+        return path.join(outside, "owner.md");
+      }
+      return realpath(candidate);
+    });
+
+    await expect(ensureClawChatMemoryTargetSafe(root, { targetType: "owner", targetId: "owner" })).rejects.toThrow(
+      /outside root/i,
+    );
+  });
+});
+
+describe("clawchat memory file metadata and body", () => {
+  it("returns empty content for missing files without creating them", async () => {
+    const root = tempMemoryRoot();
+
+    await expect(readClawChatMemoryFile(root, { targetType: "user", targetId: "usr_1" })).resolves.toEqual({
+      exists: false,
+      metadata: {},
+      body: "",
+      raw: "",
+    });
+    expect(fs.existsSync(path.join(root, "users", "usr_1.md"))).toBe(false);
+  });
+
+  it("returns the full body and empty metadata when the file has no metadata block", async () => {
+    const root = tempMemoryRoot();
+    fs.mkdirSync(path.join(root, "groups"));
+    fs.writeFileSync(path.join(root, "groups", "grp_1.md"), "A note\nwith two lines");
+
+    await expect(readClawChatMemoryFile(root, { targetType: "group", targetId: "grp_1" })).resolves.toEqual({
+      exists: true,
+      metadata: {},
+      body: "A note\nwith two lines",
+      raw: "A note\nwith two lines",
+    });
+  });
+
+  it("parses metadata only between exact marker lines", async () => {
+    const root = tempMemoryRoot();
+    fs.writeFileSync(
+      path.join(root, "owner.md"),
+      [
+        metadataStart,
+        "nickname: Alice",
+        "malformed line",
+        "bio: hello: world",
+        metadataEnd,
+        "",
+        "nickname: Body Value",
+        "Body text",
+      ].join("\n"),
+    );
+
+    await expect(readClawChatMemoryFile(root, { targetType: "owner", targetId: "owner" })).resolves.toMatchObject({
+      metadata: { nickname: "Alice", bio: "hello: world" },
+      body: "nickname: Body Value\nBody text",
+    });
+
+    fs.writeFileSync(
+      path.join(root, "owner.md"),
+      [`${metadataStart} `, "nickname: Alice", metadataEnd, "", "Body text"].join("\n"),
+    );
+
+    await expect(readClawChatMemoryFile(root, { targetType: "owner", targetId: "owner" })).resolves.toMatchObject({
+      metadata: {},
+      body: [`${metadataStart} `, "nickname: Alice", metadataEnd, "", "Body text"].join("\n"),
+    });
+  });
+
+  it("replaces the metadata block while preserving the body", async () => {
+    const root = tempMemoryRoot();
+    fs.writeFileSync(
+      path.join(root, "owner.md"),
+      [metadataStart, "nickname: Old", metadataEnd, "", "Remember this.", "And this."].join("\n"),
+    );
+
+    await writeClawChatMetadata(root, { targetType: "owner", targetId: "owner" }, { nickname: "New" });
+
+    expect(fs.readFileSync(path.join(root, "owner.md"), "utf8")).toBe(
+      [metadataStart, "nickname: New", metadataEnd, "", "Remember this.", "And this."].join("\n"),
+    );
+  });
+
+  it("replaces metadata without normalizing CRLF body content", async () => {
+    const root = tempMemoryRoot();
+    const body = "\r\nFirst line\r\nSecond line\r\n";
+    fs.writeFileSync(path.join(root, "owner.md"), `${metadataStart}\nowner_id: old\n${metadataEnd}${body}`);
+
+    await writeClawChatMetadata(root, { targetType: "owner", targetId: "owner" }, { owner_id: "new" });
+
+    expect(fs.readFileSync(path.join(root, "owner.md"), "utf8")).toBe(
+      `${metadataStart}\nowner_id: new\n${metadataEnd}${body}`,
+    );
+  });
+
+  it("replaces the body while preserving the metadata block", async () => {
+    const root = tempMemoryRoot();
+    fs.writeFileSync(path.join(root, "owner.md"), [metadataStart, "nickname: Alice", metadataEnd, "", "Old"].join("\n"));
+
+    await writeClawChatMemoryBody(root, { targetType: "owner", targetId: "owner" }, "replace", "New body");
+
+    expect(fs.readFileSync(path.join(root, "owner.md"), "utf8")).toBe(
+      [metadataStart, "nickname: Alice", metadataEnd, "", "New body"].join("\n"),
+    );
+  });
+
+  it.each([
+    ["owner", { targetType: "owner", targetId: "owner" }, "owner.md"],
+    ["user", { targetType: "user", targetId: "usr_1" }, path.join("users", "usr_1.md")],
+    ["group", { targetType: "group", targetId: "grp_1" }, path.join("groups", "grp_1.md")],
+  ] as const)("creates missing %s file on replace", async (_label, target, relativePath) => {
+    const root = tempMemoryRoot();
+    const targetPath = path.join(root, relativePath);
+
+    await writeClawChatMemoryBody(root, target, "replace", "New body");
+
+    expect(fs.readFileSync(targetPath, "utf8")).toBe("New body");
+  });
+
+  it("appends body content while preserving a CRLF metadata block", async () => {
+    const root = tempMemoryRoot();
+    const rawMetadataBlock = `${metadataStart}\r\nnickname: Alice\r\n${metadataEnd}`;
+    fs.writeFileSync(path.join(root, "owner.md"), `${rawMetadataBlock}\r\n\r\nOld`);
+
+    await writeClawChatMemoryBody(root, { targetType: "owner", targetId: "owner" }, "append", "New");
+
+    expect(fs.readFileSync(path.join(root, "owner.md"), "utf8")).toBe(`${rawMetadataBlock}\r\n\r\nOld\nNew`);
+  });
+
+  it("replaces body content while preserving a CRLF metadata block", async () => {
+    const root = tempMemoryRoot();
+    const rawMetadataBlock = `${metadataStart}\r\nnickname: Alice\r\n${metadataEnd}`;
+    fs.writeFileSync(path.join(root, "owner.md"), `${rawMetadataBlock}\r\n\r\nOld\r\nBody`);
+
+    await writeClawChatMemoryBody(root, { targetType: "owner", targetId: "owner" }, "replace", "New body");
+
+    expect(fs.readFileSync(path.join(root, "owner.md"), "utf8")).toBe(`${rawMetadataBlock}\r\n\r\nNew body`);
+  });
+
+  it("normalizes metadata values to a single line", async () => {
+    const root = tempMemoryRoot();
+
+    await writeClawChatMetadata(root, { targetType: "owner", targetId: "owner" }, {
+      bio: "Line 1\r\n\r\nLine 2\nLine 3\rLine 4",
+    });
+
+    expect(fs.readFileSync(path.join(root, "owner.md"), "utf8")).toBe(
+      [metadataStart, "bio: Line 1 Line 2 Line 3 Line 4", metadataEnd].join("\n"),
+    );
+  });
+
+  it("fills default agent behavior when owner.md is first created with empty behavior", async () => {
+    const root = tempMemoryRoot();
+
+    await writeClawChatMetadata(root, { targetType: "owner", targetId: "owner" }, {
+      agent_id: "usr_self",
+      agent_behavior: "",
+    });
+
+    const file = await readClawChatMemoryFile(root, { targetType: "owner", targetId: "owner" });
+    expect(file.metadata.agent_behavior).toContain("【鼓励】");
+    expect(file.metadata.agent_behavior).toContain("公开发布内容、修改个人资料");
+  });
+
+  it("fills default group description when group metadata is first created with empty description", async () => {
+    const root = tempMemoryRoot();
+
+    await writeClawChatMetadata(root, { targetType: "group", targetId: "grp_1" }, {
+      group_id: "grp_1",
+      group_description: "",
+    });
+
+    const file = await readClawChatMemoryFile(root, { targetType: "group", targetId: "grp_1" });
+    expect(file.metadata.group_description).toContain("【群目标】");
+    expect(file.metadata.group_description).toContain("Agent 参与范围");
+  });
+
+  it("does not fill default owner behavior when owner.md already exists", async () => {
+    const root = tempMemoryRoot();
+    fs.writeFileSync(
+      path.join(root, "owner.md"),
+      [metadataStart, "agent_behavior: ", metadataEnd].join("\n"),
+    );
+
+    await writeClawChatMetadata(root, { targetType: "owner", targetId: "owner" }, {
+      agent_behavior: "",
+    });
+
+    const file = await readClawChatMemoryFile(root, { targetType: "owner", targetId: "owner" });
+    expect(file.metadata.agent_behavior).toBe("");
+  });
+
+  it("preserves non-empty owner behavior and group description on first creation", async () => {
+    const root = tempMemoryRoot();
+
+    await writeClawChatMetadata(root, { targetType: "owner", targetId: "owner" }, {
+      agent_behavior: "Use the configured behavior.",
+    });
+    await writeClawChatMetadata(root, { targetType: "group", targetId: "grp_1" }, {
+      group_description: "Existing group bio.",
+    });
+
+    await expect(readClawChatMemoryFile(root, { targetType: "owner", targetId: "owner" }))
+      .resolves.toMatchObject({ metadata: { agent_behavior: "Use the configured behavior." } });
+    await expect(readClawChatMemoryFile(root, { targetType: "group", targetId: "grp_1" }))
+      .resolves.toMatchObject({ metadata: { group_description: "Existing group bio." } });
+  });
+
+  it("appends body content with a joining newline and no trailing newline", async () => {
+    const root = tempMemoryRoot();
+    fs.writeFileSync(path.join(root, "owner.md"), [metadataStart, "nickname: Alice", metadataEnd, "", "Old"].join("\n"));
+
+    await writeClawChatMemoryBody(root, { targetType: "owner", targetId: "owner" }, "append", "New");
+
+    expect(fs.readFileSync(path.join(root, "owner.md"), "utf8")).toBe(
+      [metadataStart, "nickname: Alice", metadataEnd, "", "Old", "New"].join("\n"),
+    );
+  });
+
+  it.each([
+    ["overwrite", "overwrite"],
+    ["undefined", undefined],
+  ])("rejects invalid body write mode %s without mutating", async (_label, mode) => {
+    const root = tempMemoryRoot();
+    const target = { targetType: "owner", targetId: "owner" } as const;
+    const targetPath = path.join(root, "owner.md");
+    fs.writeFileSync(targetPath, "Old");
+
+    await expect(writeClawChatMemoryBody(root, target, mode as "append", "New")).rejects.toThrow(/mode/i);
+    expect(fs.readFileSync(targetPath, "utf8")).toBe("Old");
+  });
+
+  it("appends body content while preserving pre-existing CRLF body content", async () => {
+    const root = tempMemoryRoot();
+    fs.writeFileSync(path.join(root, "owner.md"), [metadataStart, "nickname: Alice", metadataEnd].join("\n") + "\n\nOne\r\nTwo");
+
+    await writeClawChatMemoryBody(root, { targetType: "owner", targetId: "owner" }, "append", "Three");
+
+    expect(fs.readFileSync(path.join(root, "owner.md"), "utf8")).toBe(
+      [metadataStart, "nickname: Alice", metadataEnd].join("\n") + "\n\nOne\r\nTwo\nThree",
+    );
+  });
+
+  it("edits exactly one normalized body match while preserving metadata", async () => {
+    const root = tempMemoryRoot();
+    fs.writeFileSync(
+      path.join(root, "owner.md"),
+      [metadataStart, "nickname: Alice", metadataEnd, "", "one", "two", "three"].join("\n"),
+    );
+
+    await editClawChatMemoryBody(root, { targetType: "owner", targetId: "owner" }, "one\r\ntwo", "ONE\r\nTWO");
+
+    expect(fs.readFileSync(path.join(root, "owner.md"), "utf8")).toBe(
+      [metadataStart, "nickname: Alice", metadataEnd, "", "ONE", "TWO", "three"].join("\n"),
+    );
+  });
+
+  it("rejects body edits with empty or non-unique old text", async () => {
+    const root = tempMemoryRoot();
+    fs.writeFileSync(path.join(root, "owner.md"), "same\nsame");
+
+    await expect(
+      editClawChatMemoryBody(root, { targetType: "owner", targetId: "owner" }, "", "new"),
+    ).rejects.toThrow(/oldText/i);
+    await expect(
+      editClawChatMemoryBody(root, { targetType: "owner", targetId: "owner" }, "same", "new"),
+    ).rejects.toThrow(/exactly one/i);
+  });
+
+  it("rejects body edits with overlapping old text matches", async () => {
+    const root = tempMemoryRoot();
+    fs.writeFileSync(path.join(root, "owner.md"), "aaa");
+
+    await expect(
+      editClawChatMemoryBody(root, { targetType: "owner", targetId: "owner" }, "aa", "b"),
+    ).rejects.toThrow(/exactly one/i);
+  });
+});
+
+describe("clawchat memory search", () => {
+  it("finds local user memory by alias in metadata or body without returning paths", async () => {
+    const root = tempMemoryRoot();
+    fs.mkdirSync(path.join(root, "users"));
+    fs.writeFileSync(
+      path.join(root, "users", "usr_1.md"),
+      [
+        metadataStart,
+        "nickname: 小糖糖",
+        metadataEnd,
+        "",
+        "known_as: 才哥",
+        "likes product design",
+      ].join("\n"),
+    );
+
+    await expect(searchClawChatMemory(root, { query: "才哥", targetTypes: ["user"] })).resolves.toMatchObject({
+      query: "才哥",
+      matches: [
+        {
+          targetType: "user",
+          targetId: "usr_1",
+          matchedFields: ["body"],
+          snippets: ["known_as: 才哥"],
+        },
+      ],
+      truncated: false,
+    });
+    const result = await searchClawChatMemory(root, { query: "才哥", targetTypes: ["user"] });
+    expect(JSON.stringify(result)).not.toContain(root);
+  });
+
+  it("returns bounded ranked matches across owner users and groups", async () => {
+    const root = tempMemoryRoot();
+    fs.mkdirSync(path.join(root, "users"));
+    fs.mkdirSync(path.join(root, "groups"));
+    fs.writeFileSync(path.join(root, "owner.md"), [metadataStart, "agent_owner_nickname: Colin", metadataEnd].join("\n"));
+    fs.writeFileSync(path.join(root, "users", "usr_1.md"), "known_as: Colin");
+    fs.writeFileSync(path.join(root, "groups", "grp_1.md"), "Colin group note");
+
+    const result = await searchClawChatMemory(root, { query: "Colin", maxResults: 2 });
+
+    expect(result.matches.map((match) => `${match.targetType}:${match.targetId}`)).toEqual([
+      "owner:owner",
+      "user:usr_1",
+    ]);
+    expect(result.truncated).toBe(true);
+  });
+});