miladyai 2.0.0-alpha.27

package/dist/config/includes.js

@@ -0,0 +1,121 @@
+import { isPlainObject } from "./object-utils.js";
+import path from "node:path";
+import fs from "node:fs";
+import JSON5 from "json5";
+
+//#region src/config/includes.ts
+/**
+* $include directive for modular configs.
+*
+* ```json5
+* { "$include": "./base.json5" }
+* { "$include": ["./a.json5", "./b.json5"] }
+* ```
+*/
+const INCLUDE_KEY = "$include";
+const MAX_INCLUDE_DEPTH = 10;
+const BLOCKED_KEYS = new Set([
+	"__proto__",
+	"constructor",
+	"prototype"
+]);
+var ConfigIncludeError = class extends Error {
+	constructor(message, includePath, cause) {
+		super(message);
+		this.includePath = includePath;
+		this.cause = cause;
+		this.name = "ConfigIncludeError";
+	}
+};
+var CircularIncludeError = class extends ConfigIncludeError {
+	constructor(chain) {
+		super(`Circular include detected: ${chain.join(" -> ")}`, chain[chain.length - 1]);
+		this.chain = chain;
+		this.name = "CircularIncludeError";
+	}
+};
+function deepMerge(target, source) {
+	if (Array.isArray(target) && Array.isArray(source)) return [...target, ...source];
+	if (isPlainObject(target) && isPlainObject(source)) {
+		const result = { ...target };
+		for (const key of Object.keys(source)) {
+			if (BLOCKED_KEYS.has(key)) continue;
+			result[key] = key in result ? deepMerge(result[key], source[key]) : source[key];
+		}
+		return result;
+	}
+	return source;
+}
+var IncludeProcessor = class IncludeProcessor {
+	constructor(basePath, resolver) {
+		this.basePath = basePath;
+		this.resolver = resolver;
+		this.visited = /* @__PURE__ */ new Set();
+		this.depth = 0;
+		this.visited.add(path.normalize(basePath));
+	}
+	process(obj) {
+		if (Array.isArray(obj)) return obj.map((item) => this.process(item));
+		if (!isPlainObject(obj)) return obj;
+		if (!(INCLUDE_KEY in obj)) return this.processObject(obj);
+		return this.processInclude(obj);
+	}
+	processObject(obj) {
+		const result = {};
+		for (const [key, value] of Object.entries(obj)) {
+			if (BLOCKED_KEYS.has(key)) continue;
+			result[key] = this.process(value);
+		}
+		return result;
+	}
+	processInclude(obj) {
+		const includeValue = obj[INCLUDE_KEY];
+		const otherKeys = Object.keys(obj).filter((k) => k !== INCLUDE_KEY);
+		const included = this.resolveInclude(includeValue);
+		if (otherKeys.length === 0) return included;
+		if (!isPlainObject(included)) throw new ConfigIncludeError("Sibling keys require included content to be an object", typeof includeValue === "string" ? includeValue : INCLUDE_KEY);
+		const rest = {};
+		for (const key of otherKeys) rest[key] = this.process(obj[key]);
+		return deepMerge(included, rest);
+	}
+	resolveInclude(value) {
+		if (typeof value === "string") return this.loadFile(value);
+		if (Array.isArray(value)) return value.reduce((merged, item) => {
+			if (typeof item !== "string") throw new ConfigIncludeError(`Invalid $include array item: expected string, got ${typeof item}`, String(item));
+			return deepMerge(merged, this.loadFile(item));
+		}, {});
+		throw new ConfigIncludeError(`Invalid $include value: expected string or array of strings, got ${typeof value}`, String(value));
+	}
+	loadFile(includePath) {
+		const resolvedPath = path.isAbsolute(includePath) ? includePath : path.resolve(path.dirname(this.basePath), includePath);
+		const normalized = path.normalize(resolvedPath);
+		if (this.visited.has(normalized)) throw new CircularIncludeError([...this.visited, normalized]);
+		if (this.depth >= MAX_INCLUDE_DEPTH) throw new ConfigIncludeError(`Maximum include depth (${MAX_INCLUDE_DEPTH}) exceeded at: ${includePath}`, includePath);
+		let raw;
+		try {
+			raw = this.resolver.readFile(normalized);
+		} catch (err) {
+			throw new ConfigIncludeError(`Failed to read include file: ${includePath} (resolved: ${normalized})`, includePath, err instanceof Error ? err : void 0);
+		}
+		let parsed;
+		try {
+			parsed = this.resolver.parseJson(raw);
+		} catch (err) {
+			throw new ConfigIncludeError(`Failed to parse include file: ${includePath} (resolved: ${normalized})`, includePath, err instanceof Error ? err : void 0);
+		}
+		const nested = new IncludeProcessor(normalized, this.resolver);
+		nested.visited = new Set([...this.visited, normalized]);
+		nested.depth = this.depth + 1;
+		return nested.process(parsed);
+	}
+};
+const defaultResolver = {
+	readFile: (p) => fs.readFileSync(p, "utf-8"),
+	parseJson: (raw) => JSON5.parse(raw)
+};
+function resolveConfigIncludes(obj, configPath, resolver = defaultResolver) {
+	return new IncludeProcessor(configPath, resolver).process(obj);
+}
+
+//#endregion
+export { resolveConfigIncludes };

package/dist/config/object-utils.js

@@ -0,0 +1,7 @@
+//#region src/config/object-utils.ts
+function isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && Object.prototype.toString.call(value) === "[object Object]";
+}
+
+//#endregion
+export { isPlainObject };

package/dist/config/paths.js

@@ -0,0 +1,38 @@
+import os from "node:os";
+import path from "node:path";
+
+//#region src/config/paths.ts
+const STATE_DIRNAME = ".milady";
+const CONFIG_FILENAME = "milady.json";
+function stateDir(homedir = os.homedir) {
+	return path.join(homedir(), STATE_DIRNAME);
+}
+function resolveUserPath(input) {
+	const trimmed = input.trim();
+	if (!trimmed) return trimmed;
+	if (trimmed.startsWith("~")) {
+		const expanded = trimmed.replace(/^~(?=$|[\\/])/, os.homedir());
+		return path.resolve(expanded);
+	}
+	return path.resolve(trimmed);
+}
+function resolveStateDir(env = process.env, homedir = os.homedir) {
+	const override = env.MILADY_STATE_DIR?.trim();
+	if (override) return resolveUserPath(override);
+	return stateDir(homedir);
+}
+function resolveConfigPath(env = process.env, stateDirPath = resolveStateDir(env, os.homedir)) {
+	const override = env.MILADY_CONFIG_PATH?.trim();
+	if (override) return resolveUserPath(override);
+	return path.join(stateDirPath, CONFIG_FILENAME);
+}
+/**
+* Directory for per-provider model cache files.
+* Each provider gets its own file: `~/.milady/models/<providerId>.json`
+*/
+function resolveModelsCacheDir(env = process.env, stateDirPath = resolveStateDir(env, os.homedir)) {
+	return path.join(stateDirPath, "models");
+}
+
+//#endregion
+export { resolveConfigPath, resolveModelsCacheDir, resolveStateDir, resolveUserPath };

package/dist/config/plugin-auto-enable.js

@@ -0,0 +1,231 @@
+import { SUBSCRIPTION_PROVIDER_MAP } from "../auth/types.js";
+
+//#region src/config/plugin-auto-enable.ts
+const CONNECTOR_PLUGINS = {
+	telegram: "@elizaos/plugin-telegram",
+	discord: "@elizaos/plugin-discord",
+	slack: "@elizaos/plugin-slack",
+	twitter: "@elizaos/plugin-twitter",
+	whatsapp: "@milady/plugin-whatsapp",
+	signal: "@elizaos/plugin-signal",
+	bluebubbles: "@elizaos/plugin-bluebubbles",
+	imessage: "@elizaos/plugin-imessage",
+	farcaster: "@elizaos/plugin-farcaster",
+	lens: "@elizaos/plugin-lens",
+	msteams: "@elizaos/plugin-msteams",
+	mattermost: "@elizaos/plugin-mattermost",
+	googlechat: "@elizaos/plugin-google-chat",
+	feishu: "@elizaos/plugin-feishu",
+	matrix: "@elizaos/plugin-matrix",
+	nostr: "@elizaos/plugin-nostr",
+	retake: "@milady/plugin-retake"
+};
+const PROVIDER_PLUGINS = {
+	"google-antigravity": "@elizaos/plugin-google-antigravity",
+	"google-gemini": "@elizaos/plugin-google-gemini",
+	"vercel-ai-gateway": "@elizaos/plugin-vercel-ai-gateway",
+	openai: "@elizaos/plugin-openai",
+	anthropic: "@elizaos/plugin-anthropic",
+	"pi-ai": "@elizaos/plugin-pi-ai",
+	qwen: "@elizaos/plugin-qwen",
+	minimax: "@elizaos/plugin-minimax",
+	groq: "@elizaos/plugin-groq",
+	xai: "@elizaos/plugin-xai",
+	openrouter: "@elizaos/plugin-openrouter",
+	ollama: "@elizaos/plugin-ollama",
+	zai: "@homunculuslabs/plugin-zai",
+	deepseek: "@elizaos/plugin-deepseek",
+	together: "@elizaos/plugin-together",
+	mistral: "@elizaos/plugin-mistral",
+	cohere: "@elizaos/plugin-cohere",
+	perplexity: "@elizaos/plugin-perplexity"
+};
+const AUTH_PROVIDER_PLUGINS = {
+	ANTHROPIC_API_KEY: "@elizaos/plugin-anthropic",
+	CLAUDE_API_KEY: "@elizaos/plugin-anthropic",
+	OPENAI_API_KEY: "@elizaos/plugin-openai",
+	AI_GATEWAY_API_KEY: "@elizaos/plugin-vercel-ai-gateway",
+	AIGATEWAY_API_KEY: "@elizaos/plugin-vercel-ai-gateway",
+	GOOGLE_API_KEY: "@elizaos/plugin-google-gemini",
+	GOOGLE_GENERATIVE_AI_API_KEY: "@elizaos/plugin-google-gemini",
+	GOOGLE_CLOUD_API_KEY: "@elizaos/plugin-google-antigravity",
+	GROQ_API_KEY: "@elizaos/plugin-groq",
+	XAI_API_KEY: "@elizaos/plugin-xai",
+	GROK_API_KEY: "@elizaos/plugin-xai",
+	OPENROUTER_API_KEY: "@elizaos/plugin-openrouter",
+	OLLAMA_BASE_URL: "@elizaos/plugin-ollama",
+	ZAI_API_KEY: "@homunculuslabs/plugin-zai",
+	DEEPSEEK_API_KEY: "@elizaos/plugin-deepseek",
+	TOGETHER_API_KEY: "@elizaos/plugin-together",
+	MISTRAL_API_KEY: "@elizaos/plugin-mistral",
+	COHERE_API_KEY: "@elizaos/plugin-cohere",
+	PERPLEXITY_API_KEY: "@elizaos/plugin-perplexity",
+	ELIZAOS_CLOUD_API_KEY: "@elizaos/plugin-elizacloud",
+	ELIZAOS_CLOUD_ENABLED: "@elizaos/plugin-elizacloud",
+	MILAIDY_USE_PI_AI: "@elizaos/plugin-pi-ai",
+	CUA_API_KEY: "@elizaos/plugin-cua",
+	CUA_HOST: "@elizaos/plugin-cua",
+	OBSIDIAN_VAULT_PATH: "@elizaos/plugin-obsidian",
+	OBSIDAN_VAULT_PATH: "@elizaos/plugin-obsidian",
+	REPOPROMPT_CLI_PATH: "@elizaos/plugin-repoprompt",
+	CLAUDE_CODE_WORKBENCH_ENABLED: "@milaidy/plugin-claude-code-workbench"
+};
+const FEATURE_PLUGINS = {
+	browser: "@elizaos/plugin-browser",
+	cua: "@elizaos/plugin-cua",
+	obsidian: "@elizaos/plugin-obsidian",
+	cron: "@elizaos/plugin-cron",
+	shell: "@elizaos/plugin-shell",
+	imageGen: "@elizaos/plugin-image-generation",
+	tts: "@elizaos/plugin-tts",
+	stt: "@elizaos/plugin-stt",
+	agentSkills: "@elizaos/plugin-agent-skills",
+	directives: "@elizaos/plugin-directives",
+	commands: "@elizaos/plugin-commands",
+	diagnosticsOtel: "@elizaos/plugin-diagnostics-otel",
+	webhooks: "@elizaos/plugin-webhooks",
+	gmailWatch: "@elizaos/plugin-gmail-watch",
+	personality: "@elizaos/plugin-personality",
+	experience: "@elizaos/plugin-experience",
+	form: "@elizaos/plugin-form",
+	x402: "@elizaos/plugin-x402",
+	fal: "@elizaos/plugin-fal",
+	suno: "@elizaos/plugin-suno",
+	vision: "@elizaos/plugin-vision",
+	computeruse: "@elizaos/plugin-computeruse",
+	repoprompt: "@elizaos/plugin-repoprompt",
+	claudeCodeWorkbench: "@milaidy/plugin-claude-code-workbench"
+};
+function isConnectorConfigured(connectorName, connectorConfig) {
+	if (!connectorConfig || typeof connectorConfig !== "object") return false;
+	const config = connectorConfig;
+	if (config.enabled === false) return false;
+	if (config.botToken || config.token || config.apiKey) return true;
+	if (connectorName === "signal" && typeof config.accounts === "object" && config.accounts !== null && Object.values(config.accounts).some((account) => {
+		if (!account || typeof account !== "object") return false;
+		const accountConfig = account;
+		if (accountConfig.enabled === false) return false;
+		return Boolean(accountConfig.account || accountConfig.httpUrl || accountConfig.httpHost || accountConfig.httpPort || accountConfig.cliPath);
+	})) return true;
+	switch (connectorName) {
+		case "bluebubbles": return Boolean(config.serverUrl && config.password);
+		case "imessage": return Boolean(config.cliPath);
+		case "signal": return Boolean(config.account || config.httpUrl || config.httpHost || config.httpPort || config.cliPath);
+		case "whatsapp": return Boolean(config.authState || config.sessionPath || config.authDir || config.accounts && typeof config.accounts === "object" && Object.values(config.accounts).some((account) => {
+			if (!account || typeof account !== "object") return false;
+			const acc = account;
+			if (acc.enabled === false) return false;
+			return Boolean(acc.authDir);
+		}));
+		case "retake": return Boolean(config.accessToken || config.enabled === true);
+		default: return false;
+	}
+}
+function addToAllowlist(allow, pluginName, shortId, changes, reason) {
+	if (!allow.includes(pluginName) && !allow.includes(shortId)) {
+		allow.push(shortId);
+		changes.push(`Auto-enabled plugin: ${pluginName} (${reason})`);
+	}
+}
+/** Safely extract `agents.defaults.subscriptionProvider` from an untyped config. */
+function getSubscriptionProvider(config) {
+	if (typeof config !== "object" || config === null) return void 0;
+	const agents = config.agents;
+	if (typeof agents !== "object" || agents === null) return void 0;
+	const defaults = agents.defaults;
+	if (typeof defaults !== "object" || defaults === null) return void 0;
+	const provider = defaults.subscriptionProvider;
+	return typeof provider === "string" ? provider : void 0;
+}
+function applyPluginAutoEnable(params) {
+	const { config, env } = params;
+	const changes = [];
+	const updatedConfig = structuredClone(config);
+	if (updatedConfig.plugins?.enabled === false) return {
+		config: updatedConfig,
+		changes
+	};
+	updatedConfig.plugins = updatedConfig.plugins ?? {};
+	const pluginsConfig = updatedConfig.plugins;
+	pluginsConfig.allow = pluginsConfig.allow ?? [];
+	pluginsConfig.entries = pluginsConfig.entries ?? {};
+	const connectors = updatedConfig.connectors ?? updatedConfig.channels;
+	if (connectors) for (const [connectorName, connectorConfig] of Object.entries(connectors)) {
+		const pluginName = CONNECTOR_PLUGINS[connectorName];
+		if (!pluginName) continue;
+		if (!isConnectorConfigured(connectorName, connectorConfig)) continue;
+		if (pluginsConfig.entries[connectorName]?.enabled === false) continue;
+		addToAllowlist(pluginsConfig.allow, pluginName, connectorName, changes, `connector: ${connectorName}`);
+	}
+	if (updatedConfig.auth?.profiles) for (const [profileKey, profile] of Object.entries(updatedConfig.auth.profiles)) {
+		const provider = profile.provider;
+		if (!provider) continue;
+		const pluginName = PROVIDER_PLUGINS[provider];
+		if (!pluginName) continue;
+		addToAllowlist(pluginsConfig.allow, pluginName, provider, changes, `auth profile: ${profileKey}`);
+	}
+	const subscriptionProvider = getSubscriptionProvider(updatedConfig);
+	const subscriptionPluginId = typeof subscriptionProvider === "string" ? SUBSCRIPTION_PROVIDER_MAP[subscriptionProvider] : void 0;
+	if (subscriptionPluginId) {
+		const pluginName = PROVIDER_PLUGINS[subscriptionPluginId];
+		if (pluginName) {
+			pluginsConfig.entries[subscriptionPluginId] = {
+				...pluginsConfig.entries[subscriptionPluginId],
+				enabled: true
+			};
+			addToAllowlist(pluginsConfig.allow, pluginName, subscriptionPluginId, changes, `subscription: ${subscriptionProvider}`);
+		}
+	}
+	for (const [envKey, pluginName] of Object.entries(AUTH_PROVIDER_PLUGINS)) {
+		const envValue = env[envKey];
+		if (!envValue || typeof envValue !== "string" || envValue.trim() === "") continue;
+		const pluginId = pluginName.includes("/plugin-") ? pluginName.slice(pluginName.lastIndexOf("/plugin-") + 8) : pluginName;
+		if (pluginsConfig.entries[pluginId]?.enabled === false) continue;
+		addToAllowlist(pluginsConfig.allow, pluginName, pluginId, changes, `env: ${envKey}`);
+	}
+	if (updatedConfig.features) for (const [featureName, featureConfig] of Object.entries(updatedConfig.features)) {
+		const pluginName = FEATURE_PLUGINS[featureName];
+		if (!pluginName) continue;
+		if (!(featureConfig === true || typeof featureConfig === "object" && featureConfig !== null && featureConfig.enabled !== false)) continue;
+		const pluginId = pluginName.includes("/plugin-") ? pluginName.slice(pluginName.lastIndexOf("/plugin-") + 8) : pluginName;
+		if (pluginsConfig.entries[pluginId]?.enabled === false) continue;
+		addToAllowlist(pluginsConfig.allow, pluginName, pluginId, changes, `feature: ${featureName}`);
+	}
+	const hooksConfig = updatedConfig.hooks;
+	if (hooksConfig && hooksConfig.enabled !== false && hooksConfig.token) {
+		const webhooksPlugin = FEATURE_PLUGINS.webhooks;
+		if (webhooksPlugin) addToAllowlist(pluginsConfig.allow, webhooksPlugin, webhooksPlugin.replace("@elizaos/plugin-", ""), changes, "hooks.token");
+	}
+	if (hooksConfig) {
+		if (hooksConfig.gmail?.account?.trim()) {
+			const gmailPlugin = FEATURE_PLUGINS.gmailWatch;
+			if (gmailPlugin) addToAllowlist(pluginsConfig.allow, gmailPlugin, gmailPlugin.replace("@elizaos/plugin-", ""), changes, "hooks.gmail.account");
+		}
+	}
+	const mediaConfig = updatedConfig.media;
+	if (mediaConfig) {
+		if (mediaConfig.image?.enabled !== false && mediaConfig.image?.mode === "own-key" && mediaConfig.image?.provider === "fal") {
+			const falPlugin = FEATURE_PLUGINS.fal;
+			if (falPlugin) addToAllowlist(pluginsConfig.allow, falPlugin, "fal", changes, "media.image.provider=fal");
+		}
+		if (mediaConfig.video?.enabled !== false && mediaConfig.video?.mode === "own-key" && mediaConfig.video?.provider === "fal") {
+			const falPlugin = FEATURE_PLUGINS.fal;
+			if (falPlugin) addToAllowlist(pluginsConfig.allow, falPlugin, "fal", changes, "media.video.provider=fal");
+		}
+		if (mediaConfig.audio?.enabled !== false && mediaConfig.audio?.mode === "own-key" && mediaConfig.audio?.provider === "suno") {
+			const sunoPlugin = FEATURE_PLUGINS.suno;
+			if (sunoPlugin) addToAllowlist(pluginsConfig.allow, sunoPlugin, "suno", changes, "media.audio.provider=suno");
+		}
+		if (mediaConfig.vision?.enabled !== false && mediaConfig.vision?.provider) {
+			const visionPlugin = FEATURE_PLUGINS.vision;
+			if (visionPlugin) addToAllowlist(pluginsConfig.allow, visionPlugin, "vision", changes, `media.vision.provider=${mediaConfig.vision.provider}`);
+		}
+	}
+	return {
+		config: updatedConfig,
+		changes
+	};
+}
+
+//#endregion
+export { applyPluginAutoEnable };