miladyai 2.0.0-alpha.27

package/dist/cloud-routes.js

@@ -0,0 +1,330 @@
+import { saveMiladyConfig } from "./config/config.js";
+import { createIntegrationTelemetrySpan } from "./diagnostics/integration-observability.js";
+import { readJsonBody as readJsonBody$1, sendJson, sendJsonError } from "./http-helpers.js";
+import { validateCloudBaseUrl } from "./cloud/validate-url.js";
+import { logger } from "@elizaos/core";
+
+//#region src/api/cloud-routes.ts
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+function extractAgentId(pathname) {
+	const id = pathname.split("/")[4];
+	return id && UUID_RE.test(id) ? id : null;
+}
+/**
+* Read and parse a JSON request body with size limits and error handling.
+* Returns null (and sends a 4xx response) if reading or parsing fails.
+*/
+async function readJsonBody(req, res) {
+	return readJsonBody$1(req, res, {
+		maxBytes: 1048576,
+		tooLargeMessage: "Request body too large",
+		destroyOnTooLarge: true
+	});
+}
+const CLOUD_LOGIN_CREATE_TIMEOUT_MS = 1e4;
+const CLOUD_LOGIN_POLL_TIMEOUT_MS = 1e4;
+function isRedirectResponse(response) {
+	return response.status >= 300 && response.status < 400;
+}
+function isTimeoutError(error) {
+	if (!(error instanceof Error)) return false;
+	if (error.name === "TimeoutError" || error.name === "AbortError") return true;
+	const message = error.message.toLowerCase();
+	return message.includes("timed out") || message.includes("timeout");
+}
+async function fetchWithTimeout(input, init, timeoutMs) {
+	return fetch(input, {
+		...init,
+		redirect: "manual",
+		signal: AbortSignal.timeout(timeoutMs)
+	});
+}
+/**
+* Returns true if the request was handled, false if path didn't match.
+*/
+async function handleCloudRoute(req, res, pathname, method, state) {
+	if (method === "POST" && pathname === "/api/cloud/login") {
+		const baseUrl = state.config.cloud?.baseUrl ?? "https://www.elizacloud.ai";
+		const urlError = await validateCloudBaseUrl(baseUrl);
+		if (urlError) {
+			sendJsonError(res, urlError);
+			return true;
+		}
+		const sessionId = crypto.randomUUID();
+		const loginCreateSpan = createIntegrationTelemetrySpan({
+			boundary: "cloud",
+			operation: "login_create_session",
+			timeoutMs: CLOUD_LOGIN_CREATE_TIMEOUT_MS
+		});
+		let createRes;
+		try {
+			createRes = await fetchWithTimeout(`${baseUrl}/api/auth/cli-session`, {
+				method: "POST",
+				headers: { "Content-Type": "application/json" },
+				body: JSON.stringify({ sessionId })
+			}, CLOUD_LOGIN_CREATE_TIMEOUT_MS);
+		} catch (fetchErr) {
+			if (isTimeoutError(fetchErr)) {
+				loginCreateSpan.failure({
+					error: fetchErr,
+					statusCode: 504
+				});
+				sendJsonError(res, "Eliza Cloud login request timed out", 504);
+				return true;
+			}
+			loginCreateSpan.failure({
+				error: fetchErr,
+				statusCode: 502
+			});
+			sendJsonError(res, "Failed to reach Eliza Cloud", 502);
+			return true;
+		}
+		if (isRedirectResponse(createRes)) {
+			loginCreateSpan.failure({
+				statusCode: createRes.status,
+				errorKind: "redirect_response"
+			});
+			sendJsonError(res, "Eliza Cloud login request was redirected; redirects are not allowed", 502);
+			return true;
+		}
+		if (!createRes.ok) {
+			loginCreateSpan.failure({
+				statusCode: createRes.status,
+				errorKind: "http_error"
+			});
+			sendJsonError(res, "Failed to create auth session with Eliza Cloud", 502);
+			return true;
+		}
+		loginCreateSpan.success({ statusCode: createRes.status });
+		sendJson(res, {
+			ok: true,
+			sessionId,
+			browserUrl: `${baseUrl}/auth/cli-login?session=${encodeURIComponent(sessionId)}`
+		});
+		return true;
+	}
+	if (method === "GET" && pathname.startsWith("/api/cloud/login/status")) {
+		const sessionId = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`).searchParams.get("sessionId");
+		if (!sessionId) {
+			sendJsonError(res, "sessionId query parameter is required");
+			return true;
+		}
+		const baseUrl = state.config.cloud?.baseUrl ?? "https://www.elizacloud.ai";
+		const urlError = await validateCloudBaseUrl(baseUrl);
+		if (urlError) {
+			sendJsonError(res, urlError);
+			return true;
+		}
+		const loginPollSpan = createIntegrationTelemetrySpan({
+			boundary: "cloud",
+			operation: "login_poll_status",
+			timeoutMs: CLOUD_LOGIN_POLL_TIMEOUT_MS
+		});
+		let pollRes;
+		try {
+			pollRes = await fetchWithTimeout(`${baseUrl}/api/auth/cli-session/${encodeURIComponent(sessionId)}`, {}, CLOUD_LOGIN_POLL_TIMEOUT_MS);
+		} catch (fetchErr) {
+			if (isTimeoutError(fetchErr)) {
+				loginPollSpan.failure({
+					error: fetchErr,
+					statusCode: 504
+				});
+				sendJson(res, {
+					status: "error",
+					error: "Eliza Cloud status request timed out"
+				}, 504);
+				return true;
+			}
+			loginPollSpan.failure({
+				error: fetchErr,
+				statusCode: 502
+			});
+			sendJson(res, {
+				status: "error",
+				error: "Failed to reach Eliza Cloud"
+			}, 502);
+			return true;
+		}
+		if (isRedirectResponse(pollRes)) {
+			loginPollSpan.failure({
+				statusCode: pollRes.status,
+				errorKind: "redirect_response"
+			});
+			sendJson(res, {
+				status: "error",
+				error: "Eliza Cloud status request was redirected; redirects are not allowed"
+			}, 502);
+			return true;
+		}
+		if (!pollRes.ok) {
+			loginPollSpan.failure({
+				statusCode: pollRes.status,
+				errorKind: "http_error"
+			});
+			sendJson(res, pollRes.status === 404 ? {
+				status: "expired",
+				error: "Session not found or expired"
+			} : {
+				status: "error",
+				error: `Eliza Cloud returned HTTP ${pollRes.status}`
+			});
+			return true;
+		}
+		let data;
+		try {
+			data = await pollRes.json();
+		} catch (parseErr) {
+			loginPollSpan.failure({
+				error: parseErr,
+				statusCode: pollRes.status
+			});
+			throw parseErr;
+		}
+		loginPollSpan.success({ statusCode: pollRes.status });
+		if (data.status === "authenticated" && data.apiKey) {
+			const cloud = state.config.cloud ?? {};
+			cloud.enabled = true;
+			cloud.apiKey = data.apiKey;
+			state.config.cloud = cloud;
+			try {
+				saveMiladyConfig(state.config);
+				logger.info("[cloud-login] API key saved to config file");
+			} catch (saveErr) {
+				logger.error(`[cloud-login] Failed to save config: ${saveErr instanceof Error ? saveErr.message : saveErr}`);
+			}
+			process.env.ELIZAOS_CLOUD_API_KEY = data.apiKey;
+			process.env.ELIZAOS_CLOUD_ENABLED = "true";
+			if (state.runtime) try {
+				if (!state.runtime.character.secrets) state.runtime.character.secrets = {};
+				const secrets = state.runtime.character.secrets;
+				secrets.ELIZAOS_CLOUD_API_KEY = data.apiKey;
+				secrets.ELIZAOS_CLOUD_ENABLED = "true";
+				await state.runtime.updateAgent(state.runtime.agentId, { secrets: { ...secrets } });
+				logger.info("[cloud-login] API key persisted to agent DB record");
+			} catch (dbErr) {
+				logger.warn(`[cloud-login] DB persistence failed (non-fatal): ${dbErr instanceof Error ? dbErr.message : dbErr}`);
+			}
+			if (state.cloudManager && !state.cloudManager.getClient()) await state.cloudManager.init();
+			sendJson(res, {
+				status: "authenticated",
+				keyPrefix: data.keyPrefix
+			});
+		} else sendJson(res, { status: data.status });
+		return true;
+	}
+	if (method === "GET" && pathname === "/api/cloud/agents") {
+		const client = state.cloudManager?.getClient();
+		if (!client) {
+			sendJsonError(res, "Not connected to Eliza Cloud", 401);
+			return true;
+		}
+		sendJson(res, {
+			ok: true,
+			agents: await client.listAgents()
+		});
+		return true;
+	}
+	if (method === "POST" && pathname === "/api/cloud/agents") {
+		const client = state.cloudManager?.getClient();
+		if (!client) {
+			sendJsonError(res, "Not connected to Eliza Cloud", 401);
+			return true;
+		}
+		const body = await readJsonBody(req, res);
+		if (!body) return true;
+		if (!body.agentName?.trim()) {
+			sendJsonError(res, "agentName is required");
+			return true;
+		}
+		sendJson(res, {
+			ok: true,
+			agent: await client.createAgent({
+				agentName: body.agentName,
+				agentConfig: body.agentConfig,
+				environmentVars: body.environmentVars
+			})
+		}, 201);
+		return true;
+	}
+	if (method === "POST" && pathname.startsWith("/api/cloud/agents/") && pathname.endsWith("/provision")) {
+		const agentId = extractAgentId(pathname);
+		if (!agentId || !state.cloudManager) {
+			sendJsonError(res, "Invalid agent ID or cloud not connected", 400);
+			return true;
+		}
+		sendJson(res, {
+			ok: true,
+			agentId,
+			agentName: (await state.cloudManager.connect(agentId)).agentName,
+			status: state.cloudManager.getStatus()
+		});
+		return true;
+	}
+	if (method === "POST" && pathname.startsWith("/api/cloud/agents/") && pathname.endsWith("/shutdown")) {
+		const agentId = extractAgentId(pathname);
+		if (!agentId || !state.cloudManager) {
+			sendJsonError(res, "Invalid agent ID or cloud not connected", 400);
+			return true;
+		}
+		const client = state.cloudManager.getClient();
+		if (!client) {
+			sendJsonError(res, "Not connected to Eliza Cloud", 401);
+			return true;
+		}
+		if (state.cloudManager.getActiveAgentId() === agentId) await state.cloudManager.disconnect();
+		await client.deleteAgent(agentId);
+		sendJson(res, {
+			ok: true,
+			agentId,
+			status: "stopped"
+		});
+		return true;
+	}
+	if (method === "POST" && pathname.startsWith("/api/cloud/agents/") && pathname.endsWith("/connect")) {
+		const agentId = extractAgentId(pathname);
+		if (!agentId || !state.cloudManager) {
+			sendJsonError(res, "Invalid agent ID or cloud not connected", 400);
+			return true;
+		}
+		if (state.cloudManager.getActiveAgentId()) await state.cloudManager.disconnect();
+		sendJson(res, {
+			ok: true,
+			agentId,
+			agentName: (await state.cloudManager.connect(agentId)).agentName,
+			status: state.cloudManager.getStatus()
+		});
+		return true;
+	}
+	if (method === "POST" && pathname === "/api/cloud/disconnect") {
+		if (state.cloudManager) await state.cloudManager.disconnect();
+		const cloud = state.config.cloud ?? {};
+		cloud.enabled = false;
+		delete cloud.apiKey;
+		state.config.cloud = cloud;
+		try {
+			saveMiladyConfig(state.config);
+		} catch (saveErr) {
+			logger.warn(`[cloud-login] Failed to save cloud disconnect state: ${saveErr instanceof Error ? saveErr.message : saveErr}`);
+		}
+		delete process.env.ELIZAOS_CLOUD_API_KEY;
+		delete process.env.ELIZAOS_CLOUD_ENABLED;
+		if (state.runtime) try {
+			if (!state.runtime.character.secrets) state.runtime.character.secrets = {};
+			const secrets = state.runtime.character.secrets;
+			delete secrets.ELIZAOS_CLOUD_API_KEY;
+			delete secrets.ELIZAOS_CLOUD_ENABLED;
+			await state.runtime.updateAgent(state.runtime.agentId, { secrets: { ...secrets } });
+		} catch (dbErr) {
+			logger.warn(`[cloud-login] Failed to clear cloud secrets from agent DB: ${dbErr instanceof Error ? dbErr.message : dbErr}`);
+		}
+		sendJson(res, {
+			ok: true,
+			status: "disconnected"
+		});
+		return true;
+	}
+	return false;
+}
+
+//#endregion
+export { handleCloudRoute };

package/dist/cloud-status-routes.js

@@ -0,0 +1,155 @@
+import { validateCloudBaseUrl } from "./cloud/validate-url.js";
+import { logger } from "@elizaos/core";
+
+//#region src/api/cloud-status-routes.ts
+const DEFAULT_CLOUD_API_BASE_URL = "https://www.elizacloud.ai/api/v1";
+const CLOUD_BILLING_URL = "https://www.elizacloud.ai/dashboard/settings?tab=billing";
+function resolveCloudApiBaseUrl(rawBaseUrl) {
+	const base = (rawBaseUrl ?? DEFAULT_CLOUD_API_BASE_URL).trim().replace(/\/+$/, "");
+	if (base.endsWith("/api/v1")) return base;
+	return `${base}/api/v1`;
+}
+async function fetchCloudCreditsByApiKey(baseUrl, apiKey) {
+	const response = await fetch(`${baseUrl}/credits/balance`, {
+		headers: {
+			Accept: "application/json",
+			Authorization: `Bearer ${apiKey}`
+		},
+		redirect: "manual",
+		signal: AbortSignal.timeout(1e4)
+	});
+	if (response.status >= 300 && response.status < 400) throw new Error("Cloud credits request was redirected; redirects are not allowed");
+	const creditResponse = await response.json().catch(() => ({}));
+	if (!response.ok) {
+		const message = typeof creditResponse.error === "string" && creditResponse.error.trim() ? creditResponse.error : `HTTP ${response.status}`;
+		throw new Error(message);
+	}
+	const rawBalance = typeof creditResponse.balance === "number" ? creditResponse.balance : typeof creditResponse.data?.balance === "number" ? creditResponse.data.balance : void 0;
+	return typeof rawBalance === "number" ? rawBalance : null;
+}
+async function handleCloudStatusRoutes(ctx) {
+	const { res, method, pathname, config, runtime, json } = ctx;
+	if (method === "GET" && pathname === "/api/cloud/status") {
+		const cloudMode = config.cloud?.enabled;
+		const cloudEnabled = cloudMode === true;
+		const hasApiKey = Boolean(config.cloud?.apiKey?.trim());
+		const effectivelyEnabled = cloudEnabled || cloudMode !== false && hasApiKey;
+		const cloudAuth = runtime ? runtime.getService("CLOUD_AUTH") : null;
+		const authConnected = Boolean(cloudAuth?.isAuthenticated());
+		if (authConnected || hasApiKey) {
+			json(res, {
+				connected: true,
+				enabled: effectivelyEnabled,
+				hasApiKey,
+				userId: authConnected ? cloudAuth?.getUserId?.() : void 0,
+				organizationId: authConnected ? cloudAuth?.getOrganizationId?.() : void 0,
+				topUpUrl: CLOUD_BILLING_URL,
+				reason: authConnected ? void 0 : runtime ? "api_key_present_not_authenticated" : "api_key_present_runtime_not_started"
+			});
+			return true;
+		}
+		if (!runtime) {
+			json(res, {
+				connected: false,
+				enabled: effectivelyEnabled,
+				hasApiKey,
+				reason: "runtime_not_started"
+			});
+			return true;
+		}
+		json(res, {
+			connected: false,
+			enabled: effectivelyEnabled,
+			hasApiKey,
+			reason: "not_authenticated"
+		});
+		return true;
+	}
+	if (method === "GET" && pathname === "/api/cloud/credits") {
+		const cloudAuth = runtime ? runtime.getService("CLOUD_AUTH") : null;
+		const configApiKey = config.cloud?.apiKey?.trim();
+		if (!cloudAuth || !cloudAuth.isAuthenticated()) {
+			if (!configApiKey) {
+				json(res, {
+					balance: null,
+					connected: false
+				});
+				return true;
+			}
+			const resolvedBaseUrl = resolveCloudApiBaseUrl(config.cloud?.baseUrl);
+			const baseUrlRejection = await validateCloudBaseUrl(resolvedBaseUrl);
+			if (baseUrlRejection) {
+				json(res, {
+					balance: null,
+					connected: true,
+					error: baseUrlRejection
+				});
+				return true;
+			}
+			try {
+				const balance = await fetchCloudCreditsByApiKey(resolvedBaseUrl, configApiKey);
+				if (typeof balance !== "number") {
+					json(res, {
+						balance: null,
+						connected: true,
+						error: "unexpected response"
+					});
+					return true;
+				}
+				json(res, {
+					connected: true,
+					balance,
+					low: balance < 2,
+					critical: balance < .5,
+					topUpUrl: CLOUD_BILLING_URL
+				});
+			} catch (err) {
+				const msg = err instanceof Error ? err.message : "cloud API unreachable";
+				logger.debug(`[cloud/credits] Failed to fetch balance via API key: ${msg}`);
+				json(res, {
+					balance: null,
+					connected: true,
+					error: msg
+				});
+			}
+			return true;
+		}
+		let balance;
+		const client = cloudAuth.getClient();
+		try {
+			const creditResponse = await client.get("/credits/balance");
+			const rawBalance = typeof creditResponse?.balance === "number" ? creditResponse.balance : typeof (creditResponse?.data)?.balance === "number" ? creditResponse.data.balance : void 0;
+			if (typeof rawBalance !== "number") {
+				logger.debug(`[cloud/credits] Unexpected response shape: ${JSON.stringify(creditResponse)}`);
+				json(res, {
+					balance: null,
+					connected: true,
+					error: "unexpected response"
+				});
+				return true;
+			}
+			balance = rawBalance;
+		} catch (err) {
+			const msg = err instanceof Error ? err.message : "cloud API unreachable";
+			logger.debug(`[cloud/credits] Failed to fetch balance: ${msg}`);
+			json(res, {
+				balance: null,
+				connected: true,
+				error: msg
+			});
+			return true;
+		}
+		json(res, {
+			connected: true,
+			balance,
+			low: balance < 2,
+			critical: balance < .5,
+			topUpUrl: CLOUD_BILLING_URL
+		});
+		return true;
+	}
+	return false;
+}
+
+//#endregion
+export { handleCloudStatusRoutes };

package/dist/compat-utils.js

@@ -0,0 +1,111 @@
+//#region src/api/compat-utils.ts
+function asRecord(value) {
+	if (!value || typeof value !== "object" || Array.isArray(value)) return null;
+	return value;
+}
+function readString(value) {
+	return typeof value === "string" ? value : "";
+}
+/**
+* Extract a best-effort text string from OpenAI/Anthropic "content" fields.
+* Supports:
+* - string
+* - array of parts: [{ type: "text", text: "..." }, ...]
+* - objects with a `text` string field
+*/
+function extractCompatTextContent(content) {
+	if (typeof content === "string") return content;
+	if (Array.isArray(content)) {
+		const chunks = [];
+		for (const item of content) {
+			const obj = asRecord(item);
+			if (!obj) continue;
+			const type = readString(obj.type);
+			if (type && type !== "text") continue;
+			const text = readString(obj.text);
+			if (text) chunks.push(text);
+		}
+		return chunks.join("");
+	}
+	const obj = asRecord(content);
+	if (obj) return readString(obj.text);
+	return "";
+}
+/**
+* For OpenAI-compatible requests, we intentionally reduce "messages" to:
+* - all system/developer messages (joined)
+* - the last user message
+*
+* This keeps the server-side room memory coherent (so stateless clients that
+* resend full history do not cause runaway duplication).
+*/
+function extractOpenAiSystemAndLastUser(messages) {
+	if (!Array.isArray(messages)) return null;
+	let system = "";
+	let user = "";
+	for (const item of messages) {
+		const msg = asRecord(item);
+		if (!msg) continue;
+		const role = readString(msg.role);
+		const contentText = extractCompatTextContent(msg.content);
+		if (!contentText.trim()) continue;
+		if (role === "system" || role === "developer") {
+			system = system ? `${system}\n\n${contentText.trim()}` : contentText.trim();
+			continue;
+		}
+		if (role === "user") user = contentText.trim();
+	}
+	if (!user) return null;
+	return {
+		system,
+		user
+	};
+}
+function extractAnthropicSystemAndLastUser(args) {
+	if (!Array.isArray(args.messages)) return null;
+	const system = readString(args.system).trim();
+	let user = "";
+	for (const item of args.messages) {
+		const msg = asRecord(item);
+		if (!msg) continue;
+		if (readString(msg.role) !== "user") continue;
+		const contentText = extractCompatTextContent(msg.content);
+		if (!contentText.trim()) continue;
+		user = contentText.trim();
+	}
+	if (!user) return null;
+	return {
+		system,
+		user
+	};
+}
+function readNestedString(obj, key) {
+	const raw = obj[key];
+	if (typeof raw === "string" && raw.trim()) return raw.trim();
+	return null;
+}
+/**
+* Resolve a stable room key for compatibility endpoints so manual testing can
+* keep conversation memory when the client provides an identifier.
+*
+* We accept a few common fields without requiring any one client:
+* - OpenAI: body.user (string)
+* - OpenAI: body.metadata.conversation_id
+* - Anthropic: body.metadata.user_id
+* - Anthropic: body.metadata.conversation_id
+*/
+function resolveCompatRoomKey(body, fallback = "default") {
+	const direct = readNestedString(body, "user");
+	if (direct) return direct;
+	const metadata = asRecord(body.metadata);
+	if (metadata) {
+		const conv = readNestedString(metadata, "conversation_id") ?? readNestedString(metadata, "conversationId");
+		if (conv) return conv;
+		const userId = readNestedString(metadata, "user_id");
+		if (userId) return userId;
+	}
+	return fallback;
+}
+
+//#endregion
+export { extractAnthropicSystemAndLastUser, extractCompatTextContent, extractOpenAiSystemAndLastUser, resolveCompatRoomKey };

package/dist/config/config.js

@@ -0,0 +1,69 @@
+import { resolveConfigPath, resolveUserPath } from "./paths.js";
+import { collectConfigEnvVars } from "./env-vars.js";
+import { resolveConfigIncludes } from "./includes.js";
+import path from "node:path";
+import fs from "node:fs";
+import JSON5 from "json5";
+
+//#region src/config/config.ts
+function loadMiladyConfig() {
+	const configPath = resolveConfigPath();
+	let raw;
+	try {
+		raw = fs.readFileSync(configPath, "utf-8");
+	} catch (err) {
+		if (err.code === "ENOENT") return { logging: { level: "error" } };
+		throw err;
+	}
+	const resolved = resolveConfigIncludes(JSON5.parse(raw), configPath);
+	const skillsJsonPath = resolveUserPath("~/.eliza/skills.json");
+	if (!fs.existsSync(skillsJsonPath)) try {
+		const skillsDir = path.dirname(skillsJsonPath);
+		if (!fs.existsSync(skillsDir)) fs.mkdirSync(skillsDir, { recursive: true });
+		fs.writeFileSync(skillsJsonPath, JSON.stringify({ extraDirs: [] }, null, 2), "utf-8");
+	} catch (err) {
+		console.warn(`[milady] Failed to auto-create ~/.eliza/skills.json: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	if (fs.existsSync(skillsJsonPath)) try {
+		const skillsRaw = fs.readFileSync(skillsJsonPath, "utf-8");
+		const skillsConfig = JSON5.parse(skillsRaw);
+		if (skillsConfig.extraDirs && Array.isArray(skillsConfig.extraDirs) && skillsConfig.extraDirs.length > 0) {
+			if (!resolved.skills) resolved.skills = {};
+			if (!resolved.skills.load) resolved.skills.load = {};
+			if (!resolved.skills.load.extraDirs) resolved.skills.load.extraDirs = [];
+			const existing = new Set(resolved.skills.load.extraDirs);
+			for (const dir of skillsConfig.extraDirs) {
+				const loadedDir = resolveUserPath(dir);
+				if (!existing.has(loadedDir)) {
+					resolved.skills.load.extraDirs.push(loadedDir);
+					existing.add(loadedDir);
+				}
+			}
+		}
+	} catch (err) {
+		console.warn(`[milady] Failed to load ~/.eliza/skills.json: ${err instanceof Error ? err.message : String(err)}`);
+	}
+	if (!resolved.logging) resolved.logging = { level: "error" };
+	else if (!resolved.logging.level) resolved.logging.level = "error";
+	const envVars = collectConfigEnvVars(resolved);
+	for (const [key, value] of Object.entries(envVars)) if (process.env[key] === void 0) process.env[key] = value;
+	return resolved;
+}
+function saveMiladyConfig(config) {
+	const configPath = resolveConfigPath();
+	const dir = path.dirname(configPath);
+	if (!fs.existsSync(dir)) fs.mkdirSync(dir, {
+		recursive: true,
+		mode: 448
+	});
+	fs.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`, {
+		encoding: "utf-8",
+		mode: 384
+	});
+}
+function configFileExists() {
+	return fs.existsSync(resolveConfigPath());
+}
+
+//#endregion
+export { configFileExists, loadMiladyConfig, saveMiladyConfig };

package/dist/config/env-vars.js

@@ -0,0 +1,19 @@
+//#region src/config/env-vars.ts
+function collectConfigEnvVars(cfg) {
+	const envConfig = cfg?.env;
+	if (!envConfig) return {};
+	const entries = {};
+	if (envConfig.vars) for (const [key, value] of Object.entries(envConfig.vars)) {
+		if (!value) continue;
+		entries[key] = value;
+	}
+	for (const [key, value] of Object.entries(envConfig)) {
+		if (key === "shellEnv" || key === "vars") continue;
+		if (typeof value !== "string" || !value.trim()) continue;
+		entries[key] = value;
+	}
+	return entries;
+}
+
+//#endregion
+export { collectConfigEnvVars };