miladyai 2.0.0-alpha.27

package/dist/hooks/registry.js

@@ -0,0 +1,55 @@
+import { logger } from "@elizaos/core";
+
+//#region src/hooks/registry.ts
+const registry = /* @__PURE__ */ new Map();
+/**
+* Event keys: "command" matches all command events,
+* "command:new" matches only /new.
+*/
+function registerHook(eventKey, handler) {
+	const handlers = registry.get(eventKey) ?? [];
+	handlers.push(handler);
+	registry.set(eventKey, handlers);
+}
+function clearHooks() {
+	registry.clear();
+}
+/** Dispatches to specific ("command:new") then general ("command") handlers. */
+async function triggerHook(event) {
+	const specificKey = `${event.type}:${event.action}`;
+	const generalKey = event.type;
+	const handlers = [];
+	const specificHandlers = registry.get(specificKey);
+	if (specificHandlers) for (const handler of specificHandlers) handlers.push({
+		key: specificKey,
+		handler
+	});
+	const generalHandlers = registry.get(generalKey);
+	if (generalHandlers) for (const handler of generalHandlers) handlers.push({
+		key: generalKey,
+		handler
+	});
+	if (handlers.length === 0) return;
+	const errors = [];
+	for (const { key, handler } of handlers) try {
+		await handler(event);
+	} catch (err) {
+		const error = err instanceof Error ? err : new Error(String(err));
+		logger.error(`[hooks] Handler error for "${key}": ${error.message}`);
+		errors.push(error);
+	}
+	if (errors.length > 0) logger.warn(`[hooks] ${errors.length} hook handler(s) failed — errors were logged above`);
+}
+function createHookEvent(type, action, sessionKey, context = {}) {
+	return {
+		type,
+		action,
+		sessionKey,
+		timestamp: /* @__PURE__ */ new Date(),
+		messages: [],
+		context
+	};
+}
+
+//#endregion
+export { clearHooks, createHookEvent, registerHook, triggerHook };

package/dist/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 };

package/dist/index.js

@@ -0,0 +1,49 @@
+import process from "node:process";
+
+//#region src/runtime/restart.ts
+/**
+* Restart infrastructure for Milady.
+*
+* Provides a pluggable restart handler so the restart action (and the
+* `/api/agent/restart` endpoint) work in every host environment:
+*
+*   - **CLI** (default): exits with {@link RESTART_EXIT_CODE} (75). The runner
+*     script (`scripts/run-node.mjs`) catches this, rebuilds if source files
+*     changed, and relaunches.
+*   - **Dev-server / API**: the host registers a handler via
+*     {@link setRestartHandler} that stops the current runtime, creates a new
+*     one, and hot-swaps references.
+*   - **Electron app**: the host registers a handler that calls
+*     `AgentManager.restart()`.
+*
+* @module restart
+*/
+/**
+* Special exit code that tells the CLI runner to restart the process.
+* Must stay in sync with `RESTART_EXIT_CODE` in `scripts/run-node.mjs`.
+*/
+const RESTART_EXIT_CODE = 75;
+let _handler = () => {
+	process.exit(RESTART_EXIT_CODE);
+};
+/**
+* Replace the active restart handler.
+*
+* Call this at startup in non-CLI environments (dev-server, Electron) to
+* provide an in-process restart strategy.
+*/
+function setRestartHandler(handler) {
+	_handler = handler;
+}
+/**
+* Trigger a restart.  Delegates to whatever handler is currently registered.
+*
+* Safe to call from the restart action, the API endpoint, or any other code
+* that needs to bounce the agent.
+*/
+function requestRestart(reason) {
+	return _handler(reason);
+}
+
+//#endregion
+export { RESTART_EXIT_CODE, requestRestart, setRestartHandler };