@newbase-clawchat/openclaw-clawchat 2026.5.12-2 → 2026.5.12-21

package/src/clawchat-memory.ts

@@ -0,0 +1,363 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+
+export type ClawChatMemoryTargetType = "owner" | "user" | "group";
+
+export interface ClawChatMemoryTarget {
+  targetType: ClawChatMemoryTargetType;
+  targetId: string;
+}
+
+export interface ClawChatMemoryFile {
+  exists: boolean;
+  metadata: Record<string, string>;
+  body: string;
+  raw: string;
+}
+
+const metadataStart = "<!-- clawchat:metadata:start -->";
+const metadataEnd = "<!-- clawchat:metadata:end -->";
+
+interface ParsedClawChatMemoryFile {
+  metadata: Record<string, string>;
+  body: string;
+  rawMetadataBlock: string | null;
+  rawBodyPrefix: string;
+  rawBody: string;
+}
+
+function assertValidTargetId(target: ClawChatMemoryTarget): void {
+  if (target.targetType !== "owner" && target.targetType !== "user" && target.targetType !== "group") {
+    throw new Error("Invalid clawchat memory targetType");
+  }
+  if (typeof target.targetId !== "string") {
+    throw new Error("Invalid clawchat memory targetId: targetId must be a string");
+  }
+  if (target.targetId.length === 0) {
+    throw new Error("Invalid clawchat memory targetId: targetId is required");
+  }
+  if (target.targetId === "." || target.targetId === ".." || target.targetId.includes("..")) {
+    throw new Error("Invalid clawchat memory targetId");
+  }
+  if (/[\/\\\p{Cc}]/u.test(target.targetId)) {
+    throw new Error("Invalid clawchat memory targetId");
+  }
+  if (target.targetType === "owner" && target.targetId !== "owner") {
+    throw new Error("Invalid clawchat memory owner targetId: owner targetId must be owner");
+  }
+}
+
+export function resolveClawChatMemoryPath(root: string, target: ClawChatMemoryTarget): string {
+  assertValidTargetId(target);
+
+  if (target.targetType === "owner") {
+    return path.resolve(root, "owner.md");
+  }
+  if (target.targetType === "user") {
+    return path.resolve(root, "users", `${target.targetId}.md`);
+  }
+  return path.resolve(root, "groups", `${target.targetId}.md`);
+}
+
+async function pathExists(candidate: string): Promise<boolean> {
+  try {
+    await fs.lstat(candidate);
+    return true;
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+      return false;
+    }
+    throw error;
+  }
+}
+
+function assertInsideRoot(root: string, candidate: string): void {
+  const relative = path.relative(root, candidate);
+  if (relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative))) {
+    return;
+  }
+  throw new Error(`Resolved clawchat memory path is outside root: ${candidate}`);
+}
+
+async function assertExistingDirectorySafe(rootRealPath: string, dirPath: string): Promise<void> {
+  let stat;
+  try {
+    stat = await fs.lstat(dirPath);
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+      return;
+    }
+    throw error;
+  }
+  if (stat.isSymbolicLink()) {
+    throw new Error(`Unsafe clawchat memory directory symlink: ${dirPath}`);
+  }
+  if (!stat.isDirectory()) {
+    throw new Error(`Unsafe clawchat memory parent is not a directory: ${dirPath}`);
+  }
+  assertInsideRoot(rootRealPath, await fs.realpath(dirPath));
+}
+
+export async function ensureClawChatMemoryTargetSafe(root: string, target: ClawChatMemoryTarget): Promise<string> {
+  const targetPath = resolveClawChatMemoryPath(root, target);
+  const rootPath = path.resolve(root);
+  const rootRealPath = (await pathExists(rootPath)) ? await fs.realpath(rootPath) : rootPath;
+  assertInsideRoot(rootPath, targetPath);
+
+  if (target.targetType !== "owner") {
+    await assertExistingDirectorySafe(rootRealPath, path.dirname(targetPath));
+  }
+
+  let stat;
+  try {
+    stat = await fs.lstat(targetPath);
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+      return targetPath;
+    }
+    throw error;
+  }
+  if (stat.isSymbolicLink()) {
+    throw new Error(`Unsafe clawchat memory target symlink: ${targetPath}`);
+  }
+  if (!stat.isFile()) {
+    throw new Error(`Unsafe clawchat memory target is not a regular file: ${targetPath}`);
+  }
+  assertInsideRoot(rootRealPath, await fs.realpath(targetPath));
+  return targetPath;
+}
+
+function normalizeLineEndings(value: string): string {
+  return value.replace(/\r\n?/g, "\n");
+}
+
+function normalizeMetadataValue(value: string): string {
+  return value.replace(/[\r\n]+/g, " ");
+}
+
+function consumeLineEnding(value: string, index: number): number {
+  if (value.startsWith("\r\n", index)) {
+    return 2;
+  }
+  if (value[index] === "\n" || value[index] === "\r") {
+    return 1;
+  }
+  return 0;
+}
+
+function splitRawBodySuffix(rawBodySuffix: string): { prefix: string; rawBody: string } {
+  let offset = consumeLineEnding(rawBodySuffix, 0);
+  if (offset === 0) {
+    return { prefix: "", rawBody: rawBodySuffix };
+  }
+
+  offset += consumeLineEnding(rawBodySuffix, offset);
+  return { prefix: rawBodySuffix.slice(0, offset), rawBody: rawBodySuffix.slice(offset) };
+}
+
+function parseMetadataBlock(rawMetadataBlock: string): Record<string, string> {
+  const metadata: Record<string, string> = {};
+  const lines = normalizeLineEndings(rawMetadataBlock).split("\n");
+  for (const line of lines.slice(1, -1)) {
+    const separatorIndex = line.indexOf(":");
+    if (separatorIndex <= 0) {
+      continue;
+    }
+    const key = line.slice(0, separatorIndex).trim();
+    if (key.length === 0) {
+      continue;
+    }
+    metadata[key] = line.slice(separatorIndex + 1).trimStart();
+  }
+  return metadata;
+}
+
+function parseClawChatMemoryRaw(raw: string): ParsedClawChatMemoryFile {
+  const firstLineEnd = raw.indexOf("\n");
+  const firstLineRawEnd = firstLineEnd === -1 ? raw.length : firstLineEnd;
+  const firstLineContentEnd = raw[firstLineRawEnd - 1] === "\r" ? firstLineRawEnd - 1 : firstLineRawEnd;
+
+  if (raw.slice(0, firstLineContentEnd) !== metadataStart) {
+    return { metadata: {}, body: normalizeLineEndings(raw), rawMetadataBlock: null, rawBodyPrefix: "", rawBody: raw };
+  }
+
+  let lineStart = firstLineEnd === -1 ? raw.length : firstLineEnd + 1;
+  while (lineStart < raw.length) {
+    const lineEnd = raw.indexOf("\n", lineStart);
+    const lineRawEnd = lineEnd === -1 ? raw.length : lineEnd;
+    const lineContentEnd = raw[lineRawEnd - 1] === "\r" ? lineRawEnd - 1 : lineRawEnd;
+    if (raw.slice(lineStart, lineContentEnd) === metadataEnd) {
+      const rawMetadataBlock = raw.slice(0, lineContentEnd);
+      const { prefix, rawBody } = splitRawBodySuffix(raw.slice(lineContentEnd));
+      return {
+        metadata: parseMetadataBlock(rawMetadataBlock),
+        body: normalizeLineEndings(rawBody),
+        rawMetadataBlock,
+        rawBodyPrefix: prefix,
+        rawBody,
+      };
+    }
+    if (lineEnd === -1) {
+      break;
+    }
+    lineStart = lineEnd + 1;
+  }
+
+  return { metadata: {}, body: normalizeLineEndings(raw), rawMetadataBlock: null, rawBodyPrefix: "", rawBody: raw };
+}
+
+function formatMetadataBlock(metadata: Record<string, string>): string {
+  const lines = [metadataStart];
+  for (const [key, value] of Object.entries(metadata)) {
+    lines.push(`${key}: ${normalizeMetadataValue(value)}`);
+  }
+  lines.push(metadataEnd);
+  return lines.join("\n");
+}
+
+function formatRawMemoryFile(parsed: ParsedClawChatMemoryFile, rawBody: string): string {
+  if (parsed.rawMetadataBlock === null) {
+    return rawBody;
+  }
+  if (rawBody.length === 0) {
+    return parsed.rawMetadataBlock;
+  }
+  return `${parsed.rawMetadataBlock}${parsed.rawBodyPrefix || "\n\n"}${rawBody}`;
+}
+
+function rawBodySuffixForMetadataReplacement(parsed: ParsedClawChatMemoryFile): string {
+  if (parsed.rawMetadataBlock === null) {
+    return parsed.rawBody.length === 0 ? "" : `\n\n${parsed.rawBody}`;
+  }
+  return `${parsed.rawBodyPrefix}${parsed.rawBody}`;
+}
+
+function normalizeWithRawBoundaryMap(raw: string): { normalized: string; rawBoundaries: number[] } {
+  let normalized = "";
+  const rawBoundaries = [0];
+  let rawIndex = 0;
+  while (rawIndex < raw.length) {
+    if (raw[rawIndex] === "\r") {
+      normalized += "\n";
+      rawIndex += raw[rawIndex + 1] === "\n" ? 2 : 1;
+    } else {
+      normalized += raw[rawIndex];
+      rawIndex += 1;
+    }
+    rawBoundaries.push(rawIndex);
+  }
+  return { normalized, rawBoundaries };
+}
+
+async function readExistingClawChatMemoryFile(root: string, target: ClawChatMemoryTarget): Promise<{
+  targetPath: string;
+  exists: boolean;
+  parsed: ParsedClawChatMemoryFile;
+  raw: string;
+}> {
+  const targetPath = await ensureClawChatMemoryTargetSafe(root, target);
+  let raw: string;
+  try {
+    raw = await fs.readFile(targetPath, "utf8");
+  } catch (error) {
+    if ((error as NodeJS.ErrnoException).code === "ENOENT") {
+      return {
+        targetPath,
+        exists: false,
+        parsed: { metadata: {}, body: "", rawMetadataBlock: null, rawBodyPrefix: "", rawBody: "" },
+        raw: "",
+      };
+    }
+    throw error;
+  }
+  return { targetPath, exists: true, parsed: parseClawChatMemoryRaw(raw), raw };
+}
+
+async function writeFileAtomically(targetPath: string, content: string): Promise<void> {
+  const dir = path.dirname(targetPath);
+  await fs.mkdir(dir, { recursive: true });
+  const tempPath = path.join(dir, `.${path.basename(targetPath)}.${randomUUID()}.tmp`);
+  try {
+    await fs.writeFile(tempPath, content, "utf8");
+    await fs.rename(tempPath, targetPath);
+  } catch (error) {
+    await fs.unlink(tempPath).catch(() => undefined);
+    throw error;
+  }
+}
+
+export async function readClawChatMemoryFile(root: string, target: ClawChatMemoryTarget): Promise<ClawChatMemoryFile> {
+  const file = await readExistingClawChatMemoryFile(root, target);
+  return {
+    exists: file.exists,
+    metadata: file.parsed.metadata,
+    body: file.parsed.body,
+    raw: file.raw,
+  };
+}
+
+export async function writeClawChatMemoryBody(
+  root: string,
+  target: ClawChatMemoryTarget,
+  mode: "append" | "replace",
+  content: string,
+): Promise<void> {
+  if (mode !== "append" && mode !== "replace") {
+    throw new Error("Invalid clawchat memory write mode");
+  }
+
+  const file = await readExistingClawChatMemoryFile(root, target);
+  let rawBody = file.parsed.rawBody;
+
+  if (mode === "replace") {
+    rawBody = content;
+  } else {
+    if (content.length === 0) {
+      throw new Error("clawchat memory append content must be non-empty");
+    }
+    if (rawBody.length === 0 || rawBody.endsWith("\n") || rawBody.endsWith("\r") || content.startsWith("\n") || content.startsWith("\r")) {
+      rawBody = `${rawBody}${content}`;
+    } else {
+      rawBody = `${rawBody}\n${content}`;
+    }
+  }
+
+  await writeFileAtomically(file.targetPath, formatRawMemoryFile(file.parsed, rawBody));
+}
+
+export async function editClawChatMemoryBody(
+  root: string,
+  target: ClawChatMemoryTarget,
+  oldText: string,
+  newText: string,
+): Promise<void> {
+  const normalizedOldText = normalizeLineEndings(oldText);
+  if (normalizedOldText.length === 0) {
+    throw new Error("clawchat memory edit oldText must be non-empty");
+  }
+
+  const file = await readExistingClawChatMemoryFile(root, target);
+  const { normalized: body, rawBoundaries } = normalizeWithRawBoundaryMap(file.parsed.rawBody);
+  const firstIndex = body.indexOf(normalizedOldText);
+  if (firstIndex === -1 || body.indexOf(normalizedOldText, firstIndex + 1) !== -1) {
+    throw new Error("clawchat memory edit requires exactly one oldText match");
+  }
+
+  const updatedRawBody = `${file.parsed.rawBody.slice(0, rawBoundaries[firstIndex])}${normalizeLineEndings(
+    newText,
+  )}${file.parsed.rawBody.slice(rawBoundaries[firstIndex + normalizedOldText.length])}`;
+  await writeFileAtomically(file.targetPath, formatRawMemoryFile(file.parsed, updatedRawBody));
+}
+
+export async function writeClawChatMetadata(
+  root: string,
+  target: ClawChatMemoryTarget,
+  metadata: Record<string, string>,
+): Promise<void> {
+  const file = await readExistingClawChatMemoryFile(root, target);
+  await writeFileAtomically(
+    file.targetPath,
+    `${formatMetadataBlock(metadata)}${rawBodySuffixForMetadataReplacement(file.parsed)}`,
+  );
+}