miladyai 2.0.0-alpha.27

package/dist/emotes/catalog.js

@@ -0,0 +1,271 @@
+//#region src/emotes/catalog.ts
+const EMOTE_CATALOG = [
+	{
+		id: "wave",
+		name: "Wave",
+		description: "Waves both hands in greeting",
+		glbPath: "/animations/emotes/waving-both-hands.glb",
+		duration: 2.5,
+		loop: false,
+		category: "greeting"
+	},
+	{
+		id: "kiss",
+		name: "Kiss",
+		description: "Blows a kiss",
+		glbPath: "/animations/emotes/kiss.glb",
+		duration: 2,
+		loop: false,
+		category: "greeting"
+	},
+	{
+		id: "crying",
+		name: "Crying",
+		description: "Cries sadly",
+		glbPath: "/animations/emotes/crying.glb",
+		duration: 3,
+		loop: true,
+		category: "emotion"
+	},
+	{
+		id: "sorrow",
+		name: "Sorrow",
+		description: "Expresses deep sorrow",
+		glbPath: "/animations/emotes/sorrow.glb",
+		duration: 3,
+		loop: true,
+		category: "emotion"
+	},
+	{
+		id: "rude-gesture",
+		name: "Rude Gesture",
+		description: "Makes a rude gesture",
+		glbPath: "/animations/emotes/rude-gesture.glb",
+		duration: 2,
+		loop: false,
+		category: "emotion"
+	},
+	{
+		id: "looking-around",
+		name: "Looking Around",
+		description: "Looks around nervously",
+		glbPath: "/animations/emotes/looking-around.glb",
+		duration: 3,
+		loop: true,
+		category: "emotion"
+	},
+	{
+		id: "dance-happy",
+		name: "Happy Dance",
+		description: "Happy dance",
+		glbPath: "/animations/emotes/dance-happy.glb",
+		duration: 4,
+		loop: true,
+		category: "dance"
+	},
+	{
+		id: "dance-breaking",
+		name: "Breaking",
+		description: "Breakdance moves",
+		glbPath: "/animations/emotes/dance-breaking.glb",
+		duration: 4,
+		loop: true,
+		category: "dance"
+	},
+	{
+		id: "dance-hiphop",
+		name: "Hip Hop",
+		description: "Hip hop dance",
+		glbPath: "/animations/emotes/dance-hiphop.glb",
+		duration: 4,
+		loop: true,
+		category: "dance"
+	},
+	{
+		id: "dance-popping",
+		name: "Popping",
+		description: "Popping dance moves",
+		glbPath: "/animations/emotes/dance-popping.glb",
+		duration: 4,
+		loop: true,
+		category: "dance"
+	},
+	{
+		id: "hook-punch",
+		name: "Hook Punch",
+		description: "Throws a hook punch",
+		glbPath: "/animations/emotes/hook-punch.glb",
+		duration: 1.5,
+		loop: false,
+		category: "combat"
+	},
+	{
+		id: "punching",
+		name: "Punching",
+		description: "Throws punches",
+		glbPath: "/animations/emotes/punching.glb",
+		duration: 2,
+		loop: false,
+		category: "combat"
+	},
+	{
+		id: "firing-gun",
+		name: "Firing Gun",
+		description: "Fires a gun",
+		glbPath: "/animations/emotes/firing-gun.glb",
+		duration: 2,
+		loop: false,
+		category: "combat"
+	},
+	{
+		id: "sword-swing",
+		name: "Sword Swing",
+		description: "Swings a sword",
+		glbPath: "/animations/emotes/sword_swing.glb",
+		duration: 2,
+		loop: false,
+		category: "combat"
+	},
+	{
+		id: "chopping",
+		name: "Chopping",
+		description: "Chops with an axe",
+		glbPath: "/animations/emotes/chopping.glb",
+		duration: 2,
+		loop: false,
+		category: "combat"
+	},
+	{
+		id: "spell-cast",
+		name: "Spell Cast",
+		description: "Casts a magic spell",
+		glbPath: "/animations/emotes/spell-cast.glb",
+		duration: 2.5,
+		loop: false,
+		category: "combat"
+	},
+	{
+		id: "range",
+		name: "Range",
+		description: "Fires a ranged weapon",
+		glbPath: "/animations/emotes/range.glb",
+		duration: 2,
+		loop: false,
+		category: "combat"
+	},
+	{
+		id: "death",
+		name: "Death",
+		description: "Falls down defeated",
+		glbPath: "/animations/emotes/death.glb",
+		duration: 3,
+		loop: false,
+		category: "combat"
+	},
+	{
+		id: "idle",
+		name: "Idle",
+		description: "Stands idle",
+		glbPath: "/animations/emotes/idle.glb",
+		duration: 5,
+		loop: true,
+		category: "idle"
+	},
+	{
+		id: "talk",
+		name: "Talk",
+		description: "Talks animatedly",
+		glbPath: "/animations/emotes/talk.glb",
+		duration: 3,
+		loop: true,
+		category: "idle"
+	},
+	{
+		id: "squat",
+		name: "Squat",
+		description: "Squats down",
+		glbPath: "/animations/emotes/squat.glb",
+		duration: 3,
+		loop: true,
+		category: "idle"
+	},
+	{
+		id: "fishing",
+		name: "Fishing",
+		description: "Casts a fishing line",
+		glbPath: "/animations/emotes/fishing.glb",
+		duration: 5,
+		loop: true,
+		category: "idle"
+	},
+	{
+		id: "float",
+		name: "Float",
+		description: "Floats in the air",
+		glbPath: "/animations/emotes/float.glb",
+		duration: 4,
+		loop: true,
+		category: "idle"
+	},
+	{
+		id: "jump",
+		name: "Jump",
+		description: "Jumps up",
+		glbPath: "/animations/emotes/jump.glb",
+		duration: 1.5,
+		loop: false,
+		category: "movement"
+	},
+	{
+		id: "flip",
+		name: "Flip",
+		description: "Does a backflip",
+		glbPath: "/animations/emotes/flip.glb",
+		duration: 2,
+		loop: false,
+		category: "movement"
+	},
+	{
+		id: "run",
+		name: "Run",
+		description: "Runs in place",
+		glbPath: "/animations/emotes/run.glb",
+		duration: 3,
+		loop: true,
+		category: "movement"
+	},
+	{
+		id: "walk",
+		name: "Walk",
+		description: "Walks in place",
+		glbPath: "/animations/emotes/walk.glb",
+		duration: 3,
+		loop: true,
+		category: "movement"
+	},
+	{
+		id: "crawling",
+		name: "Crawling",
+		description: "Crawls on the ground",
+		glbPath: "/animations/emotes/crawling.glb",
+		duration: 3,
+		loop: true,
+		category: "movement"
+	},
+	{
+		id: "fall",
+		name: "Fall",
+		description: "Falls down",
+		glbPath: "/animations/emotes/fall.glb",
+		duration: 2,
+		loop: false,
+		category: "movement"
+	}
+];
+/**
+* Map for O(1) emote lookup by ID
+*/
+const EMOTE_BY_ID = new Map(EMOTE_CATALOG.map((emote) => [emote.id, emote]));
+
+//#endregion
+export { EMOTE_BY_ID, EMOTE_CATALOG };

package/dist/entry.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+import { applyCliProfileEnv, parseCliProfileArgs } from "./cli/profile.js";
+import process from "node:process";
+
+//#region src/entry.ts
+/**
+* CLI entry point for Milady.
+*
+* This file is built by tsdown into dist/entry.js and invoked by milady.mjs.
+* It bootstraps the CLI: normalizes env, applies profile settings,
+* and delegates to the Commander-based CLI.
+*/
+process.title = "milady";
+if (process.argv.includes("--no-color")) {
+	process.env.NO_COLOR = "1";
+	process.env.FORCE_COLOR = "0";
+}
+if (!process.env.LOG_LEVEL) if (process.argv.includes("--debug")) process.env.LOG_LEVEL = "debug";
+else if (process.argv.includes("--verbose")) process.env.LOG_LEVEL = "info";
+else process.env.LOG_LEVEL = "error";
+if (!process.env.NODE_LLAMA_CPP_LOG_LEVEL) {
+	const logLevel = String(process.env.LOG_LEVEL).toLowerCase();
+	process.env.NODE_LLAMA_CPP_LOG_LEVEL = logLevel === "debug" ? "debug" : logLevel === "info" ? "info" : "error";
+}
+const parsed = parseCliProfileArgs(process.argv);
+if (!parsed.ok) {
+	console.error(`[milady] ${parsed.error}`);
+	process.exit(2);
+}
+if (parsed.profile) {
+	applyCliProfileEnv({ profile: parsed.profile });
+	process.argv = parsed.argv;
+}
+import("./cli/run-main.js").then(({ runCli }) => runCli(process.argv)).catch((error) => {
+	console.error("[milady] Failed to start CLI:", error instanceof Error ? error.stack ?? error.message : error);
+	process.exit(1);
+});
+
+//#endregion
+export {  };

package/dist/hooks/discovery.js

@@ -0,0 +1,167 @@
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+import { logger } from "@elizaos/core";
+import { readFile, readdir, stat } from "node:fs/promises";
+
+//#region src/hooks/discovery.ts
+/**
+* Discover hooks from workspace, managed (~/.milady/hooks/), and bundled dirs.
+* Later sources win on name conflicts.
+*/
+const HOOK_MD = "HOOK.md";
+const HANDLER_NAMES = [
+	"handler.ts",
+	"handler",
+	"index.ts",
+	"index"
+];
+function parseFrontmatter(content) {
+	const fmMatch = content.match(/^---\s*\n([\s\S]*?)\n---/);
+	if (!fmMatch) return null;
+	const fmBlock = fmMatch[1];
+	const result = {
+		name: "",
+		description: ""
+	};
+	for (const line of fmBlock.split("\n")) {
+		const kvMatch = line.match(/^(\w+):\s*(.+)/);
+		if (!kvMatch) continue;
+		const [, key, rawValue] = kvMatch;
+		const value = rawValue.replace(/^["']|["']$/g, "").trim();
+		switch (key) {
+			case "name":
+				result.name = value;
+				break;
+			case "description":
+				result.description = value;
+				break;
+			case "homepage":
+				result.homepage = value;
+				break;
+			case "metadata":
+				try {
+					const metaStart = fmBlock.indexOf("metadata:");
+					if (metaStart !== -1) {
+						const jsonMatch = fmBlock.slice(metaStart + 9).trim().match(/\{[\s\S]*\}/);
+						if (jsonMatch) result.metadata = JSON.parse(jsonMatch[0]);
+					}
+				} catch {
+					try {
+						result.metadata = JSON.parse(value);
+					} catch {
+						logger.warn(`[hooks] Failed to parse metadata in HOOK.md`);
+					}
+				}
+				break;
+		}
+	}
+	return result.name ? result : null;
+}
+function extractMetadata(frontmatter) {
+	const milady = frontmatter.metadata?.milady;
+	if (!milady) return void 0;
+	return {
+		always: milady.always,
+		hookKey: milady.hookKey,
+		emoji: milady.emoji,
+		homepage: milady.homepage ?? frontmatter.homepage,
+		events: Array.isArray(milady.events) ? milady.events : [],
+		export: milady.export,
+		os: milady.os,
+		requires: milady.requires,
+		install: milady.install
+	};
+}
+async function isDirectory(path) {
+	try {
+		return (await stat(path)).isDirectory();
+	} catch {
+		return false;
+	}
+}
+async function fileExists(path) {
+	try {
+		return (await stat(path)).isFile();
+	} catch {
+		return false;
+	}
+}
+async function findHandlerPath(dir) {
+	for (const name of HANDLER_NAMES) {
+		const p = join(dir, name);
+		if (await fileExists(p)) return p;
+	}
+	return null;
+}
+async function loadHookFromDir(dir, source, pluginId) {
+	const hookMdPath = join(dir, HOOK_MD);
+	if (!await fileExists(hookMdPath)) return null;
+	const handlerPath = await findHandlerPath(dir);
+	if (!handlerPath) {
+		logger.warn(`[hooks] Hook at ${dir} has HOOK.md but no handler`);
+		return null;
+	}
+	try {
+		const frontmatter = parseFrontmatter(await readFile(hookMdPath, "utf-8"));
+		if (!frontmatter) {
+			logger.warn(`[hooks] Invalid frontmatter in ${hookMdPath}`);
+			return null;
+		}
+		const metadata = extractMetadata(frontmatter);
+		return {
+			hook: {
+				name: frontmatter.name,
+				description: frontmatter.description,
+				source,
+				pluginId,
+				filePath: hookMdPath,
+				baseDir: dir,
+				handlerPath
+			},
+			frontmatter,
+			metadata
+		};
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		logger.warn(`[hooks] Error loading hook from ${dir}: ${msg}`);
+		return null;
+	}
+}
+async function scanHooksDir(dir, source) {
+	if (!await isDirectory(dir)) return [];
+	const entries = [];
+	try {
+		const items = await readdir(dir);
+		for (const item of items) {
+			const itemPath = join(dir, item);
+			if (!await isDirectory(itemPath)) continue;
+			const entry = await loadHookFromDir(itemPath, source);
+			if (entry) entries.push(entry);
+		}
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		logger.warn(`[hooks] Error scanning ${dir}: ${msg}`);
+	}
+	return entries;
+}
+/** Precedence: extra (lowest) -> bundled -> managed -> workspace (highest). */
+async function discoverHooks(options = {}) {
+	const seen = /* @__PURE__ */ new Map();
+	if (options.extraDirs) for (const dir of options.extraDirs) {
+		const resolved = resolve(dir.replace(/^~/, homedir()));
+		for (const entry of await scanHooksDir(resolved, "milady-managed")) seen.set(entry.hook.name, entry);
+	}
+	if (options.bundledDir) for (const entry of await scanHooksDir(options.bundledDir, "milady-bundled")) seen.set(entry.hook.name, entry);
+	const managedDir = join(homedir(), ".milady", "hooks");
+	for (const entry of await scanHooksDir(managedDir, "milady-managed")) seen.set(entry.hook.name, entry);
+	if (options.workspacePath) {
+		const wsHooksDir = join(options.workspacePath.replace(/^~/, homedir()), "hooks");
+		for (const entry of await scanHooksDir(wsHooksDir, "milady-workspace")) seen.set(entry.hook.name, entry);
+	}
+	const all = Array.from(seen.values());
+	logger.info(`[hooks] Discovered ${all.length} hooks`);
+	return all;
+}
+
+//#endregion
+export { discoverHooks };

package/dist/hooks/eligibility.js

@@ -0,0 +1,64 @@
+import { platform } from "node:os";
+import { delimiter } from "node:path";
+import { existsSync } from "node:fs";
+
+//#region src/hooks/eligibility.ts
+/**
+* Hook eligibility: checks OS, binary, env, and config requirements.
+*/
+function binaryExists(name) {
+	const pathDirs = (process.env.PATH ?? "").split(delimiter);
+	for (const dir of pathDirs) if (existsSync(`${dir}/${name}`)) return true;
+	return false;
+}
+function resolveConfigPath(config, pathStr) {
+	const parts = pathStr.split(".");
+	let current = config;
+	for (const part of parts) {
+		if (current === null || current === void 0 || typeof current !== "object") return;
+		current = current[part];
+	}
+	return current;
+}
+function isConfigPathTruthy(config, pathStr) {
+	const value = resolveConfigPath(config, pathStr);
+	return value !== void 0 && value !== null && value !== false && value !== "" && value !== 0;
+}
+function checkEligibility(metadata, hookConfig, miladyConfig = {}) {
+	const missing = [];
+	if (!metadata) return {
+		eligible: true,
+		missing: []
+	};
+	if (metadata.os && metadata.os.length > 0) {
+		if (!metadata.os.includes(platform())) missing.push(`OS: requires ${metadata.os.join("|")}, current: ${platform()}`);
+	}
+	if (metadata.always) return {
+		eligible: missing.length === 0,
+		missing
+	};
+	if (metadata.requires?.bins) {
+		for (const bin of metadata.requires.bins) if (!binaryExists(bin)) missing.push(`Binary missing: ${bin}`);
+	}
+	if (metadata.requires?.anyBins && metadata.requires.anyBins.length > 0) {
+		if (!metadata.requires.anyBins.some(binaryExists)) missing.push(`None of: ${metadata.requires.anyBins.join(", ")}`);
+	}
+	if (metadata.requires?.env) for (const envVar of metadata.requires.env) {
+		const hasInProcess = Boolean(process.env[envVar]);
+		const hasInHookConfig = Boolean(hookConfig?.env?.[envVar]);
+		if (!hasInProcess && !hasInHookConfig) missing.push(`Env missing: ${envVar}`);
+	}
+	if (metadata.requires?.config) {
+		for (const configPath of metadata.requires.config) if (!isConfigPathTruthy(miladyConfig, configPath)) missing.push(`Config missing: ${configPath}`);
+	}
+	return {
+		eligible: missing.length === 0,
+		missing
+	};
+}
+function resolveHookConfig(internalConfig, hookKey) {
+	return internalConfig?.entries?.[hookKey];
+}
+
+//#endregion
+export { checkEligibility, resolveHookConfig };

package/dist/hooks/index.js

@@ -0,0 +1,4 @@
+import { createHookEvent, triggerHook } from "./registry.js";
+import { loadHooks } from "./loader.js";
+
+export {  };

package/dist/hooks/loader.js

@@ -0,0 +1,147 @@
+import { discoverHooks } from "./discovery.js";
+import { checkEligibility, resolveHookConfig } from "./eligibility.js";
+import { clearHooks, registerHook } from "./registry.js";
+import { homedir } from "node:os";
+import { resolve, sep } from "node:path";
+import { logger } from "@elizaos/core";
+import { pathToFileURL } from "node:url";
+
+//#region src/hooks/loader.ts
+/**
+* Hook Loader — load and register hooks into the event system.
+*
+* Orchestrates discovery -> eligibility -> loading -> registration.
+*
+* @module hooks/loader
+*/
+/** Directories from which hook modules may be loaded. */
+function getSafeHookRoots(workspacePath, bundledDir) {
+	const roots = [resolve(homedir(), ".milady", "hooks")];
+	if (bundledDir) roots.push(resolve(bundledDir));
+	if (workspacePath) roots.push(resolve(workspacePath.replace(/^~/, homedir()), "hooks"));
+	return roots;
+}
+/**
+* Ensure a module path resolves to a file under one of the allowed hook
+* roots.  Blocks absolute paths to arbitrary locations and path-traversal
+* attacks (e.g. "../../etc/malicious").
+*/
+function isPathUnderRoots(modulePath, roots) {
+	const resolved = resolve(modulePath);
+	return roots.some((root) => {
+		const r = root.endsWith(sep) ? root : root + sep;
+		return resolved.startsWith(r) || resolved === root;
+	});
+}
+/**
+* Dynamically import a hook handler module.
+* Uses cache-busting query parameter for dev mode hot reload.
+*/
+async function loadHandlerModule(handlerPath, exportName = "default") {
+	try {
+		const handler = (await import(`${pathToFileURL(handlerPath).href}?t=${Date.now()}`))[exportName];
+		if (typeof handler !== "function") {
+			logger.warn(`[hooks] Handler at ${handlerPath} does not export a function as "${exportName}"`);
+			return null;
+		}
+		return handler;
+	} catch (err) {
+		const msg = err instanceof Error ? err.message : String(err);
+		logger.error(`[hooks] Failed to load handler ${handlerPath}: ${msg}`);
+		return null;
+	}
+}
+/**
+* Discover, filter, load, and register all hooks.
+*
+* This is the main entry point called during gateway startup.
+*/
+async function loadHooks(options = {}) {
+	const { internalConfig, miladyConfig = {} } = options;
+	if (internalConfig?.enabled === false) {
+		logger.info("[hooks] Internal hooks disabled");
+		return {
+			discovered: 0,
+			eligible: 0,
+			registered: 0,
+			skipped: [],
+			failed: []
+		};
+	}
+	clearHooks();
+	const safeExtraDirs = [...options.extraDirs ?? []];
+	const miladyHome = resolve(homedir(), ".milady");
+	for (const dir of internalConfig?.load?.extraDirs ?? []) {
+		const resolved = resolve(dir.replace(/^~/, homedir()));
+		if (resolved.startsWith(miladyHome + sep) || resolved === miladyHome) safeExtraDirs.push(dir);
+		else logger.warn(`[hooks] Rejected config extraDir "${dir}": must be under ~/.milady/`);
+	}
+	const entries = await discoverHooks({
+		workspacePath: options.workspacePath,
+		bundledDir: options.bundledDir,
+		extraDirs: safeExtraDirs
+	});
+	const result = {
+		discovered: entries.length,
+		eligible: 0,
+		registered: 0,
+		skipped: [],
+		failed: []
+	};
+	for (const entry of entries) {
+		const hookConfig = resolveHookConfig(internalConfig, entry.metadata?.hookKey ?? entry.hook.name);
+		const eligibility = checkEligibility(entry.metadata, hookConfig, miladyConfig);
+		if (!eligibility.eligible) {
+			result.skipped.push(`${entry.hook.name}: ${eligibility.missing.join(", ")}`);
+			continue;
+		}
+		result.eligible++;
+		if (hookConfig?.enabled === false) {
+			result.skipped.push(`${entry.hook.name}: disabled in config`);
+			continue;
+		}
+		const exportName = entry.metadata?.export ?? "default";
+		const handler = await loadHandlerModule(entry.hook.handlerPath, exportName);
+		if (!handler) {
+			result.failed.push(entry.hook.name);
+			continue;
+		}
+		const events = entry.metadata?.events ?? [];
+		if (events.length === 0) {
+			logger.warn(`[hooks] Hook "${entry.hook.name}" has no events configured`);
+			result.skipped.push(`${entry.hook.name}: no events`);
+			continue;
+		}
+		for (const eventKey of events) registerHook(eventKey, handler);
+		const emoji = entry.metadata?.emoji ?? "🔗";
+		logger.info(`[hooks] ${emoji} Registered: ${entry.hook.name} -> ${events.join(", ")}`);
+		result.registered++;
+	}
+	if (internalConfig?.handlers) {
+		const safeRoots = getSafeHookRoots(options.workspacePath, options.bundledDir);
+		for (const legacyHandler of internalConfig.handlers) {
+			if (!isPathUnderRoots(legacyHandler.module, safeRoots)) {
+				logger.warn(`[hooks] Rejected legacy handler: module path "${legacyHandler.module}" is outside allowed hook directories`);
+				result.failed.push(legacyHandler.module);
+				continue;
+			}
+			try {
+				const handler = await loadHandlerModule(legacyHandler.module, legacyHandler.export ?? "default");
+				if (handler) {
+					registerHook(legacyHandler.event, handler);
+					logger.info(`[hooks] Registered legacy handler: ${legacyHandler.event} -> ${legacyHandler.module}`);
+					result.registered++;
+				} else result.failed.push(legacyHandler.module);
+			} catch (err) {
+				const msg = err instanceof Error ? err.message : String(err);
+				logger.warn(`[hooks] Failed to load legacy handler: ${msg}`);
+				result.failed.push(legacyHandler.module);
+			}
+		}
+	}
+	logger.info(`[hooks] Load complete: ${result.registered}/${result.discovered} registered, ${result.skipped.length} skipped, ${result.failed.length} failed`);
+	return result;
+}
+
+//#endregion
+export { loadHooks };