miladyai 2.0.0-alpha.27

package/dist/services/agent-export.js

@@ -0,0 +1,559 @@
+import { logger } from "@elizaos/core";
+import * as crypto$1 from "node:crypto";
+import { Readable } from "node:stream";
+import { createGunzip, gzipSync } from "node:zlib";
+import { z } from "zod";
+
+//#region src/services/agent-export.ts
+/**
+* Agent Export/Import Service
+*
+* Provides encrypted, portable agent archives for migrating agents between
+* machines. Captures all database state (character, memories, entities,
+* relationships, rooms, participants, worlds, tasks, and optionally logs)
+* into a single password-encrypted binary file (.eliza-agent).
+*
+* Encryption: PBKDF2-SHA256 key derivation + AES-256-GCM
+* Compression: gzip
+*
+* File format (binary):
+*   ELIZA_AGENT_V1\n   (15 bytes magic header)
+*   iterations           (4 bytes uint32 BE — PBKDF2 iteration count)
+*   salt                 (32 bytes — PBKDF2 salt)
+*   iv                   (12 bytes — AES-256-GCM nonce)
+*   tag                  (16 bytes — AES-GCM authentication tag)
+*   ciphertext           (variable — gzip-compressed JSON, encrypted)
+*/
+const MAGIC_BYTES = Buffer.from("ELIZA_AGENT_V1\n", "utf-8");
+const PBKDF2_ITERATIONS = 6e5;
+const MAX_PBKDF2_ITERATIONS = 12e5;
+const SALT_LEN = 32;
+const IV_LEN = 12;
+const TAG_LEN = 16;
+const KEY_LEN = 32;
+const MIN_PASSWORD_LENGTH = 4;
+const HEADER_SIZE = MAGIC_BYTES.length + 4 + SALT_LEN + IV_LEN + TAG_LEN;
+const EXPORT_VERSION = 1;
+const MAX_IMPORT_DECOMPRESSED_BYTES = 16 * 1024 * 1024;
+const MEMORY_TABLES = [
+	"messages",
+	"facts",
+	"documents",
+	"fragments",
+	"descriptions",
+	"character_modifications",
+	"custom"
+];
+const IdRecord = z.record(z.string(), z.unknown()).and(z.object({ id: z.string() }));
+const IdRecordArray = z.array(IdRecord);
+const LooseRecordArray = z.array(z.record(z.string(), z.unknown()));
+const PayloadSchema = z.object({
+	version: z.number().int().min(1),
+	exportedAt: z.string(),
+	sourceAgentId: z.string(),
+	agent: z.record(z.string(), z.unknown()),
+	characterConfig: z.record(z.string(), z.unknown()).optional(),
+	entities: IdRecordArray,
+	memories: IdRecordArray,
+	components: IdRecordArray,
+	rooms: IdRecordArray,
+	participants: z.array(z.object({
+		entityId: z.string(),
+		roomId: z.string(),
+		userState: z.string().nullable()
+	})),
+	relationships: IdRecordArray,
+	worlds: IdRecordArray,
+	tasks: IdRecordArray,
+	logs: LooseRecordArray
+});
+function deriveKey(password, salt, iterations) {
+	return new Promise((resolve, reject) => {
+		crypto$1.pbkdf2(password, salt, iterations, KEY_LEN, "sha256", (err, key) => {
+			if (err) reject(err);
+			else resolve(key);
+		});
+	});
+}
+async function encrypt(plaintext, password) {
+	const salt = crypto$1.randomBytes(SALT_LEN);
+	const iv = crypto$1.randomBytes(IV_LEN);
+	const key = await deriveKey(password, salt, PBKDF2_ITERATIONS);
+	const cipher = crypto$1.createCipheriv("aes-256-gcm", key, iv);
+	const ciphertext = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+	return {
+		salt,
+		iv,
+		tag: cipher.getAuthTag(),
+		ciphertext,
+		iterations: PBKDF2_ITERATIONS
+	};
+}
+async function decrypt(ciphertext, password, salt, iv, tag, iterations) {
+	const key = await deriveKey(password, salt, iterations);
+	const decipher = crypto$1.createDecipheriv("aes-256-gcm", key, iv);
+	decipher.setAuthTag(tag);
+	return Buffer.concat([decipher.update(ciphertext), decipher.final()]);
+}
+function packFile(encrypted) {
+	const iterBuf = Buffer.alloc(4);
+	iterBuf.writeUInt32BE(encrypted.iterations, 0);
+	return Buffer.concat([
+		MAGIC_BYTES,
+		iterBuf,
+		encrypted.salt,
+		encrypted.iv,
+		encrypted.tag,
+		encrypted.ciphertext
+	]);
+}
+function unpackFile(fileBuffer) {
+	if (fileBuffer.length < HEADER_SIZE) throw new AgentExportError("File is too small to be a valid .eliza-agent export.");
+	if (!fileBuffer.subarray(0, MAGIC_BYTES.length).equals(MAGIC_BYTES)) throw new AgentExportError("Invalid file format — this does not appear to be an .eliza-agent export file.");
+	let offset = MAGIC_BYTES.length;
+	const iterations = fileBuffer.readUInt32BE(offset);
+	offset += 4;
+	if (iterations < 1 || iterations > MAX_PBKDF2_ITERATIONS) throw new AgentExportError(`Invalid PBKDF2 iteration count (${iterations}). Expected between 1 and ${MAX_PBKDF2_ITERATIONS.toLocaleString()}.`);
+	const salt = fileBuffer.subarray(offset, offset + SALT_LEN);
+	offset += SALT_LEN;
+	const iv = fileBuffer.subarray(offset, offset + IV_LEN);
+	offset += IV_LEN;
+	const tag = fileBuffer.subarray(offset, offset + TAG_LEN);
+	offset += TAG_LEN;
+	const ciphertext = fileBuffer.subarray(offset);
+	if (ciphertext.length === 0) throw new AgentExportError("Export file contains no encrypted data.");
+	return {
+		salt,
+		iv,
+		tag,
+		ciphertext,
+		iterations
+	};
+}
+var AgentExportError = class extends Error {
+	constructor(message) {
+		super(message);
+		this.name = "AgentExportError";
+	}
+};
+async function gunzipWithSizeLimit(compressed, maxBytes = MAX_IMPORT_DECOMPRESSED_BYTES) {
+	const source = Readable.from([compressed]);
+	const gunzip = createGunzip();
+	const chunks = [];
+	let total = 0;
+	source.pipe(gunzip);
+	for await (const chunk of gunzip) {
+		const buf = Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk);
+		total += buf.length;
+		if (total > maxBytes) {
+			source.destroy();
+			gunzip.destroy();
+			throw new AgentExportError(`Decompressed payload exceeds import limit (${maxBytes} bytes).`);
+		}
+		chunks.push(buf);
+	}
+	return Buffer.concat(chunks, total);
+}
+/** Read agentId from a Task, accounting for proto vs DB naming. */
+function taskAgentId(t) {
+	const rec = t;
+	return rec.agentId ?? rec.agent_id;
+}
+async function extractAgentData(runtime, options) {
+	const db = runtime.adapter;
+	const agentId = runtime.agentId;
+	logger.info(`[agent-export] Extracting data for agent ${agentId}`);
+	const agent = await db.getAgent(agentId);
+	if (!agent) throw new AgentExportError(`Agent ${agentId} not found in database.`);
+	const agentWorlds = (await db.getAllWorlds()).filter((w) => w.agentId === agentId);
+	logger.info(`[agent-export] Found ${agentWorlds.length} worlds`);
+	const roomMap = /* @__PURE__ */ new Map();
+	for (const world of agentWorlds) {
+		if (!world.id) continue;
+		const worldRooms = await db.getRoomsByWorld(world.id);
+		for (const room of worldRooms) if (room.id) roomMap.set(room.id, room);
+	}
+	const participantRoomIds = await db.getRoomsForParticipant(agentId);
+	if (participantRoomIds.length > 0) {
+		const participantRooms = await db.getRoomsByIds(participantRoomIds);
+		if (participantRooms) {
+			for (const room of participantRooms) if (room.id) roomMap.set(room.id, room);
+		}
+	}
+	const rooms = Array.from(roomMap.values());
+	logger.info(`[agent-export] Found ${rooms.length} rooms`);
+	const entityMap = /* @__PURE__ */ new Map();
+	const participantRecords = [];
+	for (const room of rooms) {
+		if (!room.id) continue;
+		const roomEntities = await db.getEntitiesForRoom(room.id, true);
+		for (const entity of roomEntities) if (entity.id) entityMap.set(entity.id, entity);
+		const participantIds = await db.getParticipantsForRoom(room.id);
+		for (const entityId of participantIds) {
+			const userState = await db.getParticipantUserState(room.id, entityId);
+			participantRecords.push({
+				entityId,
+				roomId: room.id,
+				userState
+			});
+		}
+	}
+	const entities = Array.from(entityMap.values());
+	logger.info(`[agent-export] Found ${entities.length} entities, ${participantRecords.length} participant records`);
+	const componentIds = /* @__PURE__ */ new Set();
+	const allComponents = [];
+	const addComponent = (c) => {
+		if (c.id && !componentIds.has(c.id)) {
+			componentIds.add(c.id);
+			allComponents.push(c);
+		}
+	};
+	for (const entity of entities) {
+		if (!entity.id) continue;
+		for (const c of await db.getComponents(entity.id)) addComponent(c);
+		for (const world of agentWorlds) {
+			if (!world.id) continue;
+			for (const c of await db.getComponents(entity.id, world.id)) addComponent(c);
+		}
+	}
+	logger.info(`[agent-export] Found ${allComponents.length} components`);
+	const allMemories = [];
+	const memoryIdSet = /* @__PURE__ */ new Set();
+	for (const tableName of MEMORY_TABLES) {
+		const memories = await db.getMemories({
+			agentId,
+			tableName,
+			count: Number.MAX_SAFE_INTEGER
+		});
+		for (const mem of memories) if (mem.id && !memoryIdSet.has(mem.id)) {
+			memoryIdSet.add(mem.id);
+			allMemories.push({
+				...mem,
+				embedding: void 0
+			});
+		}
+	}
+	for (const world of agentWorlds) {
+		if (!world.id) continue;
+		for (const tableName of MEMORY_TABLES) {
+			const worldMemories = await db.getMemoriesByWorldId({
+				worldId: world.id,
+				count: Number.MAX_SAFE_INTEGER,
+				tableName
+			});
+			for (const mem of worldMemories) if (mem.id && !memoryIdSet.has(mem.id)) {
+				memoryIdSet.add(mem.id);
+				allMemories.push({
+					...mem,
+					embedding: void 0
+				});
+			}
+		}
+	}
+	logger.info(`[agent-export] Found ${allMemories.length} memories`);
+	const relationships = await db.getRelationships({ entityId: agentId });
+	logger.info(`[agent-export] Found ${relationships.length} relationships`);
+	const agentTasks = (await db.getTasks({})).filter((t) => taskAgentId(t) === agentId);
+	logger.info(`[agent-export] Found ${agentTasks.length} tasks`);
+	let logs = [];
+	if (options.includeLogs) {
+		logs = await db.getLogs({ count: Number.MAX_SAFE_INTEGER });
+		logger.info(`[agent-export] Found ${logs.length} logs`);
+	}
+	let characterConfig;
+	if (runtime.character) {
+		const { secrets, ...safeChar } = runtime.character;
+		characterConfig = safeChar;
+		logger.info(`[agent-export] Captured runtime character config (${Object.keys(safeChar).length} fields)`);
+	}
+	return {
+		version: EXPORT_VERSION,
+		exportedAt: (/* @__PURE__ */ new Date()).toISOString(),
+		sourceAgentId: agentId,
+		agent,
+		characterConfig,
+		entities,
+		memories: allMemories,
+		components: allComponents,
+		rooms,
+		participants: participantRecords,
+		relationships,
+		worlds: agentWorlds,
+		tasks: agentTasks,
+		logs
+	};
+}
+function createIdRemapper(fixed) {
+	const map = new Map(fixed);
+	return (oldId) => {
+		if (!oldId) return oldId;
+		const existing = map.get(oldId);
+		if (existing) return existing;
+		const newId = crypto$1.randomUUID();
+		map.set(oldId, newId);
+		return newId;
+	};
+}
+async function restoreAgentData(runtime, payload) {
+	const db = runtime.adapter;
+	const newAgentId = crypto$1.randomUUID();
+	const remap = createIdRemapper(new Map([[payload.sourceAgentId, newAgentId]]));
+	logger.info(`[agent-import] Importing agent "${payload.agent.name}" as ${newAgentId}`);
+	const charBase = payload.characterConfig ? { ...payload.characterConfig } : {};
+	delete charBase.secrets;
+	const agentData = {
+		...charBase,
+		...payload.agent
+	};
+	agentData.id = newAgentId;
+	agentData.enabled = true;
+	agentData.createdAt = Date.now();
+	agentData.updatedAt = Date.now();
+	if (!await db.createAgent(agentData)) throw new AgentExportError("Failed to create agent in database.");
+	logger.info(`[agent-import] Created agent record${payload.characterConfig ? " (merged with characterConfig)" : ""}`);
+	let worldsImported = 0;
+	for (const world of payload.worlds) {
+		const newWorld = {
+			...world,
+			id: remap(world.id ?? ""),
+			agentId: newAgentId
+		};
+		await db.createWorld(newWorld);
+		worldsImported++;
+	}
+	logger.info(`[agent-import] Imported ${worldsImported} worlds`);
+	let roomsImported = 0;
+	const roomBatch = [];
+	for (const room of payload.rooms) {
+		const newRoom = {
+			...room,
+			id: remap(room.id ?? ""),
+			agentId: newAgentId,
+			worldId: room.worldId ? remap(room.worldId) : void 0
+		};
+		roomBatch.push(newRoom);
+	}
+	if (roomBatch.length > 0) {
+		await db.createRooms(roomBatch);
+		roomsImported = roomBatch.length;
+	}
+	logger.info(`[agent-import] Imported ${roomsImported} rooms`);
+	let entitiesImported = 0;
+	const entityBatch = [];
+	for (const entity of payload.entities) {
+		const newEntity = {
+			...entity,
+			id: remap(entity.id ?? ""),
+			agentId: newAgentId,
+			components: void 0
+		};
+		entityBatch.push(newEntity);
+	}
+	if (entityBatch.length > 0) {
+		await db.createEntities(entityBatch);
+		entitiesImported = entityBatch.length;
+	}
+	logger.info(`[agent-import] Imported ${entitiesImported} entities`);
+	let participantsImported = 0;
+	for (const p of payload.participants) {
+		const newEntityId = remap(p.entityId);
+		const newRoomId = remap(p.roomId);
+		await db.addParticipantsRoom([newEntityId], newRoomId);
+		if (p.userState === "FOLLOWED" || p.userState === "MUTED") await db.setParticipantUserState(newRoomId, newEntityId, p.userState);
+		participantsImported++;
+	}
+	logger.info(`[agent-import] Imported ${participantsImported} participants`);
+	let componentsImported = 0;
+	for (const comp of payload.components) {
+		const newComp = {
+			...comp,
+			id: remap(comp.id ?? ""),
+			...comp.entityId ? { entityId: remap(comp.entityId) } : {},
+			...comp.agentId ? { agentId: newAgentId } : {},
+			...comp.roomId ? { roomId: remap(comp.roomId) } : {},
+			...comp.worldId ? { worldId: remap(comp.worldId) } : {},
+			...comp.sourceEntityId ? { sourceEntityId: remap(comp.sourceEntityId) } : {}
+		};
+		await db.createComponent(newComp);
+		componentsImported++;
+	}
+	logger.info(`[agent-import] Imported ${componentsImported} components`);
+	let memoriesImported = 0;
+	for (const mem of payload.memories) {
+		const tableName = resolveMemoryTableName(mem);
+		const newMem = {
+			...mem,
+			id: remap(mem.id ?? ""),
+			agentId: newAgentId,
+			...mem.entityId ? { entityId: remap(mem.entityId) } : {},
+			...mem.roomId ? { roomId: remap(mem.roomId) } : {},
+			...mem.worldId ? { worldId: remap(mem.worldId) } : {},
+			embedding: void 0
+		};
+		await db.createMemory(newMem, tableName);
+		memoriesImported++;
+	}
+	logger.info(`[agent-import] Imported ${memoriesImported} memories`);
+	let relationshipsImported = 0;
+	for (const rel of payload.relationships) {
+		await db.createRelationship({
+			sourceEntityId: remap(rel.sourceEntityId ?? ""),
+			targetEntityId: remap(rel.targetEntityId ?? ""),
+			tags: rel.tags,
+			metadata: rel.metadata
+		});
+		relationshipsImported++;
+	}
+	logger.info(`[agent-import] Imported ${relationshipsImported} relationships`);
+	let tasksImported = 0;
+	for (const task of payload.tasks) {
+		const newTask = {
+			...task,
+			id: remap(task.id ?? ""),
+			agentId: newAgentId,
+			roomId: task.roomId ? remap(task.roomId) : void 0,
+			worldId: task.worldId ? remap(task.worldId) : void 0,
+			entityId: task.entityId ? remap(task.entityId) : void 0
+		};
+		await db.createTask(newTask);
+		tasksImported++;
+	}
+	logger.info(`[agent-import] Imported ${tasksImported} tasks`);
+	let logsImported = 0;
+	for (const logEntry of payload.logs) {
+		await db.log({
+			body: logEntry.body,
+			entityId: logEntry.entityId ? remap(logEntry.entityId) : logEntry.entityId,
+			roomId: logEntry.roomId ? remap(logEntry.roomId) : newAgentId,
+			type: logEntry.type ?? "action"
+		});
+		logsImported++;
+	}
+	logger.info(`[agent-import] Imported ${logsImported} logs`);
+	return {
+		success: true,
+		agentId: newAgentId,
+		agentName: payload.agent.name ?? "Unknown",
+		counts: {
+			memories: memoriesImported,
+			entities: entitiesImported,
+			components: componentsImported,
+			rooms: roomsImported,
+			participants: participantsImported,
+			relationships: relationshipsImported,
+			worlds: worldsImported,
+			tasks: tasksImported,
+			logs: logsImported
+		}
+	};
+}
+/**
+* Resolve the memory table name from a memory record's metadata.
+* The ElizaOS adapter requires a tableName for createMemory.
+*/
+function resolveMemoryTableName(mem) {
+	const metaType = mem.metadata?.type;
+	if (metaType === "message") return "messages";
+	if (metaType === "document") return "documents";
+	if (metaType === "fragment") return "fragments";
+	if (metaType === "description") return "descriptions";
+	if (metaType === "custom") return "custom";
+	const memType = mem.type;
+	if (typeof memType === "string" && memType.length > 0) return memType;
+	return "messages";
+}
+/**
+* Export the current agent's full state as a password-encrypted binary file.
+*
+* @param runtime - The running AgentRuntime with an active database adapter
+* @param password - User-provided password for encryption
+* @param options - Export options (e.g., whether to include logs)
+* @returns A Buffer containing the encrypted .eliza-agent file
+*/
+async function exportAgent(runtime, password, options = {}) {
+	if (!password || password.length < MIN_PASSWORD_LENGTH) throw new AgentExportError(`A password of at least ${MIN_PASSWORD_LENGTH} characters is required to encrypt the export.`);
+	if (!runtime.adapter) throw new AgentExportError("No database adapter available on the runtime.");
+	const payload = await extractAgentData(runtime, { includeLogs: options.includeLogs ?? false });
+	const jsonString = JSON.stringify(payload);
+	const compressed = gzipSync(Buffer.from(jsonString, "utf-8"));
+	logger.info(`[agent-export] Payload: ${jsonString.length} bytes JSON → ${compressed.length} bytes compressed`);
+	const fileBuffer = packFile(await encrypt(compressed, password));
+	logger.info(`[agent-export] Final file size: ${fileBuffer.length} bytes`);
+	return fileBuffer;
+}
+/**
+* Import an agent from a password-encrypted .eliza-agent file.
+*
+* @param runtime - An AgentRuntime with an active database adapter (the agent
+*                  will be created in this database, not overwriting the current agent)
+* @param fileBuffer - The raw bytes of the .eliza-agent file
+* @param password - The password used when the file was exported
+* @returns An ImportResult describing what was imported
+*/
+async function importAgent(runtime, fileBuffer, password) {
+	if (!password || password.length < MIN_PASSWORD_LENGTH) throw new AgentExportError(`A password of at least ${MIN_PASSWORD_LENGTH} characters is required to decrypt the import.`);
+	if (!runtime.adapter) throw new AgentExportError("No database adapter available on the runtime.");
+	const { salt, iv, tag, ciphertext, iterations } = unpackFile(fileBuffer);
+	let compressed;
+	try {
+		compressed = await decrypt(ciphertext, password, salt, iv, tag, iterations);
+	} catch (err) {
+		if (err instanceof Error && (err.message.includes("Unsupported state") || err.message.includes("unable to authenticate") || err.message.includes("auth"))) throw new AgentExportError("Incorrect password — decryption failed. Please check your password and try again.");
+		throw new AgentExportError(`Decryption failed: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	let jsonString;
+	try {
+		jsonString = (await gunzipWithSizeLimit(compressed)).toString("utf-8");
+	} catch (err) {
+		if (err instanceof AgentExportError) throw err;
+		throw new AgentExportError(`Decompression failed — the file may be corrupt: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	let rawPayload;
+	try {
+		rawPayload = JSON.parse(jsonString);
+	} catch (err) {
+		throw new AgentExportError(`JSON parse failed — the export data is malformed: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	const parseResult = PayloadSchema.safeParse(rawPayload);
+	if (!parseResult.success) throw new AgentExportError(`Export file schema validation failed: ${parseResult.error.issues.map((i) => `${i.path.join(".")}: ${i.message}`).join("; ")}`);
+	const payload = rawPayload;
+	if (payload.version > EXPORT_VERSION) throw new AgentExportError(`Unsupported export version ${payload.version}. This build supports up to version ${EXPORT_VERSION}. Please update your software to import this file.`);
+	logger.info(`[agent-import] Importing agent "${payload.agent.name}" exported at ${payload.exportedAt}`);
+	return restoreAgentData(runtime, payload);
+}
+/**
+* Estimate the size of an agent export without actually creating it.
+* Useful for showing the user how large the export will be.
+*/
+async function estimateExportSize(runtime) {
+	const db = runtime.adapter;
+	const agentId = runtime.agentId;
+	let memoriesCount = 0;
+	for (const tableName of MEMORY_TABLES) {
+		const mems = await db.getMemories({
+			agentId,
+			tableName,
+			count: Number.MAX_SAFE_INTEGER
+		});
+		memoriesCount += mems.length;
+	}
+	const agentWorlds = (await db.getAllWorlds()).filter((w) => w.agentId === agentId);
+	const roomIds = await db.getRoomsForParticipant(agentId);
+	const entityIdSet = /* @__PURE__ */ new Set();
+	for (const roomId of roomIds) {
+		const roomEntities = await db.getEntitiesForRoom(roomId);
+		for (const e of roomEntities) if (e.id) entityIdSet.add(e.id);
+	}
+	const agentTasks = (await db.getTasks({})).filter((t) => taskAgentId(t) === agentId);
+	return {
+		estimatedBytes: memoriesCount * 500 + entityIdSet.size * 200 + roomIds.length * 300 + agentWorlds.length * 200 + agentTasks.length * 400 + 2e3,
+		memoriesCount,
+		entitiesCount: entityIdSet.size,
+		roomsCount: roomIds.length,
+		worldsCount: agentWorlds.length,
+		tasksCount: agentTasks.length
+	};
+}
+
+//#endregion
+export { AgentExportError, estimateExportSize, exportAgent, importAgent };