@agentmemory/agentmemory 0.9.28 → 0.9.30

package/dist/standalone.mjs

@@ -1,4 +1,5 @@
 #!/usr/bin/env node
+import { createRequire } from "node:module";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
 import { homedir } from "node:os";
@@ -47,6 +48,13 @@ var InMemoryKV = class {
 };
 //#endregion
 //#region src/mcp/transport.ts
+var JsonRpcError = class extends Error {
+	constructor(code, message) {
+		super(message);
+		this.code = code;
+		this.name = "JsonRpcError";
+	}
+};
 function isNotification(req) {
 	return req.id === void 0 || req.id === null;
 }
@@ -112,7 +120,7 @@ async function processLine(line, handler, writeOut, writeErr = (msg) => process.
 			jsonrpc: "2.0",
 			id: request.id,
 			error: {
-				code: -32603,
+				code: err instanceof JsonRpcError ? err.code : -32603,
 				message: err instanceof Error ? err.message : String(err)
 			}
 		});
@@ -283,6 +291,10 @@ const CORE_TOOLS = [
 				project: {
 					type: "string",
 					description: "Stable canonical project identifier this memory belongs to (e.g. a slug, UUID, or registry key). Must match the value used when the session was started. Do not use filesystem paths or ad-hoc display names — those change across machines and will silently break project scoping."
+				},
+				agentId: {
+					type: "string",
+					description: "Agent identity to scope this memory to. When set, agent-scoped recall and search only surface it for the same agentId. Omit for shared memory."
 				}
 			},
 			required: ["content"]
@@ -311,10 +323,16 @@ const CORE_TOOLS = [
 		description: "Detect recurring patterns across sessions.",
 		inputSchema: {
 			type: "object",
-			properties: { project: {
-				type: "string",
-				description: "Project path to analyze"
-			} }
+			properties: {
+				project: {
+					type: "string",
+					description: "Project path to analyze"
+				},
+				limit: {
+					type: "integer",
+					description: "Most recent sessions to scan (default 50, max 500)"
+				}
+			}
 		}
 	},
 	{
@@ -1141,6 +1159,18 @@ const V070_TOOLS = [
 			required: ["query"]
 		}
 	},
+	{
+		name: "memory_lesson_delete",
+		description: "Soft-delete a lesson by id. Deleted lessons are excluded from recall and list; re-saving the same content creates a fresh lesson.",
+		inputSchema: {
+			type: "object",
+			properties: { lessonId: {
+				type: "string",
+				description: "The lesson id (lsn_...)"
+			} },
+			required: ["lessonId"]
+		}
+	},
 	{
 		name: "memory_obsidian_export",
 		description: "Export memories, lessons, and crystals as Obsidian-compatible Markdown files with YAML frontmatter and wikilinks for graph view.",
@@ -1313,8 +1343,13 @@ function getAllTools() {
 	];
 }
 const ENV_FILE = join(join(homedir(), ".agentmemory"), ".env");
+let envFileCache;
 function loadEnvFile() {
-	if (!existsSync(ENV_FILE)) return {};
+	if (envFileCache) return envFileCache;
+	if (!existsSync(ENV_FILE)) {
+		envFileCache = {};
+		return envFileCache;
+	}
 	const content = readFileSync(ENV_FILE, "utf-8");
 	const vars = {};
 	for (const line of content.split("\n")) {
@@ -1334,7 +1369,8 @@ function loadEnvFile() {
 		}
 		vars[key] = val;
 	}
-	return vars;
+	envFileCache = vars;
+	return envFileCache;
 }
 function getMergedEnv(overrides) {
 	return {
@@ -1348,12 +1384,215 @@ function getStandalonePersistPath() {
 }
 //#endregion
 //#region src/version.ts
-const VERSION = "0.9.28";
+const VERSION = "0.9.30";
+createRequire(import.meta.url);
 //#endregion
 //#region src/state/schema.ts
+const KV = {
+	sessions: "mem:sessions",
+	observations: (sessionId) => `mem:obs:${sessionId}`,
+	memories: "mem:memories",
+	summaries: "mem:summaries",
+	config: "mem:config",
+	metrics: "mem:metrics",
+	health: "mem:health",
+	embeddings: (obsId) => `mem:emb:${obsId}`,
+	bm25Index: "mem:index:bm25",
+	vectorPendingLog: "mem:index:vec-pending",
+	relations: "mem:relations",
+	profiles: "mem:profiles",
+	claudeBridge: "mem:claude-bridge",
+	graphNodes: "mem:graph:nodes",
+	graphEdges: "mem:graph:edges",
+	graphSnapshot: "mem:graph:snapshot",
+	graphNameIndex: "mem:graph:name-index",
+	graphEdgeKey: "mem:graph:edge-key",
+	graphNodeDegree: "mem:graph:node-degree",
+	semantic: "mem:semantic",
+	procedural: "mem:procedural",
+	teamShared: (teamId) => `mem:team:${teamId}:shared`,
+	teamUsers: (teamId, userId) => `mem:team:${teamId}:users:${userId}`,
+	teamProfile: (teamId) => `mem:team:${teamId}:profile`,
+	audit: "mem:audit",
+	auditMonth: (month) => `mem:audit:${month}`,
+	auditMonths: "mem:audit:months",
+	actions: "mem:actions",
+	actionEdges: "mem:action-edges",
+	leases: "mem:leases",
+	routines: "mem:routines",
+	routineRuns: "mem:routine-runs",
+	signals: "mem:signals",
+	checkpoints: "mem:checkpoints",
+	mesh: "mem:mesh",
+	sketches: "mem:sketches",
+	facets: "mem:facets",
+	sentinels: "mem:sentinels",
+	crystals: "mem:crystals",
+	lessons: "mem:lessons",
+	insights: "mem:insights",
+	graphEdgeHistory: "mem:graph:edge-history",
+	enrichedChunks: (sessionId) => `mem:enriched:${sessionId}`,
+	latentEmbeddings: (obsId) => `mem:latent:${obsId}`,
+	retentionScores: "mem:retention",
+	accessLog: "mem:access",
+	imageRefs: "mem:image-refs",
+	imageEmbeddings: "mem:image-embeddings",
+	slots: "mem:slots",
+	globalSlots: "mem:slots:global",
+	state: "mem:state",
+	commits: "mem:commits",
+	recentSearches: "mem:recent-searches",
+	projectSessionsIndex: "mem:idx:project-sessions",
+	obsSessionIndex: (shard) => `mem:idx:obs:${shard}`,
+	captureInbox: "mem:capture:inbox",
+	captureEvents: (shard) => `mem:capture:events:${shard}`,
+	capturePrompts: "mem:capture:prompts"
+};
 function generateId(prefix) {
 	return `${prefix}_${Date.now().toString(36)}_${crypto.randomUUID().replace(/-/g, "").slice(0, 12)}`;
 }
+process.env["AGENTMEMORY_VERBOSE"] === "1" || process.env["AGENTMEMORY_VERBOSE"];
+KV.auditMonths;
+const AUDIT_MIGRATION_STATE_KEY = "migration";
+async function readAuditMigrationState(kv) {
+	return kv.get(KV.auditMonths, AUDIT_MIGRATION_STATE_KEY);
+}
+function monthStartMs(month) {
+	const [year, mon] = month.split("-").map(Number);
+	return Date.UTC(year, mon - 1, 1);
+}
+function monthEndMs(month) {
+	const [year, mon] = month.split("-").map(Number);
+	return Date.UTC(year, mon, 1) - 1;
+}
+async function readAuditMonthIndex(kv) {
+	return (await kv.get(KV.auditMonths, "index"))?.months ?? [];
+}
+async function listAuditMonthsDesc(kv) {
+	return [...await readAuditMonthIndex(kv)].sort().reverse();
+}
+async function queryAudit(kv, filter) {
+	const limit = filter?.limit || 100;
+	let fromMs;
+	if (filter?.dateFrom) {
+		fromMs = new Date(filter.dateFrom).getTime();
+		if (Number.isNaN(fromMs)) throw new Error(`Invalid dateFrom: ${filter.dateFrom}`);
+	}
+	const query = filter?.query?.trim().toLowerCase();
+	let toMs;
+	if (filter?.dateTo) {
+		toMs = new Date(filter.dateTo).getTime();
+		if (Number.isNaN(toMs)) throw new Error(`Invalid dateTo: ${filter.dateTo}`);
+	}
+	const matches = (entry) => {
+		if (filter?.operation && entry.operation !== filter.operation) return false;
+		const t = new Date(entry.timestamp).getTime();
+		if (fromMs !== void 0 && t < fromMs) return false;
+		if (toMs !== void 0 && t > toMs) return false;
+		if (query && ![entry.functionId, ...entry.targetIds || []].some((v) => String(v || "").toLowerCase().includes(query))) return false;
+		return true;
+	};
+	const seenIds = /* @__PURE__ */ new Set();
+	const collected = [];
+	const addIfNew = (row) => {
+		if (seenIds.has(row.id)) return;
+		seenIds.add(row.id);
+		if (matches(row)) collected.push(row);
+	};
+	const months = await listAuditMonthsDesc(kv);
+	for (const month of months) {
+		if (collected.length >= limit) break;
+		if (toMs !== void 0 && monthStartMs(month) > toMs) continue;
+		if (fromMs !== void 0 && monthEndMs(month) < fromMs) break;
+		const rows = await kv.list(KV.auditMonth(month));
+		for (const row of rows) addIfNew(row);
+	}
+	let legacyFrozen = false;
+	let legacyFrozenBytes;
+	if (collected.length < limit) {
+		const migrationState = await readAuditMigrationState(kv);
+		if (migrationState?.safeToListLegacy) {
+			const legacyRows = await kv.list(KV.audit);
+			for (const row of legacyRows) addIfNew(row);
+		} else if (migrationState?.status === "too-large" || migrationState?.status === "unreadable") {
+			legacyFrozen = true;
+			legacyFrozenBytes = migrationState.legacySizeBytes;
+		}
+	}
+	collected.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+	return {
+		entries: collected.slice(0, limit),
+		legacyFrozen,
+		legacyFrozenBytes
+	};
+}
+//#endregion
+//#region src/secret-store.ts
+const SECRET_KEY = "AGENTMEMORY_SECRET";
+function agentmemoryHomeDir() {
+	return join(homedir(), ".agentmemory");
+}
+function secretFilePath() {
+	return join(agentmemoryHomeDir(), "secret");
+}
+function usable(value) {
+	if (typeof value !== "string") return "";
+	const trimmed = value.trim();
+	if (!trimmed) return "";
+	if (trimmed.startsWith("${") && trimmed.endsWith("}")) return "";
+	return trimmed;
+}
+function unquote(value) {
+	const quote = value[0];
+	if ((quote === "\"" || quote === "'") && value.length > 1) {
+		const close = value.indexOf(quote, 1);
+		if (close !== -1) return value.slice(1, close);
+	}
+	const hash = value.indexOf(" #");
+	return hash === -1 ? value : value.slice(0, hash).trim();
+}
+function readEnvFileSecret() {
+	let content;
+	try {
+		content = readFileSync(join(agentmemoryHomeDir(), ".env"), "utf-8");
+	} catch {
+		return "";
+	}
+	if (typeof content !== "string") return "";
+	let found = "";
+	for (const line of content.split("\n")) {
+		const trimmed = line.trim();
+		if (trimmed.startsWith("#")) continue;
+		const eq = trimmed.indexOf("=");
+		if (eq === -1) continue;
+		if (trimmed.slice(0, eq).replace(/^export\s+/, "").trim() !== SECRET_KEY) continue;
+		found = usable(unquote(trimmed.slice(eq + 1).trim()));
+	}
+	return found;
+}
+function readStoredSecret() {
+	try {
+		return usable(readFileSync(secretFilePath(), "utf-8"));
+	} catch {
+		return "";
+	}
+}
+function isLoopbackUrl(url) {
+	let hostname;
+	try {
+		hostname = new URL(url).hostname.toLowerCase();
+	} catch {
+		return false;
+	}
+	const bare = hostname.replace(/^\[|\]$/g, "");
+	return bare === "localhost" || bare === "::1" || /^127(?:\.\d{1,3}){3}$/.test(bare);
+}
+function resolveClientSecret(baseUrl, env = process.env) {
+	const fromEnv = usable(env[SECRET_KEY]);
+	if (fromEnv) return fromEnv;
+	if (!isLoopbackUrl(baseUrl)) return "";
+	return readEnvFileSecret() || readStoredSecret();
+}
 //#endregion
 //#region src/mcp/rest-proxy.ts
 const DEFAULT_URL = "http://localhost:3111";
@@ -1370,6 +1609,16 @@ function forceProxy() {
 	const raw = process.env["AGENTMEMORY_FORCE_PROXY"];
 	return raw === "1" || raw === "true";
 }
+var ProxyCallError = class extends Error {
+	status;
+	body;
+	constructor(message, status, body) {
+		super(message);
+		this.name = "ProxyCallError";
+		this.status = status;
+		this.body = body;
+	}
+};
 let cached = null;
 let cachedAt = 0;
 let probeInFlight = null;
@@ -1383,7 +1632,7 @@ function baseUrl() {
 	return (resolveEnvOrEmpty("AGENTMEMORY_URL") || DEFAULT_URL).replace(/\/+$/, "");
 }
 function authHeader() {
-	const secret = resolveEnvOrEmpty("AGENTMEMORY_SECRET");
+	const secret = resolveClientSecret(baseUrl());
 	return secret ? { authorization: `Bearer ${secret}` } : {};
 }
 const defaultLivezProbe = async (url, timeoutMs, headers) => {
@@ -1440,7 +1689,16 @@ async function resolveHandle() {
 						},
 						signal: AbortSignal.timeout(CALL_TIMEOUT_MS)
 					});
-					if (!res.ok) throw new Error(`${init?.method || "GET"} ${path} -> ${res.status} ${res.statusText}`);
+					if (!res.ok) {
+						const errText = await res.text().catch(() => "");
+						let errBody = void 0;
+						if (errText) try {
+							errBody = JSON.parse(errText);
+						} catch {
+							errBody = void 0;
+						}
+						throw new ProxyCallError(`${init?.method || "GET"} ${path} -> ${res.status} ${res.statusText}`, res.status, errBody);
+					}
 					const text = await res.text();
 					return text ? JSON.parse(text) : null;
 				}
@@ -1471,10 +1729,15 @@ const IMPLEMENTED_TOOLS = new Set([
 	"memory_audit",
 	"memory_governance_delete"
 ]);
+const SUPPORTED_PROTOCOL_VERSIONS = [
+	"2025-11-25",
+	"2025-06-18",
+	"2025-03-26",
+	"2024-11-05"
+];
 const SERVER_INFO = {
 	name: "agentmemory",
-	version: VERSION,
-	protocolVersion: "2024-11-05"
+	version: VERSION
 };
 const kv = new InMemoryKV(getStandalonePersistPath());
 let modeAnnounced = false;
@@ -1523,6 +1786,8 @@ function validate(toolName, args) {
 			v.type = args["type"] || "fact";
 			v.concepts = normalizeList(args["concepts"]);
 			v.files = normalizeList(args["files"]);
+			if (typeof args["project"] === "string" && args["project"].trim()) v.project = args["project"].trim();
+			if (typeof args["agentId"] === "string" && args["agentId"].trim()) v.agentId = args["agentId"].trim();
 			return v;
 		}
 		case "memory_recall":
@@ -1566,7 +1831,9 @@ async function handleProxy(v, handle) {
 				content: v.content,
 				type: v.type,
 				concepts: v.concepts,
-				files: v.files
+				files: v.files,
+				...v.project !== void 0 && { project: v.project },
+				...v.agentId !== void 0 && { agentId: v.agentId }
 			})
 		}));
 		case "memory_recall": {
@@ -1601,7 +1868,12 @@ async function handleProxy(v, handle) {
 				reason: v.reason
 			})
 		}));
-		case "memory_export": return textResponse(await handle.call("/agentmemory/export", { method: "GET" }), true);
+		case "memory_export": try {
+			return textResponse(await handle.call("/agentmemory/export", { method: "GET" }), true);
+		} catch (err) {
+			if (err instanceof ProxyCallError && err.body != null && typeof err.body === "object" && err.body.oversized === true) return textResponse(err.body, true);
+			throw err;
+		}
 		case "memory_audit": return textResponse(await handle.call(`/agentmemory/audit?limit=${v.limit}`, { method: "GET" }), true);
 		default: throw new Error(`Unknown tool: ${v.tool}`);
 	}
@@ -1670,11 +1942,7 @@ async function handleLocal(v, kvInstance) {
 			memories: await kvInstance.list("mem:memories"),
 			sessions: await kvInstance.list("mem:sessions")
 		}, true);
-		case "memory_audit": {
-			const entries = await kvInstance.list("mem:audit");
-			const limit = v.limit ?? 50;
-			return textResponse({ entries: entries.slice(0, limit) }, true);
-		}
+		case "memory_audit": return textResponse(await queryAudit(kvInstance, { limit: v.limit ?? 50 }), true);
 		default: throw new Error(`Unknown tool: ${v.tool}`);
 	}
 }
@@ -1737,14 +2005,17 @@ async function handleToolsList() {
 }
 const transport = createStdioTransport(async (method, params) => {
 	switch (method) {
-		case "initialize": return {
-			protocolVersion: SERVER_INFO.protocolVersion,
-			capabilities: { tools: { listChanged: false } },
-			serverInfo: {
-				name: SERVER_INFO.name,
-				version: SERVER_INFO.version
-			}
-		};
+		case "initialize": {
+			const requested = params?.protocolVersion;
+			return {
+				protocolVersion: typeof requested === "string" && SUPPORTED_PROTOCOL_VERSIONS.includes(requested) ? requested : SUPPORTED_PROTOCOL_VERSIONS[0],
+				capabilities: { tools: { listChanged: false } },
+				serverInfo: {
+					name: SERVER_INFO.name,
+					version: SERVER_INFO.version
+				}
+			};
+		}
 		case "notifications/initialized": return {};
 		case "tools/list": return handleToolsList();
 		case "tools/call": {