miladyai 2.0.0-alpha.27

package/dist/api/diagnostics-routes.js

@@ -0,0 +1,205 @@
+import { parseClampedInteger } from "../utils/number-parsing.js";
+import { AUDIT_EVENT_TYPES, AUDIT_SEVERITIES, getAuditFeedSize, queryAuditFeed, subscribeAuditFeed } from "../security/audit-log.js";
+import path from "node:path";
+import fs from "node:fs";
+import { fileURLToPath } from "node:url";
+
+//#region src/api/diagnostics-routes.ts
+async function defaultCheckRelayReachable(relayPort) {
+	try {
+		const response = await fetch(`http://127.0.0.1:${relayPort}/`, {
+			method: "HEAD",
+			signal: AbortSignal.timeout(2e3)
+		});
+		return response.ok || response.status < 500;
+	} catch {
+		return false;
+	}
+}
+function defaultResolveExtensionPath() {
+	try {
+		const serverDir = path.dirname(fileURLToPath(import.meta.url));
+		const extensionPath = path.resolve(serverDir, "..", "..", "apps", "chrome-extension");
+		return fs.existsSync(extensionPath) ? extensionPath : null;
+	} catch {
+		return null;
+	}
+}
+function isAutonomyEvent(event) {
+	return event.type === "agent_event" || event.type === "heartbeat_event";
+}
+function defaultInitSse(res) {
+	res.writeHead(200, {
+		"Content-Type": "text/event-stream",
+		"Cache-Control": "no-cache",
+		Connection: "keep-alive",
+		"X-Accel-Buffering": "no"
+	});
+}
+function defaultWriteSseData(res, data, event) {
+	if (event) res.write(`event: ${event}\n`);
+	const safe = data.replace(/\r?\n/g, "\ndata: ");
+	res.write(`data: ${safe}\n\n`);
+}
+function defaultWriteSseJson(res, payload, event) {
+	defaultWriteSseData(res, JSON.stringify(payload), event);
+}
+function parseAuditSince(raw) {
+	if (raw == null) return {};
+	const trimmed = raw.trim();
+	if (!trimmed) return { error: "Invalid \"since\" filter: expected epoch ms or ISO timestamp." };
+	const numeric = Number(trimmed);
+	if (Number.isFinite(numeric)) return { value: Math.trunc(numeric) };
+	const parsed = Date.parse(trimmed);
+	if (!Number.isFinite(parsed)) return { error: "Invalid \"since\" filter: expected epoch ms or ISO timestamp." };
+	return { value: parsed };
+}
+function isTruthyQueryParam(value) {
+	if (!value) return false;
+	const normalized = value.trim().toLowerCase();
+	return normalized === "1" || normalized === "true" || normalized === "yes" || normalized === "on";
+}
+function matchesAuditFilter(entry, filters) {
+	if (filters.type && entry.type !== filters.type) return false;
+	if (filters.severity && entry.severity !== filters.severity) return false;
+	if (filters.sinceMs !== void 0 && Date.parse(entry.timestamp) < filters.sinceMs) return false;
+	return true;
+}
+async function handleDiagnosticsRoutes(ctx) {
+	const { req, res, method, pathname, url, logBuffer, eventBuffer, relayPort: relayPortOverride, checkRelayReachable, resolveExtensionPath, initSse, writeSseJson, json } = ctx;
+	if (method === "GET" && pathname === "/api/logs") {
+		let entries = logBuffer;
+		const sourceFilter = url.searchParams.get("source");
+		if (sourceFilter) entries = entries.filter((entry) => entry.source === sourceFilter);
+		const levelFilter = url.searchParams.get("level");
+		if (levelFilter) entries = entries.filter((entry) => entry.level === levelFilter);
+		const tagFilter = url.searchParams.get("tag");
+		if (tagFilter) entries = entries.filter((entry) => entry.tags.includes(tagFilter));
+		const sinceFilter = url.searchParams.get("since");
+		if (sinceFilter) {
+			const sinceTimestamp = Number(sinceFilter);
+			if (!Number.isNaN(sinceTimestamp)) entries = entries.filter((entry) => entry.timestamp >= sinceTimestamp);
+		}
+		const sources = [...new Set(logBuffer.map((entry) => entry.source))].sort();
+		const tags = [...new Set(logBuffer.flatMap((entry) => entry.tags))].sort();
+		json(res, {
+			entries: entries.slice(-200),
+			sources,
+			tags
+		});
+		return true;
+	}
+	if (method === "GET" && pathname === "/api/agent/events") {
+		const limit = parseClampedInteger(url.searchParams.get("limit"), {
+			min: 1,
+			max: 1e3,
+			fallback: 200
+		});
+		const afterEventId = url.searchParams.get("after");
+		const autonomyEvents = eventBuffer.filter(isAutonomyEvent);
+		let startIndex = 0;
+		if (afterEventId) {
+			const index = autonomyEvents.findIndex((event) => event.eventId === afterEventId);
+			if (index >= 0) startIndex = index + 1;
+		}
+		const events = autonomyEvents.slice(startIndex, startIndex + limit);
+		json(res, {
+			events,
+			latestEventId: events.length > 0 ? events[events.length - 1].eventId : null,
+			totalBuffered: autonomyEvents.length,
+			replayed: true
+		});
+		return true;
+	}
+	if (method === "GET" && pathname === "/api/security/audit") {
+		const typeFilterRaw = url.searchParams.get("type");
+		const severityFilterRaw = url.searchParams.get("severity");
+		const limitFilter = parseClampedInteger(url.searchParams.get("limit"), {
+			min: 1,
+			max: 1e3,
+			fallback: 200
+		});
+		const sinceFilter = parseAuditSince(url.searchParams.get("since"));
+		if (sinceFilter.error) {
+			json(res, { error: sinceFilter.error }, 400);
+			return true;
+		}
+		let typeFilter;
+		if (typeFilterRaw) {
+			const candidate = typeFilterRaw.trim();
+			if (!AUDIT_EVENT_TYPES.includes(candidate)) {
+				json(res, { error: `Invalid "type" filter. Expected one of: ${AUDIT_EVENT_TYPES.join(", ")}` }, 400);
+				return true;
+			}
+			typeFilter = candidate;
+		}
+		let severityFilter;
+		if (severityFilterRaw) {
+			const candidate = severityFilterRaw.trim();
+			if (!AUDIT_SEVERITIES.includes(candidate)) {
+				json(res, { error: `Invalid "severity" filter. Expected one of: ${AUDIT_SEVERITIES.join(", ")}` }, 400);
+				return true;
+			}
+			severityFilter = candidate;
+		}
+		const streamRequested = isTruthyQueryParam(url.searchParams.get("stream")) || (req.headers.accept ?? "").includes("text/event-stream");
+		const filter = {
+			type: typeFilter,
+			severity: severityFilter,
+			sinceMs: sinceFilter.value
+		};
+		if (!streamRequested) {
+			json(res, {
+				entries: queryAuditFeed({
+					...filter,
+					limit: limitFilter
+				}),
+				totalBuffered: getAuditFeedSize(),
+				replayed: true
+			});
+			return true;
+		}
+		const startSse = initSse ?? defaultInitSse;
+		const sendSseJson = writeSseJson ?? defaultWriteSseJson;
+		startSse(res);
+		sendSseJson(res, {
+			type: "snapshot",
+			entries: queryAuditFeed({
+				...filter,
+				limit: limitFilter
+			}),
+			totalBuffered: getAuditFeedSize()
+		});
+		const unsubscribe = subscribeAuditFeed((entry) => {
+			if (!matchesAuditFilter(entry, filter)) return;
+			sendSseJson(res, {
+				type: "entry",
+				entry
+			});
+		});
+		let closed = false;
+		const close = () => {
+			if (closed) return;
+			closed = true;
+			unsubscribe();
+			if (!res.writableEnded) res.end();
+		};
+		req.on("close", close);
+		req.on("aborted", close);
+		res.on("close", close);
+		return true;
+	}
+	if (method === "GET" && pathname === "/api/extension/status") {
+		const relayPort = relayPortOverride ?? 18792;
+		json(res, {
+			relayReachable: await (checkRelayReachable ?? defaultCheckRelayReachable)(relayPort),
+			relayPort,
+			extensionPath: (resolveExtensionPath ?? defaultResolveExtensionPath)()
+		});
+		return true;
+	}
+	return false;
+}
+
+//#endregion
+export { handleDiagnosticsRoutes };

package/dist/api/drop-service.js

@@ -0,0 +1,134 @@
+import { logger } from "@elizaos/core";
+import { ethers } from "ethers";
+
+//#region src/api/drop-service.ts
+/**
+* MiladyMaker drop/mint service.
+*
+* Handles the ERC-8041 fixed-supply collection minting:
+* - Public free mint (user pays gas)
+* - Shiny mint (0.1 ETH + gas)
+* - Whitelist mint (Merkle proof)
+* - Supply tracking and status
+*/
+const COLLECTION_ABI = [
+	"function mint(string,string,bytes32) external returns (uint256)",
+	"function mintShiny(string,string,bytes32) external payable returns (uint256)",
+	"function mintWhitelist(string,string,bytes32,bytes32[]) external returns (uint256)",
+	"function mintFor(address,string,string,bytes32,bool) external returns (uint256)",
+	"function currentSupply() view returns (uint256)",
+	"function publicMintOpen() view returns (bool)",
+	"function whitelistMintOpen() view returns (bool)",
+	"function hasMinted(address) view returns (bool)",
+	"function getAgentMintNumber(uint256) view returns (uint256)",
+	"function isShiny(uint256) view returns (bool)",
+	"function getCollectionDetails() view returns (uint256,uint256,bool)",
+	"function MAX_SUPPLY() view returns (uint256)",
+	"function SHINY_PRICE() view returns (uint256)",
+	"function merkleRoot() view returns (bytes32)",
+	"event AgentMinted(uint256 indexed agentId, uint256 indexed mintNumber, address indexed owner, bool shiny)",
+	"event CollectionUpdated(uint256 maxSupply, uint256 currentSupply, bool publicOpen, bool whitelistOpen)"
+];
+const DEFAULT_CAP_HASH = ethers.id("milady-agent");
+var DropService = class {
+	constructor(txService, collectionAddress, dropEnabled) {
+		this.txService = txService;
+		this.contract = txService.getContract(collectionAddress, COLLECTION_ABI);
+		this.dropEnabled = dropEnabled;
+	}
+	async getStatus() {
+		if (!this.dropEnabled) return {
+			dropEnabled: false,
+			publicMintOpen: false,
+			whitelistMintOpen: false,
+			mintedOut: false,
+			currentSupply: 0,
+			maxSupply: 2138,
+			shinyPrice: "0.1",
+			userHasMinted: false
+		};
+		const [collectionDetails, whitelistOpen, hasMinted, shinyPriceBN] = await Promise.all([
+			this.contract.getCollectionDetails(),
+			this.contract.whitelistMintOpen(),
+			this.contract.hasMinted(this.txService.address),
+			this.contract.SHINY_PRICE()
+		]);
+		const [maxSupply, currentSupply, publicOpen] = collectionDetails;
+		const maxSupplyNum = Number(maxSupply);
+		const currentSupplyNum = Number(currentSupply);
+		return {
+			dropEnabled: true,
+			publicMintOpen: publicOpen,
+			whitelistMintOpen: whitelistOpen,
+			mintedOut: currentSupplyNum >= maxSupplyNum,
+			currentSupply: currentSupplyNum,
+			maxSupply: maxSupplyNum,
+			shinyPrice: ethers.formatEther(shinyPriceBN),
+			userHasMinted: hasMinted
+		};
+	}
+	async mint(name, endpoint, capabilitiesHash) {
+		const capHash = capabilitiesHash || DEFAULT_CAP_HASH;
+		logger.info(`[drop] Minting agent "${name}" for ${this.txService.address}`);
+		const nonce = await this.txService.getFreshNonce();
+		const tx = await this.contract.mint(name, endpoint, capHash, { nonce });
+		logger.info(`[drop] Mint tx submitted: ${tx.hash}`);
+		const receipt = await tx.wait();
+		return this.parseMintReceipt(receipt, false);
+	}
+	async mintShiny(name, endpoint, capabilitiesHash) {
+		const capHash = capabilitiesHash || DEFAULT_CAP_HASH;
+		const shinyPrice = await this.contract.SHINY_PRICE();
+		logger.info(`[drop] Minting SHINY agent "${name}" for ${this.txService.address} (${ethers.formatEther(shinyPrice)} ETH)`);
+		const nonce = await this.txService.getFreshNonce();
+		const tx = await this.contract.mintShiny(name, endpoint, capHash, {
+			value: shinyPrice,
+			nonce
+		});
+		logger.info(`[drop] Shiny mint tx submitted: ${tx.hash}`);
+		const receipt = await tx.wait();
+		return this.parseMintReceipt(receipt, true);
+	}
+	async mintWithWhitelist(name, endpoint, proof, capabilitiesHash) {
+		const capHash = capabilitiesHash || DEFAULT_CAP_HASH;
+		logger.info(`[drop] Whitelist minting agent "${name}" for ${this.txService.address}`);
+		const nonce = await this.txService.getFreshNonce();
+		const tx = await this.contract.mintWhitelist(name, endpoint, capHash, proof, { nonce });
+		logger.info(`[drop] Whitelist mint tx submitted: ${tx.hash}`);
+		const receipt = await tx.wait();
+		return this.parseMintReceipt(receipt, false);
+	}
+	async getMintNumber(agentId) {
+		return Number(await this.contract.getAgentMintNumber(agentId));
+	}
+	async checkIsShiny(agentId) {
+		return this.contract.isShiny(agentId);
+	}
+	parseMintReceipt(receipt, shiny) {
+		const iface = new ethers.Interface(COLLECTION_ABI);
+		let agentId = 0;
+		let mintNumber = 0;
+		for (const log of receipt.logs) {
+			const parsed = iface.parseLog({
+				topics: log.topics,
+				data: log.data
+			});
+			if (parsed && parsed.name === "AgentMinted") {
+				agentId = Number(parsed.args[0]);
+				mintNumber = Number(parsed.args[1]);
+				shiny = parsed.args[3];
+				break;
+			}
+		}
+		logger.info(`[drop] Minted: agentId=${agentId} mintNumber=${mintNumber} shiny=${shiny} txHash=${receipt.hash}`);
+		return {
+			agentId,
+			mintNumber,
+			txHash: receipt.hash,
+			isShiny: shiny
+		};
+	}
+};
+
+//#endregion
+export { DropService };

package/dist/api/early-logs.js

@@ -0,0 +1,86 @@
+import { logger } from "@elizaos/core";
+
+//#region src/api/early-logs.ts
+/**
+* Early log capture — split out from server.ts to avoid pulling in the entire
+* API server dependency graph when only the log-buffer bootstrap is needed
+* (e.g. during headless `startEliza()`).
+*
+* @module api/early-logs
+*/
+let earlyLogBuffer = null;
+let earlyPatchCleanup = null;
+/**
+* Start capturing logs from the global @elizaos/core logger before the API
+* server is up.  Call this once, early in the startup flow (e.g. before
+* `startEliza`).  When `startApiServer` runs it will flush and take over.
+*/
+function captureEarlyLogs() {
+	if (earlyLogBuffer) return;
+	if (logger.__miladyLogPatched) return;
+	earlyLogBuffer = [];
+	const EARLY_PATCHED = "__miladyEarlyPatched";
+	if (logger[EARLY_PATCHED]) return;
+	const LEVELS = [
+		"debug",
+		"info",
+		"warn",
+		"error"
+	];
+	const originals = /* @__PURE__ */ new Map();
+	for (const lvl of LEVELS) {
+		const original = logger[lvl].bind(logger);
+		originals.set(lvl, original);
+		const earlyPatched = (...args) => {
+			let msg = "";
+			let source = "agent";
+			const tags = ["agent"];
+			if (typeof args[0] === "string") msg = args[0];
+			else if (args[0] && typeof args[0] === "object") {
+				const obj = args[0];
+				if (typeof obj.src === "string") source = obj.src;
+				msg = typeof args[1] === "string" ? args[1] : JSON.stringify(obj);
+			}
+			const bracketMatch = /^\[([^\]]+)\]\s*/.exec(msg);
+			if (bracketMatch && source === "agent") source = bracketMatch[1];
+			if (source !== "agent" && !tags.includes(source)) tags.push(source);
+			earlyLogBuffer?.push({
+				timestamp: Date.now(),
+				level: lvl,
+				message: msg,
+				source,
+				tags
+			});
+			return original(...args);
+		};
+		logger[lvl] = earlyPatched;
+	}
+	logger[EARLY_PATCHED] = true;
+	earlyPatchCleanup = () => {
+		for (const lvl of LEVELS) {
+			const orig = originals.get(lvl);
+			if (orig) logger[lvl] = orig;
+		}
+		delete logger[EARLY_PATCHED];
+		delete logger.__miladyLogPatched;
+	};
+}
+/**
+* Drain the early log buffer and clean up the early logger patch.
+* Called by `startApiServer` to flush buffered entries into the main log
+* buffer, then hand control to the server's own logger patch.
+*
+* Returns the buffered entries (empty array if none).
+*/
+function flushEarlyLogs() {
+	const entries = earlyLogBuffer ? [...earlyLogBuffer] : [];
+	if (earlyPatchCleanup) {
+		earlyPatchCleanup();
+		earlyPatchCleanup = null;
+	}
+	earlyLogBuffer = null;
+	return entries;
+}
+
+//#endregion
+export { captureEarlyLogs, flushEarlyLogs };

package/dist/api/http-helpers.js

@@ -0,0 +1,131 @@
+//#region src/api/http-helpers.ts
+/**
+* Common request body size guard used across API/benchmark endpoints.
+*/
+const DEFAULT_MAX_BODY_BYTES = 1048576;
+function defaultTooLargeMessage(maxBytes, explicit) {
+	return explicit ?? `Request body exceeds maximum size (${maxBytes} bytes)`;
+}
+async function readRequestBodyBuffer(req, { maxBytes = DEFAULT_MAX_BODY_BYTES, returnNullOnError = false, returnNullOnTooLarge = false, destroyOnTooLarge = false, tooLargeMessage } = {}) {
+	return new Promise((resolve, reject) => {
+		const chunks = [];
+		let totalBytes = 0;
+		let tooLarge = false;
+		let settled = false;
+		const message = defaultTooLargeMessage(maxBytes, tooLargeMessage);
+		const cleanup = () => {
+			req.off("data", onData);
+			req.off("end", onEnd);
+			req.off("error", onError);
+		};
+		const settle = (value) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			resolve(value);
+		};
+		const fail = (err) => {
+			if (settled) return;
+			settled = true;
+			cleanup();
+			reject(err);
+		};
+		const onData = (chunk) => {
+			if (settled) return;
+			totalBytes += chunk.length;
+			if (totalBytes > maxBytes) {
+				tooLarge = true;
+				if (returnNullOnTooLarge) {
+					if (destroyOnTooLarge) req.destroy();
+					settle(null);
+					return;
+				}
+				if (destroyOnTooLarge) {
+					req.destroy();
+					fail(new Error(message));
+					return;
+				}
+				return;
+			}
+			chunks.push(chunk);
+		};
+		const onEnd = () => {
+			if (settled) return;
+			if (tooLarge) {
+				if (returnNullOnTooLarge) {
+					settle(null);
+					return;
+				}
+				fail(new Error(message));
+				return;
+			}
+			settle(Buffer.concat(chunks));
+		};
+		const onError = (err) => {
+			if (returnNullOnError) {
+				settle(null);
+				return;
+			}
+			fail(err);
+		};
+		req.on("data", onData);
+		req.on("end", onEnd);
+		req.on("error", onError);
+	});
+}
+async function readRequestBody(req, options = {}) {
+	const { encoding = "utf-8", ...rawOptions } = options;
+	const body = await readRequestBodyBuffer(req, rawOptions);
+	if (body === null) return null;
+	return body.toString(encoding);
+}
+async function writeJsonResponse(res, body, status = 200) {
+	res.statusCode = status;
+	res.setHeader("Content-Type", "application/json");
+	res.end(JSON.stringify(body));
+}
+async function writeJsonError(res, message, status = 400) {
+	await writeJsonResponse(res, { error: message }, status);
+}
+function writeJsonResponseSafe(res, body, status = 200) {
+	writeJsonResponse(res, body, status).catch(() => {});
+}
+/** Shorthand responder for successful JSON payloads with safe fire-and-forget write. */
+function sendJson(res, body, status = 200) {
+	writeJsonResponseSafe(res, body, status);
+}
+/** Shorthand responder for JSON error payloads with safe fire-and-forget write. */
+function sendJsonError(res, message, status = 400) {
+	writeJsonErrorSafe(res, message, status);
+}
+function writeJsonErrorSafe(res, message, status = 400) {
+	writeJsonError(res, message, status).catch(() => {});
+}
+async function readJsonBody(req, res, { readErrorStatus = 413, nonObjectStatus = 400, parseErrorStatus = 400, readErrorMessage = "Failed to read request body", nonObjectMessage = "Request body must be a JSON object", parseErrorMessage = "Invalid JSON in request body", requireObject = true, ...readOptions } = {}) {
+	let raw;
+	try {
+		const body = await readRequestBody(req, readOptions);
+		if (body == null) {
+			await writeJsonError(res, readErrorMessage, readErrorStatus);
+			return null;
+		}
+		raw = body;
+	} catch (err) {
+		await writeJsonError(res, err instanceof Error ? err.message : "Failed to read request body", readErrorStatus);
+		return null;
+	}
+	try {
+		const parsed = JSON.parse(raw);
+		if (requireObject && (parsed === null || typeof parsed !== "object" || Array.isArray(parsed))) {
+			await writeJsonError(res, nonObjectMessage, nonObjectStatus);
+			return null;
+		}
+		return parsed;
+	} catch {
+		await writeJsonError(res, parseErrorMessage, parseErrorStatus);
+		return null;
+	}
+}
+
+//#endregion
+export { readJsonBody, readRequestBody, readRequestBodyBuffer, sendJson, sendJsonError };