miladyai 2.0.0-alpha.27

package/dist/diagnostics/integration-observability.js

@@ -0,0 +1,57 @@
+import { logger } from "@elizaos/core";
+
+//#region src/diagnostics/integration-observability.ts
+const EVENT_PREFIX = "[integration]";
+function inferErrorKind(error) {
+	if (error instanceof Error) {
+		const message = error.message.toLowerCase();
+		if (error.name === "AbortError" || error.name === "TimeoutError" || message.includes("timeout") || message.includes("timed out")) return "timeout";
+		return sanitizeToken(error.name);
+	}
+	if (typeof error === "string") return sanitizeToken(error);
+}
+function sanitizeToken(value) {
+	if (!value) return void 0;
+	const normalized = value.toLowerCase().replace(/[^a-z0-9_-]/g, "_").replace(/_+/g, "_").replace(/^_+|_+$/g, "");
+	return normalized ? normalized.slice(0, 64) : void 0;
+}
+function emitEvent(sink, event) {
+	const line = `${EVENT_PREFIX} ${JSON.stringify(event)}`;
+	if (event.outcome === "success") {
+		sink.info(line);
+		return;
+	}
+	sink.warn(line);
+}
+function createIntegrationTelemetrySpan(meta, options = {}) {
+	const now = options.now ?? Date.now;
+	const sink = options.sink ?? logger;
+	const startedAt = now();
+	let settled = false;
+	const finalize = (outcome, args) => {
+		if (settled) return;
+		settled = true;
+		const durationMs = Math.max(0, now() - startedAt);
+		const event = {
+			schema: "integration_boundary_v1",
+			boundary: meta.boundary,
+			operation: meta.operation,
+			outcome,
+			durationMs
+		};
+		if (typeof meta.timeoutMs === "number") event.timeoutMs = meta.timeoutMs;
+		if (typeof args?.statusCode === "number") event.statusCode = args.statusCode;
+		if (outcome === "failure") {
+			const failureArgs = args;
+			event.errorKind = sanitizeToken(failureArgs?.errorKind) ?? inferErrorKind(failureArgs?.error);
+		}
+		emitEvent(sink, event);
+	};
+	return {
+		success: (args) => finalize("success", args),
+		failure: (args) => finalize("failure", args)
+	};
+}
+
+//#endregion
+export { createIntegrationTelemetrySpan };

package/dist/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 fs from "node:fs";
+import path from "node:path";
+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/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/early-logs.js

@@ -0,0 +1,24 @@
+import { logger } from "@elizaos/core";
+
+//#region src/api/early-logs.ts
+let earlyLogBuffer = null;
+let earlyPatchCleanup = null;
+/**
+* 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 { flushEarlyLogs };