miladyai 2.0.0-alpha.27

package/dist/subscription-routes.js

@@ -0,0 +1,172 @@
+import { logger } from "@elizaos/core";
+
+//#region src/api/subscription-routes.ts
+async function handleSubscriptionRoutes(ctx) {
+	const { req, res, method, pathname, state, readJsonBody, json, error } = ctx;
+	if (!pathname.startsWith("/api/subscription/")) return false;
+	if (method === "GET" && pathname === "/api/subscription/status") {
+		try {
+			const { getSubscriptionStatus } = await import("./auth/index.js");
+			json(res, { providers: getSubscriptionStatus() });
+		} catch (err) {
+			logger.error(`[api] Failed to get subscription status: ${err instanceof Error ? err.stack : err}`);
+			error(res, "Failed to get subscription status", 500);
+		}
+		return true;
+	}
+	if (method === "POST" && pathname === "/api/subscription/anthropic/start") {
+		try {
+			const { startAnthropicLogin } = await import("./auth/index.js");
+			const flow = await startAnthropicLogin();
+			state._anthropicFlow = flow;
+			json(res, { authUrl: flow.authUrl });
+		} catch (err) {
+			logger.error(`[api] Failed to start Anthropic login: ${err instanceof Error ? err.stack : err}`);
+			error(res, "Failed to start Anthropic login", 500);
+		}
+		return true;
+	}
+	if (method === "POST" && pathname === "/api/subscription/anthropic/exchange") {
+		const body = await readJsonBody(req, res);
+		if (!body) return true;
+		if (!body.code) {
+			error(res, "Missing code", 400);
+			return true;
+		}
+		try {
+			const { saveCredentials, applySubscriptionCredentials } = await import("./auth/index.js");
+			const flow = state._anthropicFlow;
+			if (!flow) {
+				error(res, "No active flow — call /start first", 400);
+				return true;
+			}
+			flow.submitCode(body.code);
+			const credentials = await flow.credentials;
+			saveCredentials("anthropic-subscription", credentials);
+			await applySubscriptionCredentials(state.config);
+			delete state._anthropicFlow;
+			json(res, {
+				success: true,
+				expiresAt: credentials.expires
+			});
+		} catch (err) {
+			logger.error(`[api] Anthropic exchange failed: ${err instanceof Error ? err.stack : err}`);
+			error(res, "Anthropic exchange failed", 500);
+		}
+		return true;
+	}
+	if (method === "POST" && pathname === "/api/subscription/anthropic/setup-token") {
+		const body = await readJsonBody(req, res);
+		if (!body) return true;
+		if (!body.token || !body.token.startsWith("sk-ant-")) {
+			error(res, "Invalid token format — expected sk-ant-oat01-...", 400);
+			return true;
+		}
+		try {
+			process.env.ANTHROPIC_API_KEY = body.token.trim();
+			if (!state.config.env) state.config.env = {};
+			state.config.env.ANTHROPIC_API_KEY = body.token.trim();
+			ctx.saveConfig(state.config);
+			json(res, { success: true });
+		} catch (err) {
+			logger.error(`[api] Failed to save setup token: ${err instanceof Error ? err.stack : err}`);
+			error(res, "Failed to save setup token", 500);
+		}
+		return true;
+	}
+	if (method === "POST" && pathname === "/api/subscription/openai/start") {
+		try {
+			const { startCodexLogin } = await import("./auth/index.js");
+			if (state._codexFlow) try {
+				state._codexFlow.close();
+			} catch (err) {
+				logger.debug(`[api] OAuth flow cleanup failed: ${err instanceof Error ? err.message : err}`);
+			}
+			clearTimeout(state._codexFlowTimer);
+			const flow = await startCodexLogin();
+			state._codexFlow = flow;
+			state._codexFlowTimer = setTimeout(() => {
+				try {
+					flow.close();
+				} catch (err) {
+					logger.debug(`[api] OAuth flow cleanup failed: ${err instanceof Error ? err.message : err}`);
+				}
+				delete state._codexFlow;
+				delete state._codexFlowTimer;
+			}, 600 * 1e3);
+			json(res, {
+				authUrl: flow.authUrl,
+				state: flow.state,
+				instructions: "Open the URL in your browser. After login, if auto-redirect doesn't work, paste the full redirect URL."
+			});
+		} catch (err) {
+			logger.error(`[api] Failed to start OpenAI login: ${err instanceof Error ? err.stack : err}`);
+			error(res, "Failed to start OpenAI login", 500);
+		}
+		return true;
+	}
+	if (method === "POST" && pathname === "/api/subscription/openai/exchange") {
+		const body = await readJsonBody(req, res);
+		if (!body) return true;
+		try {
+			const { saveCredentials, applySubscriptionCredentials } = await import("./auth/index.js");
+			const flow = state._codexFlow;
+			if (!flow) {
+				error(res, "No active flow — call /start first", 400);
+				return true;
+			}
+			if (body.code) flow.submitCode(body.code);
+			else if (!body.waitForCallback) {
+				error(res, "Provide either code or set waitForCallback: true", 400);
+				return true;
+			}
+			let credentials;
+			try {
+				credentials = await flow.credentials;
+			} catch (err) {
+				try {
+					flow.close();
+				} catch (closeErr) {
+					logger.debug(`[api] OAuth flow cleanup failed: ${closeErr instanceof Error ? closeErr.message : closeErr}`);
+				}
+				delete state._codexFlow;
+				clearTimeout(state._codexFlowTimer);
+				delete state._codexFlowTimer;
+				logger.error(`[api] OpenAI exchange failed: ${err instanceof Error ? err.stack : err}`);
+				error(res, "OpenAI exchange failed", 500);
+				return true;
+			}
+			saveCredentials("openai-codex", credentials);
+			await applySubscriptionCredentials(state.config);
+			flow.close();
+			delete state._codexFlow;
+			clearTimeout(state._codexFlowTimer);
+			delete state._codexFlowTimer;
+			json(res, {
+				success: true,
+				expiresAt: credentials.expires
+			});
+		} catch (err) {
+			logger.error(`[api] OpenAI exchange failed: ${err instanceof Error ? err.stack : err}`);
+			error(res, "OpenAI exchange failed", 500);
+		}
+		return true;
+	}
+	if (method === "DELETE" && pathname.startsWith("/api/subscription/")) {
+		const provider = pathname.split("/").pop();
+		if (provider === "anthropic-subscription" || provider === "openai-codex") try {
+			const { deleteCredentials } = await import("./auth/index.js");
+			deleteCredentials(provider);
+			json(res, { success: true });
+		} catch (err) {
+			logger.error(`[api] Failed to delete credentials: ${err instanceof Error ? err.stack : err}`);
+			error(res, "Failed to delete credentials", 500);
+		}
+		else error(res, `Unknown provider: ${provider}`, 400);
+		return true;
+	}
+	return false;
+}
+
+//#endregion
+export { handleSubscriptionRoutes };

package/dist/terminal/links.js

@@ -0,0 +1,19 @@
+//#region src/terminal/links.ts
+const DOCS_ROOT = "https://docs.milady.ai";
+function formatTerminalLink(label, url, opts) {
+	const safeLabel = label.replaceAll("\x1B", "");
+	const safeUrl = url.replaceAll("\x1B", "");
+	if (!(opts?.force ?? Boolean(process.stdout.isTTY))) return opts?.fallback ?? `${safeLabel} (${safeUrl})`;
+	return `\u001b]8;;${safeUrl}\u0007${safeLabel}\u001b]8;;\u0007`;
+}
+function formatDocsLink(path, label, opts) {
+	const trimmed = path.trim();
+	const url = trimmed.startsWith("http") ? trimmed : `${DOCS_ROOT}${trimmed.startsWith("/") ? trimmed : `/${trimmed}`}`;
+	return formatTerminalLink(label ?? url, url, {
+		fallback: opts?.fallback ?? url,
+		force: opts?.force
+	});
+}
+
+//#endregion
+export { formatDocsLink };

package/dist/terminal/palette.js

@@ -0,0 +1,14 @@
+//#region src/terminal/palette.ts
+const CLI_PALETTE = {
+	accent: "#FF5A2D",
+	accentBright: "#FF7A3D",
+	accentDim: "#D14A22",
+	info: "#FF8A5B",
+	success: "#2FBF71",
+	warn: "#FFB020",
+	error: "#E23D2D",
+	muted: "#8B7F77"
+};
+
+//#endregion
+export { CLI_PALETTE };

package/dist/terminal/theme.js

@@ -0,0 +1,25 @@
+import { CLI_PALETTE } from "./palette.js";
+import chalk, { Chalk } from "chalk";
+
+//#region src/terminal/theme.ts
+const hasForceColor = typeof process.env.FORCE_COLOR === "string" && process.env.FORCE_COLOR.trim().length > 0 && process.env.FORCE_COLOR.trim() !== "0";
+const baseChalk = process.env.NO_COLOR !== void 0 && !hasForceColor ? new Chalk({ level: 0 }) : chalk;
+const hex = (value) => baseChalk.hex(value);
+const theme = {
+	accent: hex(CLI_PALETTE.accent),
+	accentBright: hex(CLI_PALETTE.accentBright),
+	accentDim: hex(CLI_PALETTE.accentDim),
+	info: hex(CLI_PALETTE.info),
+	success: hex(CLI_PALETTE.success),
+	warn: hex(CLI_PALETTE.warn),
+	error: hex(CLI_PALETTE.error),
+	muted: hex(CLI_PALETTE.muted),
+	heading: baseChalk.bold.hex(CLI_PALETTE.accent),
+	command: hex(CLI_PALETTE.accentBright),
+	option: hex(CLI_PALETTE.warn)
+};
+const cyberGreen = hex("#00FF41");
+const isRich = () => Boolean(baseChalk.level > 0);
+
+//#endregion
+export { cyberGreen, isRich, theme };

package/dist/terminal-run-limits.js

@@ -0,0 +1,24 @@
+import { parseClampedInteger } from "./utils/number-parsing.js";
+
+//#region src/api/terminal-run-limits.ts
+const TERMINAL_RUN_MAX_CONCURRENT_DEFAULT = 2;
+const TERMINAL_RUN_MAX_CONCURRENT_CAP = 16;
+const TERMINAL_RUN_MAX_DURATION_MS_DEFAULT = 300 * 1e3;
+const TERMINAL_RUN_MAX_DURATION_MS_CAP = 3600 * 1e3;
+function resolveTerminalRunLimits() {
+	return {
+		maxConcurrent: parseClampedInteger(process.env.MILADY_TERMINAL_MAX_CONCURRENT ?? process.env.MILAIDY_TERMINAL_MAX_CONCURRENT, {
+			fallback: TERMINAL_RUN_MAX_CONCURRENT_DEFAULT,
+			min: 1,
+			max: TERMINAL_RUN_MAX_CONCURRENT_CAP
+		}),
+		maxDurationMs: parseClampedInteger(process.env.MILADY_TERMINAL_MAX_DURATION_MS ?? process.env.MILAIDY_TERMINAL_MAX_DURATION_MS, {
+			fallback: TERMINAL_RUN_MAX_DURATION_MS_DEFAULT,
+			min: 1e3,
+			max: TERMINAL_RUN_MAX_DURATION_MS_CAP
+		})
+	};
+}
+
+//#endregion
+export { resolveTerminalRunLimits };

package/dist/training-routes.js

@@ -0,0 +1,158 @@
+import { isLoopbackHost } from "./security/network-policy.js";
+import { parsePositiveInteger } from "./utils/number-parsing.js";
+
+//#region src/api/training-routes.ts
+function resolveOllamaUrlRejection(rawUrl) {
+	const trimmed = rawUrl.trim();
+	if (!trimmed) return null;
+	let parsed;
+	try {
+		parsed = new URL(trimmed);
+	} catch {
+		return "ollamaUrl must be a valid URL";
+	}
+	if (parsed.protocol !== "http:" && parsed.protocol !== "https:") return "ollamaUrl must use http:// or https://";
+	if (!isLoopbackHost(parsed.hostname)) return "ollamaUrl must target a loopback host (localhost, 127.0.0.1, or ::1)";
+	return null;
+}
+async function handleTrainingRoutes(ctx) {
+	const { req, res, method, pathname, runtime, trainingService, json, error, readJsonBody } = ctx;
+	if (!pathname.startsWith("/api/training")) return false;
+	if (method === "GET" && pathname === "/api/training/status") {
+		json(res, {
+			...trainingService.getStatus(),
+			runtimeAvailable: runtime !== null
+		});
+		return true;
+	}
+	if (method === "GET" && pathname === "/api/training/trajectories") {
+		const url = new URL(req.url ?? "/", `http://${req.headers.host ?? "localhost"}`);
+		const limit = parsePositiveInteger(url.searchParams.get("limit"), 100);
+		const offset = Math.max(0, Number(url.searchParams.get("offset") ?? "0"));
+		json(res, await trainingService.listTrajectories({
+			limit,
+			offset
+		}));
+		return true;
+	}
+	const trajectoryMatch = /^\/api\/training\/trajectories\/([^/]+)$/.exec(pathname);
+	if (method === "GET" && trajectoryMatch) {
+		const trajectoryId = decodeURIComponent(trajectoryMatch[1]);
+		const detail = await trainingService.getTrajectoryById(trajectoryId);
+		if (!detail) {
+			error(res, "Trajectory not found", 404);
+			return true;
+		}
+		json(res, { trajectory: detail });
+		return true;
+	}
+	if (method === "GET" && pathname === "/api/training/datasets") {
+		json(res, { datasets: trainingService.listDatasets() });
+		return true;
+	}
+	if (method === "POST" && pathname === "/api/training/datasets/build") {
+		const body = await readJsonBody(req, res);
+		if (!body) return true;
+		json(res, { dataset: await trainingService.buildDataset({
+			limit: body.limit,
+			minLlmCallsPerTrajectory: body.minLlmCallsPerTrajectory
+		}) }, 201);
+		return true;
+	}
+	if (method === "GET" && pathname === "/api/training/jobs") {
+		json(res, { jobs: trainingService.listJobs() });
+		return true;
+	}
+	if (method === "POST" && pathname === "/api/training/jobs") {
+		const body = await readJsonBody(req, res);
+		if (!body) return true;
+		try {
+			json(res, { job: await trainingService.startTrainingJob({
+				datasetId: body.datasetId,
+				maxTrajectories: body.maxTrajectories,
+				backend: body.backend,
+				model: body.model,
+				iterations: body.iterations,
+				batchSize: body.batchSize,
+				learningRate: body.learningRate
+			}) }, 201);
+		} catch (err) {
+			error(res, err instanceof Error ? err.message : String(err), 400);
+		}
+		return true;
+	}
+	const jobMatch = /^\/api\/training\/jobs\/([^/]+)$/.exec(pathname);
+	if (method === "GET" && jobMatch) {
+		const jobId = decodeURIComponent(jobMatch[1]);
+		const job = trainingService.getJob(jobId);
+		if (!job) {
+			error(res, "Training job not found", 404);
+			return true;
+		}
+		json(res, { job });
+		return true;
+	}
+	const cancelMatch = /^\/api\/training\/jobs\/([^/]+)\/cancel$/.exec(pathname);
+	if (method === "POST" && cancelMatch) {
+		const jobId = decodeURIComponent(cancelMatch[1]);
+		try {
+			json(res, { job: await trainingService.cancelJob(jobId) });
+		} catch (err) {
+			error(res, err instanceof Error ? err.message : String(err), 404);
+		}
+		return true;
+	}
+	if (method === "GET" && pathname === "/api/training/models") {
+		json(res, { models: trainingService.listModels() });
+		return true;
+	}
+	const importMatch = /^\/api\/training\/models\/([^/]+)\/import-ollama$/.exec(pathname);
+	if (method === "POST" && importMatch) {
+		const modelId = decodeURIComponent(importMatch[1]);
+		const body = await readJsonBody(req, res);
+		if (!body) return true;
+		if (body.ollamaUrl !== void 0 && typeof body.ollamaUrl !== "string") {
+			error(res, "ollamaUrl must be a string", 400);
+			return true;
+		}
+		if (typeof body.ollamaUrl === "string") {
+			const ollamaUrlRejection = resolveOllamaUrlRejection(body.ollamaUrl);
+			if (ollamaUrlRejection) {
+				error(res, ollamaUrlRejection, 400);
+				return true;
+			}
+		}
+		try {
+			json(res, { model: await trainingService.importModelToOllama(modelId, body) });
+		} catch (err) {
+			error(res, err instanceof Error ? err.message : String(err), 400);
+		}
+		return true;
+	}
+	const activateMatch = /^\/api\/training\/models\/([^/]+)\/activate$/.exec(pathname);
+	if (method === "POST" && activateMatch) {
+		const modelId = decodeURIComponent(activateMatch[1]);
+		const body = await readJsonBody(req, res);
+		if (!body) return true;
+		try {
+			json(res, await trainingService.activateModel(modelId, body.providerModel));
+		} catch (err) {
+			error(res, err instanceof Error ? err.message : String(err), 400);
+		}
+		return true;
+	}
+	const benchmarkMatch = /^\/api\/training\/models\/([^/]+)\/benchmark$/.exec(pathname);
+	if (method === "POST" && benchmarkMatch) {
+		const modelId = decodeURIComponent(benchmarkMatch[1]);
+		try {
+			json(res, await trainingService.benchmarkModel(modelId));
+		} catch (err) {
+			error(res, err instanceof Error ? err.message : String(err), 400);
+		}
+		return true;
+	}
+	return false;
+}
+
+//#endregion
+export { handleTrainingRoutes };