import { describe, it, beforeEach, afterEach } from "node:test";
import assert from "node:assert/strict";
import { createServer, type Server, type IncomingMessage, type ServerResponse } from "node:http";
import { mkdtemp, readFile, rm } from "fs/promises";
import { join } from "path";
import { tmpdir } from "os";
import claudeMemPlugin from "./index.js";
async function waitFor(condition: () => boolean): Promise<void> {
const deadline = performance.now() + 2000;
while (!condition()) {
assert.ok(performance.now() < deadline, "condition did not become true");
await new Promise((resolve) => setTimeout(resolve, 5));
}
}
async function unusedPort(): Promise<number> {
const server = createServer();
await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
const port = (server.address() as { port: number }).port;
await new Promise<void>((resolve, reject) => server.close((error) => error ? reject(error) : resolve()));
return port;
}
// The hook set depends on the host: 2026.2.9 predates before_prompt_build;
// 2026.2.17 through 2026.7.35 have both; 2026.8.1 on no longer know
// before_agent_start.
const CURRENT_OPENCLAW_HOST = "2026.11.2";
const LEGACY_OPENCLAW_HOST = "2026.2.9";
const BOTH_HOOKS_OPENCLAW_HOST = "2026.6.1";
// Pass null for a host that reports no version.
function createMockApi(pluginConfigOverride: Record<string, any> = {}, openClawHostVersion: string | null = CURRENT_OPENCLAW_HOST) {
const logs: string[] = [];
const sentMessages: Array<{ to: string; text: string; channel: string; opts?: any }> = [];
let registeredService: any = null;
const registeredCommands: Map<string, any> = new Map();
const eventHandlers: Map<string, Function[]> = new Map();
const api = {
id: "claude-mem",
name: "Claude-Mem (Persistent Memory)",
version: "1.0.0",
source: "/test/extensions/claude-mem/dist/index.js",
config: {},
pluginConfig: pluginConfigOverride,
logger: {
info: (message: string) => { logs.push(message); },
warn: (message: string) => { logs.push(message); },
error: (message: string) => { logs.push(message); },
debug: (message: string) => { logs.push(message); },
},
registerService: (service: any) => {
registeredService = service;
},
registerCommand: (command: any) => {
registeredCommands.set(command.name, command);
},
on: (event: string, callback: Function) => {
if (!eventHandlers.has(event)) {
eventHandlers.set(event, []);
}
eventHandlers.get(event)!.push(callback);
},
runtime: {
version: openClawHostVersion ?? undefined,
channel: {
telegram: {
sendMessageTelegram: async (to: string, text: string) => {
sentMessages.push({ to, text, channel: "telegram" });
},
},
discord: {
sendMessageDiscord: async (to: string, text: string) => {
sentMessages.push({ to, text, channel: "discord" });
},
},
signal: {
sendMessageSignal: async (to: string, text: string) => {
sentMessages.push({ to, text, channel: "signal" });
},
},
slack: {
sendMessageSlack: async (to: string, text: string) => {
sentMessages.push({ to, text, channel: "slack" });
},
},
whatsapp: {
sendMessageWhatsApp: async (to: string, text: string, opts?: { verbose: boolean }) => {
sentMessages.push({ to, text, channel: "whatsapp", opts });
},
},
line: {
sendMessageLine: async (to: string, text: string) => {
sentMessages.push({ to, text, channel: "line" });
},
},
},
},
};
return {
api: api as any,
logs,
sentMessages,
getService: () => registeredService,
getCommand: (name?: string) => {
if (name) return registeredCommands.get(name);
return registeredCommands.get("claude_mem_feed");
},
getEventHandlers: (event: string) => eventHandlers.get(event) || [],
fireEvent: async (event: string, data: any, ctx: any = {}) => {
const handlers = eventHandlers.get(event) || [];
let lastResult: any;
for (const handler of handlers) {
lastResult = await handler(data, ctx);
}
return lastResult;
},
};
}
describe("worker request deadlines", () => {
const realTimeout = AbortSignal.timeout;
async function resetGateway() {
const { api, fireEvent } = createMockApi();
claudeMemPlugin(api);
await fireEvent("gateway_start", {}, {});
}
beforeEach(async () => {
await resetGateway();
// Keep real HTTP and abort behavior, shortening only the deadline clock.
AbortSignal.timeout = (ms: number) => realTimeout(Math.min(ms, 50));
});
afterEach(async () => {
AbortSignal.timeout = realTimeout;
await resetGateway();
});
async function stalledWorker(stage: "headers" | "body") {
let requests = 0;
let closed = 0;
const server = createServer((req, res) => {
req.resume();
req.on("end", () => {
requests++;
res.on("close", () => { closed++; });
if (stage === "body") {
res.writeHead(200, { "Content-Type": "application/json" });
res.write("{");
}
});
});
await new Promise<void>(resolve => server.listen(0, "127.0.0.1", resolve));
return {
port: (server.address() as { port: number }).port,
requests: () => requests,
closed: () => closed,
async close() {
server.closeAllConnections();
await new Promise<void>(resolve => server.close(() => resolve()));
},
};
}
async function bounded<T>(work: Promise<T>): Promise<T> {
let timer: ReturnType<typeof setTimeout> | undefined;
try {
return await Promise.race([work, new Promise<never>((_, reject) => {
timer = setTimeout(() => reject(new Error("worker request never reached its deadline")), 1000);
})]);
} finally { clearTimeout(timer); }
}
// The legacy hook only inits the session; before_prompt_build inits and
// fetches context concurrently.
for (const [hook, hostVersion, expectedRequests] of [
["before_agent_start", LEGACY_OPENCLAW_HOST, 1],
["before_prompt_build", CURRENT_OPENCLAW_HOST, 2],
] as const) {
for (const stage of ["headers", "body"] as const) {
it(`releases ${hook} when the worker stalls its ${stage}`, async () => {
const server = await stalledWorker(stage);
const { api, fireEvent, logs } = createMockApi({ workerPort: server.port, workerHost: "127.0.0.1", syncMemoryFile: true }, hostVersion);
claudeMemPlugin(api);
const pending = fireEvent(hook, { prompt: "A public prompt" }, { sessionKey: "deadline", agentId: "main" });
try {
await bounded(pending);
await waitFor(() => server.closed() === expectedRequests);
assert.equal(server.requests(), expectedRequests);
assert.ok(logs.some(line => line.includes("failed:")));
} finally {
await server.close();
await pending;
}
});
}
}
it("bounds fire-and-forget capture when the worker never sends headers", async () => {
const server = await stalledWorker("headers");
const { api, fireEvent, logs } = createMockApi({ workerPort: server.port, workerHost: "127.0.0.1" });
claudeMemPlugin(api);
try {
await fireEvent("after_tool_call", { toolName: "read", params: { path: "file.txt" }, result: "done" }, { sessionKey: "capture-deadline" });
await waitFor(() => logs.some(line => line.includes("failed:")));
await waitFor(() => server.closed() === 1);
assert.equal(server.requests(), 1);
} finally { await server.close(); }
});
it("counts stalled successful bodies as consecutive breaker failures", async () => {
const server = await stalledWorker("body");
const { api, fireEvent, logs } = createMockApi({ workerPort: server.port, workerHost: "127.0.0.1" }, LEGACY_OPENCLAW_HOST);
claudeMemPlugin(api);
let pending: Promise<unknown> | undefined;
try {
for (let i = 0; i < 4; i++) {
pending = fireEvent("before_agent_start", { prompt: `Prompt ${i}` }, { sessionKey: "body-deadline" });
await bounded(pending);
}
assert.equal(server.requests(), 3);
assert.ok(logs.some(line => line.includes("disabling requests")));
} finally {
await server.close();
await pending;
}
});
});
describe("claudeMemPlugin", () => {
it("registers the service without a transcript transform", () => {
const { api, getService, getEventHandlers } = createMockApi();
claudeMemPlugin(api);
assert.equal(getService().id, "claude-mem-observation-feed");
assert.equal(getEventHandlers("tool_result_persist").length, 0, "transcript transforms must not duplicate completed observations");
});
describe("service start", () => {
for (const [label, config, message] of [
["feed not enabled", {}, "feed disabled"],
["enabled is false", { observationFeed: { enabled: false } }, "feed disabled"],
["channel is missing", { observationFeed: { enabled: true, to: "123" } }, "misconfigured"],
["to is missing", { observationFeed: { enabled: true, channel: "telegram" } }, "misconfigured"],
] as const) {
it(`logs when ${label}`, async () => {
const { api, logs, getService } = createMockApi(config);
claudeMemPlugin(api);
await getService().start({});
assert.ok(logs.some((line) => line.includes(message)));
});
}
});
describe("service stop", () => {
it("logs disconnection on stop", async () => {
const { api, logs, getService } = createMockApi({});
claudeMemPlugin(api);
await getService().stop({});
assert.ok(logs.some((l) => l.includes("feed stopped")));
});
});
describe("command handler", () => {
it("returns not configured when no feedConfig", async () => {
const { api, getCommand } = createMockApi({});
claudeMemPlugin(api);
const result = await getCommand().handler({ args: "", channel: "telegram", isAuthorizedSender: true, commandBody: "/claude_mem_feed", config: {} });
assert.ok(result.text.includes("not configured"));
});
it("returns status when no args", async () => {
const { api, getCommand } = createMockApi({
observationFeed: { enabled: true, channel: "telegram", to: "123" },
});
claudeMemPlugin(api);
const result = await getCommand().handler({ args: "", channel: "telegram", isAuthorizedSender: true, commandBody: "/claude_mem_feed", config: {} });
assert.ok(result.text.includes("Enabled: yes"));
assert.ok(result.text.includes("Channel: telegram"));
assert.ok(result.text.includes("Target: 123"));
assert.ok(result.text.includes("Connection: disconnected"));
});
});
});
describe("Observation I/O event handlers", () => {
let workerServer: Server;
let workerPort: number;
let receivedRequests: Array<{ method: string; url: string; body: any }> = [];
function startWorkerMock(): Promise<number> {
return new Promise((resolve) => {
workerServer = createServer((req: IncomingMessage, res: ServerResponse) => {
let body = "";
req.on("data", (chunk) => { body += chunk.toString(); });
req.on("end", () => {
let parsedBody: any = null;
try { parsedBody = JSON.parse(body); } catch {}
receivedRequests.push({
method: req.method || "GET",
url: req.url || "/",
body: parsedBody,
});
if (req.url === "/api/health") {
res.writeHead(200, { "Content-Type": "application/json" });
res.end(JSON.stringify({ status: "ok" }));
return;
}
if (req.url === "/api/sessions/init") {
res.writeHead(200, { "Content-Type": "application/json" });
res.end(JSON.stringify({ sessionDbId: 1, promptNumber: 1, skipped: false }));
return;
}
if (req.url === "/api/sessions/observations") {
res.writeHead(200, { "Content-Type": "application/json" });
res.end(JSON.stringify({ status: "queued" }));
return;
}
if (req.url === "/api/sessions/summarize") {
res.writeHead(200, { "Content-Type": "application/json" });
res.end(JSON.stringify({ status: "queued" }));
return;
}
if (req.url?.startsWith("/api/context/inject")) {
res.writeHead(200, { "Content-Type": "text/plain; charset=utf-8" });
res.end("# Claude-Mem Context\n\n## Timeline\n- Session 1: Did some work");
return;
}
// The worker answers these routes in the MCP tool shape.
if (req.url?.startsWith("/api/search/observations")) {
res.writeHead(200, { "Content-Type": "application/json" });
res.end(JSON.stringify({ content: [{ type: "text", text: "| #12 | Fix JWT refresh |" }] }));
return;
}
if (req.url?.startsWith("/api/context/recent")) {
res.writeHead(200, { "Content-Type": "application/json" });
res.end(JSON.stringify({ content: [{ type: "text", text: "## Session S4: Added token rotation" }] }));
return;
}
if (req.url?.startsWith("/api/timeline/by-query")) {
res.writeHead(200, { "Content-Type": "application/json" });
res.end(JSON.stringify({ content: [{ type: "text", text: "Anchor #12: Fix JWT refresh" }] }));
return;
}
if (req.url === "/stream") {
res.writeHead(200, {
"Content-Type": "text/event-stream",
"Cache-Control": "no-cache",
Connection: "keep-alive",
});
return;
}
res.writeHead(404);
res.end();
});
});
workerServer.listen(0, () => {
const address = workerServer.address();
if (address && typeof address === "object") {
resolve(address.port);
}
});
});
}
beforeEach(async () => {
receivedRequests = [];
workerPort = await startWorkerMock();
});
afterEach(() => {
workerServer?.close();
});
it("session_start sends session init to worker", async () => {
const { api, logs, fireEvent } = createMockApi({ workerPort });
claudeMemPlugin(api);
await fireEvent("session_start", {
sessionId: "test-session-1",
}, { sessionKey: "agent-1" });
const initRequests = receivedRequests.filter((r) => r.url === "/api/sessions/init");
assert.equal(initRequests.length, 1, "should init once on session_start");
const initRequest = initRequests[0];
assert.ok(initRequest, "should send init request to worker");
assert.equal(initRequest!.body.project, "openclaw");
assert.ok(initRequest!.body.contentSessionId.startsWith("openclaw-agent-1-"));
assert.ok(logs.some((l) => l.includes("Session initialized")));
});
it("after_compaction re-inits session on worker", async () => {
const { api, fireEvent } = createMockApi({ workerPort });
claudeMemPlugin(api);
await fireEvent("after_compaction", { messageCount: 5, compactedCount: 3 }, {});
const initRequests = receivedRequests.filter((r) => r.url === "/api/sessions/init");
assert.equal(initRequests.length, 1, "should re-init after compaction");
});
it("after_tool_call skips memory_ tools", async () => {
const { api, fireEvent } = createMockApi({ workerPort });
claudeMemPlugin(api);
await fireEvent("after_tool_call", {
toolName: "memory_search",
params: {},
}, {});
await fireEvent("after_tool_call", { toolName: "Read", params: {}, result: "sentinel" }, {});
await waitFor(() => receivedRequests.some((r) => r.body?.tool_response === "sentinel"));
const observations = receivedRequests.filter((r) => r.url === "/api/sessions/observations");
assert.equal(observations.length, 1, "should skip memory_ tools");
assert.equal(observations[0].body.tool_name, "Read");
});
for (const [toolName, params, result] of [
["Bash", { command: "ls" }, { content: [{ type: "text", text: "x".repeat(2000) }] }],
["custom_tool", { owned: true }, "x".repeat(2000)],
] as const) {
it(`after_tool_call truncates ${toolName} responses`, async () => {
const { api, fireEvent } = createMockApi({ workerPort });
claudeMemPlugin(api);
await fireEvent("after_tool_call", { toolName, params, result }, { sessionKey: "long-result" });
await waitFor(() => receivedRequests.some((r) => r.url === "/api/sessions/observations"));
const request = receivedRequests.find((r) => r.url === "/api/sessions/observations")!;
assert.equal(request.body.tool_response, "x".repeat(1000));
assert.equal(request.body.tool_name, toolName);
assert.deepEqual(request.body.tool_input, params);
});
}
for (const [label, result, expected] of [
["a private span crossing the cap", `${"a".repeat(990)}<private>${"SECRET".repeat(20)}</private>tail`, `${"a".repeat(990)}tail`],
["an unclosed private span", `${"a".repeat(990)}<private>${"SECRET".repeat(20)}`, "a".repeat(990)],
["nested private spans", "before<private>SECRET<private>INNER</private>SECRET</private>after", "beforeafter"],
["private content in text blocks", { content: [{ type: "text", text: "before<private>SECRET</private>after" }] }, "beforeafter"],
] as const) {
it(`after_tool_call removes ${label} before truncating`, async () => {
const { api, fireEvent } = createMockApi({ workerPort });
claudeMemPlugin(api);
await fireEvent("after_tool_call", { toolName: "read", result }, { sessionKey: "private-result" });
await waitFor(() => receivedRequests.some((r) => r.url === "/api/sessions/observations"));
const request = receivedRequests.find((r) => r.url === "/api/sessions/observations")!;
assert.equal(request.body.tool_response, expected);
});
}
it("after_tool_call keeps a failed call's error text", async () => {
const { api, fireEvent } = createMockApi({ workerPort });
claudeMemPlugin(api);
await fireEvent("after_tool_call", {
toolName: "read", params: { path: "/x" }, error: "ENOENT: no such file",
}, { sessionKey: "failed-read" });
await waitFor(() => receivedRequests.some((r) => r.url === "/api/sessions/observations"));
const request = receivedRequests.find((r) => r.url === "/api/sessions/observations");
assert.ok(request);
assert.equal(request.body.tool_name, "Read");
assert.equal(request.body.tool_response.is_error, true);
assert.match(request.body.tool_response.error, /ENOENT: no such file/);
});
it("after_tool_call records a call from a host build that omits params", async () => {
const { api, fireEvent } = createMockApi({ workerPort });
claudeMemPlugin(api);
await fireEvent("after_tool_call", { toolName: "read", result: "contents" }, { sessionKey: "no-params" });
await waitFor(() => receivedRequests.some((r) => r.url === "/api/sessions/observations"));
const request = receivedRequests.find((r) => r.url === "/api/sessions/observations");
assert.ok(request);
assert.deepEqual(request.body.tool_input, {});
assert.equal(request.body.tool_response, "contents");
assert.equal(Object.hasOwn(request.body, "tool_use_id"), false, "older hosts without a native ID must still capture normally");
});
it("agent_end sends summarize and complete to worker", async () => {
const { api, fireEvent } = createMockApi({ workerPort });
claudeMemPlugin(api);
await fireEvent("session_start", { sessionId: "s1" }, { sessionKey: "summarize-test" });
await fireEvent("agent_end", {
messages: [
{ role: "user", content: "help me" },
{ role: "assistant", content: "Here is the solution..." },
],
}, { sessionKey: "summarize-test" });
const summarizeRequest = receivedRequests.find((r) => r.url === "/api/sessions/summarize");
assert.ok(summarizeRequest, "should send summarize to worker");
assert.equal(summarizeRequest!.body.last_assistant_message, "Here is the solution...");
assert.ok(summarizeRequest!.body.contentSessionId.startsWith("openclaw-summarize-test-"));
const completeRequest = receivedRequests.find((r) => r.url === "/api/sessions/complete");
assert.ok(!completeRequest, "should not send complete (worker self-completes)");
});
it("agent_end extracts text from array content", async () => {
const { api, fireEvent } = createMockApi({ workerPort });
claudeMemPlugin(api);
await fireEvent("session_start", { sessionId: "s1" }, { sessionKey: "array-content" });
await fireEvent("agent_end", {
messages: [
{
role: "assistant",
content: [
{ type: "text", text: "First part" },
{ type: "text", text: "Second part" },
],
},
],
}, { sessionKey: "array-content" });
const summarizeRequest = receivedRequests.find((r) => r.url === "/api/sessions/summarize");
assert.ok(summarizeRequest, "should send summarize");
assert.equal(summarizeRequest!.body.last_assistant_message, "First part\nSecond part");
});
it("uses custom project name from config", async () => {
const { api, fireEvent } = createMockApi({ workerPort, project: "my-project" });
claudeMemPlugin(api);
await fireEvent("session_start", { sessionId: "s1" }, {});
const initRequest = receivedRequests.find((r) => r.url === "/api/sessions/init");
assert.ok(initRequest, "should send init");
assert.equal(initRequest!.body.project, "my-project");
});
it("stamps platformSource openclaw on session init, observation and summarize posts", async () => {
const { api, fireEvent } = createMockApi({ workerPort });
claudeMemPlugin(api);
await fireEvent("session_start", { sessionId: "s1" }, { sessionKey: "source-test" });
await fireEvent("after_tool_call", {
toolName: "Read",
params: { file_path: "/src/index.ts" },
result: { content: [{ type: "text", text: "contents" }] },
}, { sessionKey: "source-test" });
await fireEvent("agent_end", {
messages: [{ role: "assistant", content: "done" }],
}, { sessionKey: "source-test" });
await waitFor(() => receivedRequests.some((r) => r.url === "/api/sessions/observations"));
for (const url of ["/api/sessions/init", "/api/sessions/observations", "/api/sessions/summarize"]) {
const request = receivedRequests.find((r) => r.url === url);
assert.ok(request, `should send ${url}`);
assert.equal(request!.body.platformSource, "openclaw", url);
}
});
it("claude_mem_status command reports worker health", async () => {
const { api, getCommand } = createMockApi({ workerPort });
claudeMemPlugin(api);
const statusCmd = getCommand("claude_mem_status");
assert.ok(statusCmd, "status command should exist");
const result = await statusCmd.handler({ args: "", channel: "telegram", isAuthorizedSender: true, commandBody: "/claude_mem_status", config: {} });
assert.ok(result.text.includes("Status: ok"));
assert.ok(result.text.includes(`Port: ${workerPort}`));
});
it("search, recent and timeline commands render the worker's text result", async () => {
const { api, getCommand } = createMockApi({ workerPort });
claudeMemPlugin(api);
const ctx = (args: string) => ({ args, channel: "telegram", isAuthorizedSender: true, commandBody: "", config: {} });
const search = await getCommand("claude-mem-search").handler(ctx("jwt"));
assert.ok(search.includes("| #12 | Fix JWT refresh |"), search);
assert.ok(!search.includes("No results found."), search);
const recent = await getCommand("claude-mem-recent").handler(ctx(""));
assert.ok(recent.includes("## Session S4: Added token rotation"), recent);
const timeline = await getCommand("claude-mem-timeline").handler(ctx("jwt"));
assert.ok(timeline.includes("Anchor #12: Fix JWT refresh"), timeline);
});
it("claude-mem-search keeps a one-word numeric query and reads a trailing number as the limit", async () => {
const { api, getCommand } = createMockApi({ workerPort });
claudeMemPlugin(api);
const ctx = (args: string) => ({ args, channel: "telegram", isAuthorizedSender: true, commandBody: "", config: {} });
const searched = () => receivedRequests.filter((r) => r.url.startsWith("/api/search/observations")).at(-1)!.url;
const result = await getCommand("claude-mem-search").handler(ctx("4019"));
assert.equal(searched(), "/api/search/observations?query=4019&limit=10");
assert.ok(result.startsWith('Claude-Mem Search: "4019"'), result);
await getCommand("claude-mem-search").handler(ctx("port 4019 3"));
assert.equal(searched(), "/api/search/observations?query=port%204019&limit=3");
});
it("claude_mem_status reports unreachable when worker is down", async () => {
const { api, getCommand } = createMockApi({ workerPort: await unusedPort() });
claudeMemPlugin(api);
const statusCmd = getCommand("claude_mem_status");
const result = await statusCmd.handler({ args: "", channel: "telegram", isAuthorizedSender: true, commandBody: "/claude_mem_status", config: {} });
assert.ok(result.text.includes("unreachable"));
});
it("reuses same contentSessionId for same sessionKey", async () => {
const { api, fireEvent } = createMockApi({ workerPort });
claudeMemPlugin(api);
await fireEvent("session_start", { sessionId: "s1" }, { sessionKey: "reuse-test" });
await fireEvent("after_tool_call", {
toolName: "Read",
params: { file_path: "/src/index.ts" },
result: { content: [{ type: "text", text: "contents" }] },
}, { sessionKey: "reuse-test" });
const initRequest = receivedRequests.find((r) => r.url === "/api/sessions/init");
await waitFor(() => receivedRequests.some((r) => r.url === "/api/sessions/observations"));
const obsRequest = receivedRequests.find((r) => r.url === "/api/sessions/observations");
assert.ok(initRequest && obsRequest, "both requests should exist");
assert.equal(
initRequest!.body.contentSessionId,
obsRequest!.body.contentSessionId,
"should reuse contentSessionId for same sessionKey"
);
});
});
describe("before_prompt_build context injection", () => {
let workerServer: Server;
let workerPort: number;
let receivedRequests: Array<{ method: string; url: string; body: any }> = [];
let contextResponse = "# Claude-Mem Context\n\n## Timeline\n- Session 1: Did some work";
function startWorkerMock(): Promise<number> {
return new Promise((resolve) => {
workerServer = createServer((req: IncomingMessage, res: ServerResponse) => {
let body = "";
req.on("data", (chunk) => { body += chunk.toString(); });
req.on("end", () => {
let parsedBody: any = null;
try { parsedBody = JSON.parse(body); } catch {}
receivedRequests.push({
method: req.method || "GET",
url: req.url || "/",
body: parsedBody,
});
if (req.url?.startsWith("/api/context/inject")) {
res.writeHead(200, { "Content-Type": "text/plain; charset=utf-8" });
res.end(contextResponse);
return;
}
if (req.url === "/api/sessions/init") {
res.writeHead(200, { "Content-Type": "application/json" });
res.end(JSON.stringify({ sessionDbId: 1, promptNumber: 1, skipped: false }));
return;
}
res.writeHead(200, { "Content-Type": "application/json" });
res.end(JSON.stringify({ status: "ok" }));
});
});
workerServer.listen(0, () => {
const address = workerServer.address();
if (address && typeof address === "object") {
resolve(address.port);
}
});
});
}
beforeEach(async () => {
receivedRequests = [];
contextResponse = "# Claude-Mem Context\n\n## Timeline\n- Session 1: Did some work";
workerPort = await startWorkerMock();
});
afterEach(async () => {
workerServer?.close();
});
it("does not write MEMORY.md or fetch context during capture", async () => {
const tmpDir = await mkdtemp(join(tmpdir(), "claude-mem-test-"));
try {
const { api, fireEvent } = createMockApi({ workerPort }, LEGACY_OPENCLAW_HOST);
claudeMemPlugin(api);
const ctx = { sessionKey: "tool-sync", workspaceDir: tmpDir };
await fireEvent("before_agent_start", { prompt: "Help me write a function" }, ctx);
await assert.rejects(readFile(join(tmpDir, "MEMORY.md"), "utf-8"), { code: "ENOENT" });
await fireEvent("after_tool_call", {
toolName: "Read", params: { file_path: "/src/app.ts" },
result: { content: [{ type: "text", text: "file contents" }] },
}, ctx);
await waitFor(() => receivedRequests.some((r) => r.url === "/api/sessions/observations"));
assert.equal(receivedRequests.filter((r) => r.url?.startsWith("/api/context/inject")).length, 0);
await assert.rejects(readFile(join(tmpDir, "MEMORY.md"), "utf-8"), { code: "ENOENT" });
} finally {
await rm(tmpDir, { recursive: true, force: true });
}
});
it("skips context injection when syncMemoryFile is false", async () => {
const { api, fireEvent } = createMockApi({ workerPort, syncMemoryFile: false });
claudeMemPlugin(api);
const result = await fireEvent("before_prompt_build", {
prompt: "Help me write a function",
messages: [],
}, { agentId: "main" });
const contextRequest = receivedRequests.find((r) => r.url?.startsWith("/api/context/inject"));
assert.ok(!contextRequest, "should not fetch context when injection disabled");
assert.equal(result, undefined, "should return undefined when injection disabled");
});
it("injects context only for non-excluded agents", async () => {
const { api, fireEvent } = createMockApi({ workerPort, syncMemoryFileExclude: ["snarf"] });
claudeMemPlugin(api);
const excluded = await fireEvent("before_prompt_build", { prompt: "Help me", messages: [] }, { agentId: "snarf" });
assert.equal(excluded, undefined, "should return undefined for excluded agent");
assert.ok(!receivedRequests.some((r) => r.url?.startsWith("/api/context/inject")));
const included = await fireEvent("before_prompt_build", { prompt: "Help me", messages: [] }, { agentId: "main" });
assert.ok(included?.appendSystemContext, "should inject context for non-excluded agent");
});
it("returns undefined when context is empty", async () => {
contextResponse = " ";
const { api, logs, fireEvent } = createMockApi({ workerPort });
claudeMemPlugin(api);
const result = await fireEvent("before_prompt_build", {
prompt: "Help me write a function",
messages: [],
}, { agentId: "main" });
assert.equal(result, undefined, "should return undefined for empty context");
assert.ok(!logs.some((l) => l.includes("Context injected")), "should not log injection for empty context");
});
it("uses custom project name in context inject URL", async () => {
const { api, fireEvent } = createMockApi({ workerPort, project: "my-bot" });
claudeMemPlugin(api);
await fireEvent("before_prompt_build", {
prompt: "Help me write a function",
messages: [],
}, { agentId: "main" });
const contextRequest = receivedRequests.find((r) => r.url?.startsWith("/api/context/inject"));
assert.ok(contextRequest, "should request context");
assert.ok(contextRequest!.url!.includes("projects=my-bot"), "should use custom project name");
});
it("includes agent-scoped project in context request", async () => {
const { api, fireEvent } = createMockApi({ workerPort });
claudeMemPlugin(api);
await fireEvent("before_prompt_build", {
prompt: "Help me",
messages: [],
}, { agentId: "debugger" });
const contextRequest = receivedRequests.find((r) => r.url?.startsWith("/api/context/inject"));
assert.ok(contextRequest, "should request context");
const url = decodeURIComponent(contextRequest!.url!);
assert.ok(url.includes("openclaw,openclaw-debugger"), "should include both base and agent-scoped projects");
});
for (const [hostVersion, registersLegacyHook] of [
[CURRENT_OPENCLAW_HOST, false],
["2026.8.1", false],
["2026.8.1-beta.1", false],
["2026.7.35", true],
[BOTH_HOOKS_OPENCLAW_HOST, true],
["2026.2.17", true],
[LEGACY_OPENCLAW_HOST, true],
] as const) {
it(`${registersLegacyHook ? "registers" : "does not register"} before_agent_start on OpenClaw ${hostVersion}`, () => {
const { api, getEventHandlers } = createMockApi({ workerPort }, hostVersion);
claudeMemPlugin(api);
assert.equal(getEventHandlers("before_agent_start").length, registersLegacyHook ? 1 : 0);
assert.equal(getEventHandlers("before_prompt_build").length, 1);
});
}
// OpenClaw 2026.2.9 passes "unknown" as its runtime version.
for (const hostVersion of ["unknown", null] as const) {
it(`keeps before_agent_start when the host version is ${hostVersion === null ? "missing" : `"${hostVersion}"`}`, () => {
const { api, logs, getEventHandlers } = createMockApi({ workerPort }, hostVersion);
claudeMemPlugin(api);
assert.equal(getEventHandlers("before_agent_start").length, 1);
assert.equal(getEventHandlers("before_prompt_build").length, 1);
assert.ok(logs.some((line) => line.includes("host version") && line.includes("unreadable")));
});
}
// Hosts with both hooks hand before_prompt_build a prompt that can include
// rebuilt history; the raw prompt comes from before_agent_start.
for (const hostVersion of [BOTH_HOOKS_OPENCLAW_HOST, "unknown"] as const) {
it(`records only before_agent_start's raw prompt on OpenClaw ${hostVersion}`, async () => {
const { api, fireEvent } = createMockApi({ workerPort }, hostVersion);
claudeMemPlugin(api);
const ctx = { sessionKey: `both-hooks-${hostVersion}`, agentId: "main" };
const injected = await fireEvent("before_prompt_build", { prompt: "[history] earlier turn\nFix the login bug", messages: [] }, ctx);
await fireEvent("before_agent_start", { prompt: "Fix the login bug", messages: [] }, ctx);
const initRequests = receivedRequests.filter((r) => r.url === "/api/sessions/init");
assert.deepEqual(initRequests.map((r) => r.body.prompt), ["Fix the login bug"]);
assert.ok(injected?.appendSystemContext, "context injection is unchanged");
});
}
it("records before_prompt_build's explicit request even when before_agent_start is registered", async () => {
const { api, fireEvent } = createMockApi({ workerPort }, BOTH_HOOKS_OPENCLAW_HOST);
claudeMemPlugin(api);
await fireEvent("before_prompt_build", {
prompt: "[history]\nFix the login bug", currentUserMessage: "Fix the login bug", currentUserMessageId: "msg-7", messages: [],
}, { sessionKey: "explicit-on-both", agentId: "main" });
const initRequests = receivedRequests.filter((r) => r.url === "/api/sessions/init");
assert.equal(initRequests.length, 1);
assert.equal(initRequests[0].body.prompt, "Fix the login bug");
assert.equal(initRequests[0].body.nativePromptId, "msg-7");
});
it("records the host's explicit request and its native ID as the session prompt", async () => {
const { api, fireEvent } = createMockApi({ workerPort });
claudeMemPlugin(api);
await fireEvent("before_prompt_build", {
prompt: "[history] earlier turn\nFix the login bug",
currentUserMessage: "Fix the login bug",
currentUserMessageId: "msg-42",
messages: [],
}, { sessionKey: "explicit-request", agentId: "main" });
const initRequests = receivedRequests.filter((r) => r.url === "/api/sessions/init");
assert.equal(initRequests.length, 1);
assert.equal(initRequests[0].body.prompt, "Fix the login bug");
assert.equal(initRequests[0].body.nativePromptId, "msg-42");
assert.equal(initRequests[0].body.platformSource, "openclaw");
});
for (const [label, event, expectedPrompt] of [
["no explicit request", { prompt: "Help me", messages: [] }, "Help me"],
["an ID the worker would refuse", { prompt: "Help me", currentUserMessage: "Help me", currentUserMessageId: "has space", messages: [] }, "Help me"],
] as const) {
it(`records the prompt without a native ID for ${label}`, async () => {
const { api, fireEvent } = createMockApi({ workerPort });
claudeMemPlugin(api);
await fireEvent("before_prompt_build", event, { sessionKey: `no-native-${label}` });
const initRequest = receivedRequests.find((r) => r.url === "/api/sessions/init");
assert.ok(initRequest);
assert.equal(initRequest.body.prompt, expectedPrompt);
assert.equal(Object.hasOwn(initRequest.body, "nativePromptId"), false);
});
}
// OpenClaw sends an explicit empty currentUserMessage for image-only input or
// a continuation without a retained request; it must not fall back to history.
for (const [label, currentUserMessage] of [["empty", ""], ["blank", " \n"]] as const) {
for (const hostVersion of [CURRENT_OPENCLAW_HOST, BOTH_HOOKS_OPENCLAW_HOST] as const) {
it(`records no prompt when the explicit request is ${label} on OpenClaw ${hostVersion}, and still injects context`, async () => {
const { api, fireEvent } = createMockApi({ workerPort }, hostVersion);
claudeMemPlugin(api);
const injected = await fireEvent("before_prompt_build", {
prompt: "[history] earlier turn", currentUserMessage, currentUserMessageId: "msg-continuation", messages: [],
}, { sessionKey: `no-text-${label}-${hostVersion}`, agentId: "main" });
assert.equal(receivedRequests.filter((r) => r.url === "/api/sessions/init").length, 0);
assert.ok(injected?.appendSystemContext, "context injection is unchanged");
});
}
}
for (const [label, config, agentId] of [
["injection is disabled", { syncMemoryFile: false }, "main"],
["the agent is excluded from injection", { syncMemoryFileExclude: ["snarf"] }, "snarf"],
] as const) {
it(`still records the prompt when ${label}`, async () => {
const { api, fireEvent } = createMockApi({ workerPort, ...config });
claudeMemPlugin(api);
const result = await fireEvent("before_prompt_build", { prompt: "Help me", messages: [] }, { sessionKey: `record-${agentId}`, agentId });
assert.equal(result, undefined);
assert.equal(receivedRequests.filter((r) => r.url === "/api/sessions/init").length, 1);
assert.ok(!receivedRequests.some((r) => r.url?.startsWith("/api/context/inject")));
});
}
});
describe("SSE stream integration", () => {
let server: Server;
let serverPort: number;
let serverResponses: ServerResponse[] = [];
let services: any[] = [];
function startSSEServer(): Promise<number> {
return new Promise((resolve) => {
server = createServer((req: IncomingMessage, res: ServerResponse) => {
if (req.url !== "/stream") {
res.writeHead(404);
res.end();
return;
}
res.writeHead(200, {
"Content-Type": "text/event-stream",
"Cache-Control": "no-cache",
Connection: "keep-alive",
});
serverResponses.push(res);
});
server.listen(0, () => {
const address = server.address();
if (address && typeof address === "object") {
resolve(address.port);
}
});
});
}
beforeEach(async () => {
serverResponses = [];
services = [];
serverPort = await startSSEServer();
});
afterEach(async () => {
for (const service of services) await service.stop({});
for (const res of serverResponses) {
try {
res.end();
} catch {}
}
server?.close();
});
it("connects to SSE stream and receives new_observation events", async () => {
const { api, logs, sentMessages, getService } = createMockApi({
workerPort: serverPort,
observationFeed: { enabled: true, channel: "telegram", to: "12345" },
});
claudeMemPlugin(api);
services.push(getService());
await getService().start({});
await waitFor(() => serverResponses.length === 1);
assert.ok(logs.some((l) => l.includes("Connecting to SSE stream")));
const observation = {
type: "new_observation",
observation: {
id: 1,
title: "Test Observation",
subtitle: "Found something interesting",
type: "discovery",
project: "test",
prompt_number: 1,
narrative: "Discovery observations should keep routine feed messages compact.",
facts: JSON.stringify(["Routine detail should not be shown"]),
concepts: JSON.stringify(["compact-feed"]),
created_at_epoch: Date.now(),
},
timestamp: Date.now(),
};
for (const res of serverResponses) {
res.write(`data: ${JSON.stringify(observation)}\n\n`);
}
await waitFor(() => sentMessages.length === 1);
assert.equal(sentMessages.length, 1);
assert.equal(sentMessages[0].channel, "telegram");
assert.equal(sentMessages[0].to, "12345");
assert.ok(sentMessages[0].text.includes("Test Observation"));
assert.ok(sentMessages[0].text.includes("Found something interesting"));
assert.ok(!sentMessages[0].text.includes("Narrative"));
assert.ok(!sentMessages[0].text.includes("Routine detail should not be shown"));
assert.ok(!sentMessages[0].text.includes("compact-feed"));
assert.ok(sentMessages[0].text.length <= 900);
});
it("keeps important feed messages more complete", async () => {
const { api, sentMessages, getService } = createMockApi({
workerPort: serverPort,
observationFeed: { enabled: true, channel: "telegram", to: "12345" },
});
claudeMemPlugin(api);
services.push(getService());
await getService().start({});
await waitFor(() => serverResponses.length === 1);
for (const res of serverResponses) {
res.write(
`data: ${JSON.stringify({
type: "new_observation",
observation: {
id: 2,
title: "Important Bugfix",
subtitle: "Fixed a regression",
type: "bugfix",
project: "test",
prompt_number: 1,
narrative: "This fuller context should stay visible for important feed messages.",
facts: JSON.stringify([
"Important fact one is preserved",
"Important fact two is preserved",
"Important fact three is preserved",
]),
concepts: JSON.stringify(["important-feed"]),
created_at_epoch: Date.now(),
},
timestamp: Date.now(),
})}\n\n`
);
}
await waitFor(() => sentMessages.length === 1);
assert.equal(sentMessages.length, 1);
assert.ok(sentMessages[0].text.includes("Narrative"));
assert.ok(sentMessages[0].text.includes("This fuller context should stay visible"));
assert.ok(sentMessages[0].text.includes("Important fact three is preserved"));
assert.ok(sentMessages[0].text.includes("Concepts: important-feed"));
assert.ok(sentMessages[0].text.length <= 2200);
});
it("filters out non-observation events", async () => {
const { api, sentMessages, getService } = createMockApi({
workerPort: serverPort,
observationFeed: { enabled: true, channel: "discord", to: "channel-id" },
});
claudeMemPlugin(api);
services.push(getService());
await getService().start({});
await waitFor(() => serverResponses.length === 1);
for (const res of serverResponses) {
res.write(`data: ${JSON.stringify({ type: "processing_status", isProcessing: true })}\n\n`);
res.write(`data: ${JSON.stringify({ type: "session_started", sessionId: "abc" })}\n\n`);
res.write(`data: ${JSON.stringify({ type: "new_observation", observation: { id: 99, title: "Sentinel" } })}\n\n`);
}
await waitFor(() => sentMessages.length === 1);
assert.equal(sentMessages.length, 1, "only the sentinel observation should be delivered");
assert.ok(sentMessages[0].text.includes("Sentinel"));
});
it("handles observations with null titles and subtitles", async () => {
const { api, sentMessages, getService } = createMockApi({
workerPort: serverPort,
observationFeed: { enabled: true, channel: "telegram", to: "999" },
});
claudeMemPlugin(api);
services.push(getService());
await getService().start({});
await waitFor(() => serverResponses.length === 1);
for (const observation of [
{ id: 2, title: "No Subtitle", subtitle: null },
{ id: 3, title: null, subtitle: "Has subtitle" },
]) {
serverResponses[0].write(`data: ${JSON.stringify({ type: "new_observation", observation, timestamp: Date.now() })}\n\n`);
}
await waitFor(() => sentMessages.length === 2);
assert.equal(sentMessages.length, 2);
assert.ok(sentMessages[0].text.includes("No Subtitle"));
assert.ok(!sentMessages[0].text.includes("null"));
assert.ok(sentMessages[1].text.includes("Untitled"));
});
it("logs unknown channel type", async () => {
const { api, logs, sentMessages, getService } = createMockApi({
workerPort: serverPort,
observationFeed: { enabled: true, channel: "matrix", to: "room-id" },
});
claudeMemPlugin(api);
services.push(getService());
await getService().start({});
await waitFor(() => serverResponses.length === 1);
for (const res of serverResponses) {
res.write(
`data: ${JSON.stringify({
type: "new_observation",
observation: { id: 4, title: "Test", subtitle: null },
timestamp: Date.now(),
})}\n\n`
);
}
await waitFor(() => logs.some((line) => line.includes("Unsupported channel type: matrix")));
assert.equal(sentMessages.length, 0);
assert.ok(logs.some((l) => l.includes("Unsupported channel type: matrix")));
});
});
describe("circuit breaker", () => {
beforeEach(async () => {
const { api, fireEvent } = createMockApi({ workerPort: await unusedPort() });
claudeMemPlugin(api);
await fireEvent("gateway_start", {}, {});
});
it("counts requests through open, reset and half-open states", async () => {
let hits = 0;
let status = 500;
let hold = false;
const held: ServerResponse[] = [];
const server = createServer((_req, res) => {
hits++;
if (hold) held.push(res);
else {
res.writeHead(status, { "Content-Type": "application/json" });
res.end("{}");
}
});
await new Promise<void>((resolve) => server.listen(0, "127.0.0.1", resolve));
const { api, fireEvent } = createMockApi({ workerPort: (server.address() as { port: number }).port }, LEGACY_OPENCLAW_HOST);
claudeMemPlugin(api);
const realDateNow = Date.now;
let now = realDateNow();
Date.now = () => now;
const pending: Promise<unknown>[] = [];
let call = 0;
const send = () => fireEvent("before_agent_start", { prompt: "probe" }, { sessionKey: `breaker-${call++}` });
try {
for (let i = 0; i < 3; i++) await send();
assert.equal(hits, 3);
await send();
assert.equal(hits, 3, "open circuit must suppress network requests");
await fireEvent("gateway_start", {}, {});
for (let i = 0; i < 3; i++) await send();
assert.equal(hits, 6, "gateway_start must admit requests again");
now += 31_000;
hold = true;
const probe = send();
pending.push(probe);
await waitFor(() => hits === 7);
let suppressedFinished = false;
const suppressed = send().then(() => { suppressedFinished = true; });
pending.push(suppressed);
await waitFor(() => suppressedFinished);
assert.equal(hits, 7, "half-open state must admit only the in-flight probe");
held.shift()!.writeHead(500).end("{}");
await probe;
await send();
assert.equal(hits, 7, "failed probe must reopen the circuit");
hold = false;
status = 200;
now += 31_000;
await send();
assert.equal(hits, 8, "cooldown must admit a new probe");
await send();
assert.equal(hits, 9, "successful probe must close the circuit");
} finally {
Date.now = realDateNow;
server.closeAllConnections();
await new Promise<void>((resolve) => server.close(() => resolve()));
await Promise.allSettled(pending);
}
});
it("logs individual failures while circuit is closed, then disabling when it opens", async () => {
const { api, logs, fireEvent } = createMockApi({ workerPort: await unusedPort() }, LEGACY_OPENCLAW_HOST);
claudeMemPlugin(api);
await fireEvent("gateway_start", {}, {});
const logsAfterReset = logs.length;
for (let i = 0; i < 3; i++) {
await fireEvent("before_agent_start", { prompt: "hello" }, { sessionKey: `cb-log-${i}` });
}
const newLogs = logs.slice(logsAfterReset);
assert.ok(newLogs.length > 0, "threshold calls should produce log output");
const disablingLogs = newLogs.filter((l) => l.includes("disabling requests"));
assert.equal(disablingLogs.length, 1, "should emit exactly one disabling warning when circuit opens");
const failureLogs = newLogs.filter((l) => l.includes("failed:"));
assert.ok(failureLogs.length < 3, "threshold-crossing call should not log an individual failure");
});
});