@clawling/clawchat-plugin-openclaw 2026.5.12-28

package/dist/src/clawchat-memory.js

@@ -0,0 +1,403 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+import { getDefaultGroupBioPrompt, getDefaultOwnerBehaviorPrompt } from "./plugin-prompts.js";
+const metadataStart = "<!-- clawchat:metadata:start -->";
+const metadataEnd = "<!-- clawchat:metadata:end -->";
+function assertValidTargetId(target) {
+    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, target) {
+    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) {
+    try {
+        await fs.lstat(candidate);
+        return true;
+    }
+    catch (error) {
+        if (error.code === "ENOENT") {
+            return false;
+        }
+        throw error;
+    }
+}
+function assertInsideRoot(root, candidate) {
+    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, dirPath) {
+    let stat;
+    try {
+        stat = await fs.lstat(dirPath);
+    }
+    catch (error) {
+        if (error.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));
+}
+async function listSafeMemoryFiles(root, rootRealPath, targetType) {
+    if (targetType === "owner") {
+        return [{ targetType: "owner", targetId: "owner" }];
+    }
+    const dirPath = path.resolve(root, targetType === "user" ? "users" : "groups");
+    await assertExistingDirectorySafe(rootRealPath, dirPath);
+    if (!(await pathExists(dirPath))) {
+        return [];
+    }
+    const entries = await fs.readdir(dirPath, { withFileTypes: true });
+    const targets = [];
+    for (const entry of entries) {
+        if (!entry.name.endsWith(".md")) {
+            continue;
+        }
+        const targetId = entry.name.slice(0, -3);
+        assertValidTargetId({ targetType, targetId });
+        targets.push({ targetType, targetId });
+    }
+    targets.sort((a, b) => a.targetId.localeCompare(b.targetId));
+    return targets;
+}
+export async function ensureClawChatMemoryTargetSafe(root, target) {
+    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.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) {
+    return value.replace(/\r\n?/g, "\n");
+}
+function normalizeMetadataValue(value) {
+    return value.replace(/[\r\n]+/g, " ");
+}
+function consumeLineEnding(value, index) {
+    if (value.startsWith("\r\n", index)) {
+        return 2;
+    }
+    if (value[index] === "\n" || value[index] === "\r") {
+        return 1;
+    }
+    return 0;
+}
+function splitRawBodySuffix(rawBodySuffix) {
+    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) {
+    const metadata = {};
+    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) {
+    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) {
+    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, rawBody) {
+    if (parsed.rawMetadataBlock === null) {
+        return rawBody;
+    }
+    if (rawBody.length === 0) {
+        return parsed.rawMetadataBlock;
+    }
+    return `${parsed.rawMetadataBlock}${parsed.rawBodyPrefix || "\n\n"}${rawBody}`;
+}
+function rawBodySuffixForMetadataReplacement(parsed) {
+    if (parsed.rawMetadataBlock === null) {
+        return parsed.rawBody.length === 0 ? "" : `\n\n${parsed.rawBody}`;
+    }
+    return `${parsed.rawBodyPrefix}${parsed.rawBody}`;
+}
+function metadataWithInitialDefaults(target, exists, metadata) {
+    if (exists) {
+        return metadata;
+    }
+    if (target.targetType === "owner" &&
+        Object.prototype.hasOwnProperty.call(metadata, "agent_behavior") &&
+        metadata.agent_behavior.trim().length === 0) {
+        return { ...metadata, agent_behavior: getDefaultOwnerBehaviorPrompt() };
+    }
+    if (target.targetType === "group" &&
+        Object.prototype.hasOwnProperty.call(metadata, "group_description") &&
+        metadata.group_description.trim().length === 0) {
+        return { ...metadata, group_description: getDefaultGroupBioPrompt() };
+    }
+    return metadata;
+}
+function normalizeWithRawBoundaryMap(raw) {
+    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, target) {
+    const targetPath = await ensureClawChatMemoryTargetSafe(root, target);
+    let raw;
+    try {
+        raw = await fs.readFile(targetPath, "utf8");
+    }
+    catch (error) {
+        if (error.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, content) {
+    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, target) {
+    const file = await readExistingClawChatMemoryFile(root, target);
+    return {
+        exists: file.exists,
+        metadata: file.parsed.metadata,
+        body: file.parsed.body,
+        raw: file.raw,
+    };
+}
+function normalizeSearchParams(params) {
+    const query = params.query.trim();
+    if (query.length === 0) {
+        throw new Error("clawchat memory search query is required");
+    }
+    const targetTypes = params.targetTypes ?? ["owner", "user", "group"];
+    if (targetTypes.length === 0 ||
+        targetTypes.some((targetType) => targetType !== "owner" && targetType !== "user" && targetType !== "group")) {
+        throw new Error("Invalid clawchat memory search targetTypes");
+    }
+    const maxResults = params.maxResults ?? 10;
+    if (!Number.isInteger(maxResults) || maxResults < 1 || maxResults > 50) {
+        throw new Error("clawchat memory search maxResults must be between 1 and 50");
+    }
+    return { query, queryLower: query.toLocaleLowerCase(), targetTypes, maxResults };
+}
+function firstMatchingLine(value, queryLower) {
+    for (const line of normalizeLineEndings(value).split("\n")) {
+        if (line.toLocaleLowerCase().includes(queryLower)) {
+            return line.length <= 300 ? line : `${line.slice(0, 297)}...`;
+        }
+    }
+    return null;
+}
+function buildSearchMatch(target, file, queryLower) {
+    const matchedFields = [];
+    const snippets = [];
+    const metadataText = Object.entries(file.metadata).map(([key, value]) => `${key}: ${value}`).join("\n");
+    const metadataSnippet = firstMatchingLine(metadataText, queryLower);
+    if (metadataSnippet !== null) {
+        matchedFields.push("metadata");
+        snippets.push(metadataSnippet);
+    }
+    const bodySnippet = firstMatchingLine(file.body, queryLower);
+    if (bodySnippet !== null) {
+        matchedFields.push("body");
+        if (!snippets.includes(bodySnippet)) {
+            snippets.push(bodySnippet);
+        }
+    }
+    if (matchedFields.length === 0) {
+        return null;
+    }
+    return { ...target, matchedFields, snippets: snippets.slice(0, 3) };
+}
+export async function searchClawChatMemory(root, params) {
+    const { query, queryLower, targetTypes, maxResults } = normalizeSearchParams(params);
+    const rootPath = path.resolve(root);
+    const rootRealPath = (await pathExists(rootPath)) ? await fs.realpath(rootPath) : rootPath;
+    const matches = [];
+    for (const targetType of targetTypes) {
+        const targets = await listSafeMemoryFiles(rootPath, rootRealPath, targetType);
+        for (const target of targets) {
+            const file = await readClawChatMemoryFile(rootPath, target);
+            if (!file.exists) {
+                continue;
+            }
+            const match = buildSearchMatch(target, file, queryLower);
+            if (match !== null) {
+                matches.push(match);
+            }
+        }
+    }
+    return { query, matches: matches.slice(0, maxResults), truncated: matches.length > maxResults };
+}
+export async function deleteClawChatMemoryFile(root, target) {
+    const targetPath = await ensureClawChatMemoryTargetSafe(root, target);
+    await fs.unlink(targetPath).catch((error) => {
+        if (error.code !== "ENOENT") {
+            throw error;
+        }
+    });
+}
+export async function writeClawChatMemoryBody(root, target, mode, content) {
+    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, target, oldText, newText) {
+    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, target, metadata) {
+    const file = await readExistingClawChatMemoryFile(root, target);
+    const metadataToWrite = metadataWithInitialDefaults(target, file.exists, metadata);
+    await writeFileAtomically(file.targetPath, `${formatMetadataBlock(metadataToWrite)}${rawBodySuffixForMetadataReplacement(file.parsed)}`);
+}