@agentmemory/agentmemory 0.9.31 → 0.9.32

package/dist/standalone.mjs

@@ -1,8 +1,8 @@
 #!/usr/bin/env node
 import { createRequire } from "node:module";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { chmodSync, closeSync, existsSync, fchmodSync, mkdirSync, openSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, writeSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { homedir } from "node:os";
+import { homedir, tmpdir } from "node:os";
 import "picocolors";
 import { AsyncLocalStorage } from "node:async_hooks";
 //#region src/mcp/in-memory-kv.ts
@@ -41,7 +41,19 @@ var InMemoryKV = class {
 			if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
 			const data = {};
 			for (const [scope, entries] of this.store) data[scope] = Object.fromEntries(entries);
-			writeFileSync(this.persistPath, JSON.stringify(data), "utf-8");
+			const tmpPath = `${this.persistPath}.${process.pid}.tmp`;
+			try {
+				writeFileSync(tmpPath, JSON.stringify(data), {
+					encoding: "utf-8",
+					mode: 384
+				});
+				renameSync(tmpPath, this.persistPath);
+			} catch (err) {
+				try {
+					rmSync(tmpPath, { force: true });
+				} catch {}
+				throw err;
+			}
 			return true;
 		} catch (err) {
 			process.stderr.write(`[@agentmemory/mcp] Persist failed: ${err instanceof Error ? err.message : String(err)}\n`);
@@ -240,7 +252,190 @@ function createStdioTransport(handler) {
 	};
 }
 //#endregion
+//#region src/cli/engine-launch.ts
+const CREDENTIAL_URL_PATTERN = /:\/\/[^@\s/]*@/g;
+function redactCredentialUrls(text) {
+	return text.replace(CREDENTIAL_URL_PATTERN, "://***@");
+}
+const MAX_CRASH_LINE_BYTES = 64 * 1024;
+function writeStderr(text) {
+	process.stderr.write(text);
+}
+function stderrWriteMayBlock(platform = process.platform, isTTY = process.stderr.isTTY) {
+	return platform === "win32" && !isTTY;
+}
+function mcpCrashLogPath(env = process.env) {
+	return join(env["AGENTMEMORY_DATA_DIR"] || join(homedir(), ".agentmemory"), "mcp-crash.log");
+}
+function formatFatal(kind, reason, now = /* @__PURE__ */ new Date()) {
+	const detail = reason instanceof Error ? reason.stack || reason.message : String(reason);
+	return redactCredentialUrls(`[${now.toISOString()}] pid=${process.pid} ${kind}: ${detail}\n`);
+}
+function safeFormat(kind, reason) {
+	try {
+		return formatFatal(kind, reason);
+	} catch {
+		return `[${(/* @__PURE__ */ new Date()).toISOString()}] pid=${process.pid} ${kind}: (the error could not be formatted)\n`;
+	}
+}
+function describe(err) {
+	return err instanceof Error ? err.message : String(err);
+}
+function rotateCrashLog(logPath, notices) {
+	const rotated = `${logPath}.1`;
+	try {
+		renameSync(logPath, rotated);
+	} catch (err) {
+		if (err.code === "ENOENT") return;
+		throw err;
+	}
+	try {
+		chmodSync(rotated, 384);
+	} catch (err) {
+		notices.push(`[@agentmemory/mcp] rotated crash log ${rotated} could not be made owner-only: ${describe(err)}\n`);
+	}
+}
+function boundCrashLine(line, maxBytes = MAX_CRASH_LINE_BYTES) {
+	const bytes = Buffer.from(line, "utf8");
+	if (bytes.length <= maxBytes) return line;
+	const marker = " ...(truncated)\n";
+	const markerBytes = Buffer.byteLength(marker);
+	if (maxBytes <= markerBytes) return bytes.subarray(0, Math.max(0, maxBytes)).toString("utf8").replace(/�+$/, "");
+	return `${bytes.subarray(0, maxBytes - markerBytes).toString("utf8").replace(/�+$/, "")}${marker}`;
+}
+function writeAll(fd, data, write = writeSync) {
+	let offset = 0;
+	while (offset < data.length) {
+		const n = write(fd, data, offset, data.length - offset);
+		if (!(n > 0)) throw new Error(`crash log write stopped after ${offset} of ${data.length} bytes`);
+		offset += n;
+	}
+}
+function writeCrashLog(line, logPath = mcpCrashLogPath()) {
+	const notices = [];
+	const bounded = boundCrashLine(line);
+	let fd;
+	try {
+		mkdirSync(dirname(logPath), {
+			recursive: true,
+			mode: 448
+		});
+		if (existsSync(logPath) && statSync(logPath).size + Buffer.byteLength(bounded) > 1048576) rotateCrashLog(logPath, notices);
+		fd = openSync(logPath, "a", 384);
+		try {
+			fchmodSync(fd, 384);
+		} catch (err) {
+			notices.push(`[@agentmemory/mcp] crash log ${logPath} could not be made owner-only, so it was not written: ${describe(err)}\n`);
+			return {
+				written: false,
+				notices
+			};
+		}
+		writeAll(fd, Buffer.from(bounded, "utf8"));
+		notices.push(`[@agentmemory/mcp] crash log: ${logPath}\n`);
+		return {
+			written: true,
+			notices
+		};
+	} catch (err) {
+		notices.push(`[@agentmemory/mcp] crash log not written to ${logPath}: ${describe(err)}\n`);
+		return {
+			written: false,
+			notices
+		};
+	} finally {
+		if (fd !== void 0) try {
+			closeSync(fd);
+		} catch {}
+	}
+}
+function fallbackCrashLogPath() {
+	return join(tmpdir(), "agentmemory-mcp-crash.log");
+}
+function handleFatal(kind, reason, hooks) {
+	const line = safeFormat(kind, reason);
+	const stderrMayBlock = hooks.stderrMayBlock ?? stderrWriteMayBlock();
+	let result = {
+		written: false,
+		notices: []
+	};
+	try {
+		result = writeCrashLog(line, hooks.logPath ?? mcpCrashLogPath());
+	} catch {}
+	const notices = result.notices;
+	if (!result.written && stderrMayBlock) try {
+		writeCrashLog(line + notices.join(""), hooks.fallbackLogPath ?? fallbackCrashLogPath());
+	} catch {}
+	try {
+		hooks.persist();
+	} catch {}
+	if (!stderrMayBlock) {
+		const write = hooks.write ?? writeStderr;
+		for (const text of [`[@agentmemory/mcp] fatal ${line}`, ...notices]) try {
+			write(text);
+		} catch {}
+	}
+	(hooks.exit ?? ((code) => process.exit(code)))(1);
+}
+function installCrashHandlers(hooks) {
+	process.on("uncaughtException", (err) => handleFatal("uncaughtException", err, hooks));
+	process.on("unhandledRejection", (reason) => handleFatal("unhandledRejection", reason, hooks));
+}
+//#endregion
 //#region src/mcp/tools-registry.ts
+const READ_ONLY_TOOLS = new Set([
+	"memory_recall",
+	"memory_file_history",
+	"memory_patterns",
+	"memory_sessions",
+	"memory_smart_search",
+	"memory_vision_search",
+	"memory_timeline",
+	"memory_export",
+	"memory_relations",
+	"memory_commit_lookup",
+	"memory_commits",
+	"memory_graph_query",
+	"memory_team_feed",
+	"memory_audit",
+	"memory_frontier",
+	"memory_next",
+	"memory_diagnose",
+	"memory_facet_query",
+	"memory_verify",
+	"memory_lesson_recall",
+	"memory_insight_list",
+	"memory_slot_list",
+	"memory_slot_get"
+]);
+const DESTRUCTIVE_TOOLS = new Set([
+	"memory_action_update",
+	"memory_compress_file",
+	"memory_claude_bridge_sync",
+	"memory_governance_delete",
+	"memory_heal",
+	"memory_lesson_delete",
+	"memory_obsidian_export",
+	"memory_slot_replace",
+	"memory_slot_delete"
+]);
+const IDEMPOTENT_WRITE_TOOLS = new Set([
+	"memory_governance_delete",
+	"memory_lesson_delete",
+	"memory_slot_replace",
+	"memory_slot_delete",
+	"memory_claude_bridge_sync"
+]);
+const OPEN_WORLD_TOOLS = new Set(["memory_mesh_sync"]);
+function toolAnnotations(name) {
+	const readOnly = READ_ONLY_TOOLS.has(name);
+	return {
+		readOnlyHint: readOnly,
+		destructiveHint: !readOnly && DESTRUCTIVE_TOOLS.has(name),
+		idempotentHint: readOnly || IDEMPOTENT_WRITE_TOOLS.has(name),
+		openWorldHint: OPEN_WORLD_TOOLS.has(name)
+	};
+}
 const CORE_TOOLS = [
 	{
 		name: "memory_recall",
@@ -1221,6 +1416,11 @@ const V070_TOOLS = [
 				tags: {
 					type: "string",
 					description: "Comma-separated tags"
+				},
+				sourceIds: {
+					type: "array",
+					items: { type: "string" },
+					description: "Ids of the session, memory, observation or crystal this lesson came from (max 50)"
 				}
 			},
 			required: ["content"]
@@ -1433,7 +1633,10 @@ function getAllTools() {
 		...V070_TOOLS,
 		...V073_TOOLS,
 		...V010_SLOTS_TOOLS
-	];
+	].map((tool) => ({
+		...tool,
+		annotations: toolAnnotations(tool.name)
+	}));
 }
 process.env["AGENTMEMORY_DATA_DIR"] || join(homedir(), ".agentmemory");
 const ENV_FILE = process.env["AGENTMEMORY_ENV_FILE"] || join(homedir(), ".agentmemory", ".env");
@@ -1508,6 +1711,7 @@ function memoryToObservation(memory) {
 		sessionId: memory.sessionIds?.[0] ?? "memory",
 		timestamp: memory.createdAt,
 		type: "decision",
+		memoryType: memory.type,
 		title: memory.title,
 		facts: [memory.content],
 		narrative: memory.content,
@@ -1545,6 +1749,7 @@ function formatResult(result, format) {
 		sessionId: result.sessionId,
 		title: observation.title,
 		type: observation.type,
+		...observation.memoryType !== void 0 && { memoryType: observation.memoryType },
 		score: result.score,
 		timestamp: observation.timestamp,
 		...result.layer !== void 0 && { layer: result.layer }
@@ -1565,6 +1770,7 @@ function clipResult(result, format, budget) {
 			sessionId: result.sessionId,
 			title: "",
 			type: observation.type,
+			...observation.memoryType !== void 0 && { memoryType: observation.memoryType },
 			score: result.score,
 			timestamp: observation.timestamp,
 			...layer,
@@ -1586,6 +1792,7 @@ function clipResult(result, format, budget) {
 			sessionId: result.sessionId,
 			title,
 			narrative,
+			...observation.memoryType !== void 0 && { memoryType: observation.memoryType },
 			score: result.score,
 			timestamp: observation.timestamp,
 			...layer,
@@ -1597,6 +1804,7 @@ function clipResult(result, format, budget) {
 				sessionId: observation.sessionId,
 				timestamp: observation.timestamp,
 				type: observation.type,
+				...observation.memoryType !== void 0 && { memoryType: observation.memoryType },
 				title,
 				facts: [],
 				narrative,
@@ -1766,7 +1974,7 @@ function parseSessionArguments(args) {
 }
 //#endregion
 //#region src/version.ts
-const VERSION = "0.9.31";
+const VERSION = "0.9.32";
 createRequire(import.meta.url);
 //#endregion
 //#region src/state/schema.ts
@@ -2004,6 +2212,28 @@ function canonicalSecretPath() {
 	return join(homedir(), ".agentmemory", "secret");
 }
 //#endregion
+//#region src/hooks/_endpoint.ts
+const OPTION_PREFIX = "CLAUDE_PLUGIN_OPTION_";
+function filled(value) {
+	const trimmed = value?.trim();
+	if (!trimmed || trimmed.startsWith("${") && trimmed.endsWith("}")) return void 0;
+	return value;
+}
+function hookSetting(name, env = process.env) {
+	const optionKey = `${OPTION_PREFIX}${name}`;
+	const option = filled(env[optionKey])?.trim();
+	if (option) return option;
+	if (name === "AGENTMEMORY_SECRET" && optionKey in env) return void 0;
+	return filled(env[name]);
+}
+function resolveSettingSecret(url, env = process.env) {
+	const secretEnv = { ...env };
+	const explicit = hookSetting("AGENTMEMORY_SECRET", env);
+	if (explicit === void 0) delete secretEnv["AGENTMEMORY_SECRET"];
+	else secretEnv["AGENTMEMORY_SECRET"] = explicit;
+	return resolveClientSecret(url, secretEnv);
+}
+//#endregion
 //#region src/mcp/rest-proxy.ts
 const DEFAULT_URL = "http://localhost:3111";
 const DEFAULT_HEALTH_PROBE_TIMEOUT_MS = 2e3;
@@ -2034,10 +2264,7 @@ let cachedUrl = null;
 let cachedAt = 0;
 let probeInFlight = null;
 function resolveEnvOrEmpty(name) {
-	const raw = process.env[name];
-	if (!raw) return "";
-	if (raw.startsWith("${") && raw.endsWith("}")) return "";
-	return raw;
+	return hookSetting(name) ?? "";
 }
 function baseUrl() {
 	const value = resolveEnvOrEmpty("AGENTMEMORY_URL") || DEFAULT_URL;
@@ -2050,7 +2277,7 @@ function baseUrl() {
 	}
 }
 function authHeader(url) {
-	const secret = resolveClientSecret(url);
+	const secret = resolveSettingSecret(url);
 	return secret ? { authorization: `Bearer ${secret}` } : {};
 }
 const defaultLivezProbe = async (url, timeoutMs, headers) => {
@@ -2447,6 +2674,8 @@ async function handleLocal(v, kvInstance) {
 				mode: "compact",
 				results: results.map((memory) => ({
 					...memory,
+					type: "decision",
+					memoryType: memory.type,
 					obsId: memory.id,
 					sessionId: memory.sessionIds?.[0] ?? "memory",
 					layer: "memory"
@@ -2589,6 +2818,7 @@ const transport = createStdioTransport(async (method, params) => {
 		default: throw new Error(`Unknown method: ${method}`);
 	}
 });
+installCrashHandlers({ persist: () => kv.persist() });
 process.stderr.write(`[@agentmemory/mcp] Standalone MCP server v${SERVER_INFO.version} starting...\n`);
 transport.start();
 process.on("SIGINT", () => {