miladyai 2.0.0-alpha.27

package/dist/cli/program/build-program.js

@@ -0,0 +1,17 @@
+import { CLI_VERSION } from "../version.js";
+import { registerProgramCommands } from "./command-registry.js";
+import { configureProgramHelp } from "./help.js";
+import { registerPreActionHooks } from "./preaction.js";
+import { Command } from "commander";
+
+//#region src/cli/program/build-program.ts
+function buildProgram() {
+	const program = new Command();
+	configureProgramHelp(program, CLI_VERSION);
+	registerPreActionHooks(program, CLI_VERSION);
+	registerProgramCommands(program);
+	return program;
+}
+
+//#endregion
+export { buildProgram };

package/dist/cli/program/command-registry.js

@@ -0,0 +1,23 @@
+import { registerConfigCli } from "./register.config.js";
+import { registerConfigureCommand } from "./register.configure.js";
+import { registerDashboardCommand } from "./register.dashboard.js";
+import { registerSetupCommand } from "./register.setup.js";
+import { registerStartCommand } from "./register.start.js";
+import { registerSubCliCommands } from "./register.subclis.js";
+import { registerTuiCommand } from "./register.tui.js";
+import { registerUpdateCommand } from "./register.update.js";
+
+//#region src/cli/program/command-registry.ts
+function registerProgramCommands(program, argv = process.argv) {
+	registerStartCommand(program);
+	registerTuiCommand(program);
+	registerSetupCommand(program);
+	registerConfigureCommand(program);
+	registerConfigCli(program);
+	registerDashboardCommand(program);
+	registerUpdateCommand(program);
+	registerSubCliCommands(program, argv);
+}
+
+//#endregion
+export { registerProgramCommands };

package/dist/cli/program/help.js

@@ -0,0 +1,47 @@
+import { isRich, theme } from "../../terminal/theme.js";
+import { formatDocsLink } from "../../terminal/links.js";
+import { formatCliBannerLine, hasEmittedCliBanner } from "../banner.js";
+import { replaceCliName, resolveCliName } from "../cli-name.js";
+
+//#region src/cli/program/help.ts
+const CLI_NAME = resolveCliName();
+const EXAMPLES = [
+	["milady", "Start Milady in the interactive TUI."],
+	["milady start", "Start the classic runtime/chat loop."],
+	["milady dashboard", "Open the Control UI in your browser."],
+	["milady setup", "Initialize ~/.milady/milady.json and the agent workspace."],
+	["milady config get agents.defaults.model.primary", "Read a config value."],
+	["milady models", "Show configured model providers."],
+	["milady plugins list", "List available plugins."],
+	["milady update", "Check for and install the latest version."],
+	["milady update channel beta", "Switch to the beta release channel."]
+];
+function configureProgramHelp(program, programVersion) {
+	program.name(CLI_NAME).description("").version(programVersion, "-v, --version").option("--verbose", "Enable informational runtime logs").option("--debug", "Enable debug-level runtime logs").option("--dev", "Dev profile: isolate state under ~/.milady-dev with separate config and ports").option("--profile <name>", "Use a named profile (isolates MILADY_STATE_DIR/MILADY_CONFIG_PATH under ~/.milady-<name>)");
+	program.option("--no-color", "Disable ANSI colors", false);
+	program.configureHelp({
+		optionTerm: (option) => theme.option(option.flags),
+		subcommandTerm: (cmd) => theme.command(cmd.name())
+	});
+	program.configureOutput({
+		writeOut: (str) => {
+			const colored = str.replace(/^Usage:/gm, theme.heading("Usage:")).replace(/^Options:/gm, theme.heading("Options:")).replace(/^Commands:/gm, theme.heading("Commands:"));
+			process.stdout.write(colored);
+		},
+		writeErr: (str) => process.stderr.write(str),
+		outputError: (str, write) => write(theme.error(str))
+	});
+	program.addHelpText("beforeAll", () => {
+		if (hasEmittedCliBanner()) return "";
+		return `\n${formatCliBannerLine(programVersion, { richTty: isRich() })}\n`;
+	});
+	const fmtExamples = EXAMPLES.map(([cmd, desc]) => `  ${theme.command(replaceCliName(cmd, CLI_NAME))}\n    ${theme.muted(desc)}`).join("\n");
+	program.addHelpText("afterAll", ({ command }) => {
+		if (command !== program) return "";
+		const docs = formatDocsLink("/cli", "docs.milady.ai/cli");
+		return `\n${theme.heading("Examples:")}\n${fmtExamples}\n\n${theme.muted("Docs:")} ${docs}\n`;
+	});
+}
+
+//#endregion
+export { configureProgramHelp };

package/dist/cli/program/preaction.js

@@ -0,0 +1,33 @@
+import { isTruthyEnvValue, setVerbose } from "../../utils/globals.js";
+import { getCommandPath, getVerboseFlag, hasHelpOrVersion } from "../argv.js";
+import { emitCliBanner } from "../banner.js";
+import { resolveCliName } from "../cli-name.js";
+
+//#region src/cli/program/preaction.ts
+function setProcessTitleForCommand(actionCommand) {
+	let current = actionCommand;
+	while (current.parent?.parent) current = current.parent;
+	const name = current.name();
+	const cliName = resolveCliName();
+	if (!name || name === cliName) return;
+	process.title = `${cliName}-${name}`;
+}
+function registerPreActionHooks(program, programVersion) {
+	program.hook("preAction", async (_thisCommand, actionCommand) => {
+		setProcessTitleForCommand(actionCommand);
+		const argv = process.argv;
+		if (hasHelpOrVersion(argv)) return;
+		const commandPath = getCommandPath(argv, 2);
+		if (!(isTruthyEnvValue(process.env.MILADY_HIDE_BANNER) || commandPath[0] === "update" || commandPath[0] === "completion")) {
+			emitCliBanner(programVersion);
+			const { scheduleUpdateNotification } = await import("../../services/update-notifier.js");
+			scheduleUpdateNotification();
+		}
+		const verbose = getVerboseFlag(argv, { includeDebug: true });
+		setVerbose(verbose);
+		if (!verbose) process.env.NODE_NO_WARNINGS ??= "1";
+	});
+}
+
+//#endregion
+export { registerPreActionHooks };

package/dist/cli/program/register.config.js

@@ -0,0 +1,106 @@
+import { theme } from "../../terminal/theme.js";
+
+//#region src/cli/program/register.config.ts
+function registerConfigCli(program) {
+	const config = program.command("config").description("Config helpers (get/path)");
+	config.command("get <key>").description("Get a config value").action(async (key) => {
+		const { loadMiladyConfig } = await import("../../config/config.js");
+		let miladyConfig;
+		try {
+			miladyConfig = loadMiladyConfig();
+		} catch (err) {
+			const detail = err instanceof Error ? err.message : String(err);
+			console.error(`[milady] Could not load config: ${detail}`);
+			process.exit(1);
+		}
+		const parts = key.split(".");
+		let value = miladyConfig;
+		for (const part of parts) if (value && typeof value === "object") value = value[part];
+		else {
+			value = void 0;
+			break;
+		}
+		if (value === void 0) console.log(`${theme.muted("(not set)")}`);
+		else console.log(typeof value === "object" ? JSON.stringify(value, null, 2) : String(value));
+	});
+	config.command("path").description("Print the resolved config file path").action(async () => {
+		const { resolveConfigPath } = await import("../../config/paths.js");
+		console.log(resolveConfigPath());
+	});
+	config.command("show").description("Display all configuration values grouped by section").option("-a, --all", "Include advanced/hidden fields").option("--json", "Output as raw JSON").action(async (opts) => {
+		const { loadMiladyConfig } = await import("../../config/config.js");
+		const { buildConfigSchema } = await import("../../config/schema.js");
+		let config;
+		try {
+			config = loadMiladyConfig();
+		} catch (err) {
+			console.error(theme.error(`Could not load config: ${err instanceof Error ? err.message : String(err)}`));
+			process.exit(1);
+		}
+		if (opts.json) {
+			console.log(JSON.stringify(config, null, 2));
+			return;
+		}
+		const { uiHints } = buildConfigSchema();
+		displayConfig(config, uiHints, { showAdvanced: !!opts.all });
+	});
+}
+/**
+* Flatten a nested object to dot-notation keys.
+*/
+function flattenConfig(obj, prefix = "") {
+	const result = {};
+	if (obj === null || typeof obj !== "object") return { [prefix]: obj };
+	for (const [key, value] of Object.entries(obj)) {
+		const path = prefix ? `${prefix}.${key}` : key;
+		if (value !== null && typeof value === "object" && !Array.isArray(value)) Object.assign(result, flattenConfig(value, path));
+		else result[path] = value;
+	}
+	return result;
+}
+/**
+* Infer a group name from a key path (e.g., "gateway.auth.token" → "Gateway").
+*/
+function inferGroup(key) {
+	const segments = key.split(".");
+	if (segments.length === 0) return "General";
+	const first = segments[0];
+	return first.charAt(0).toUpperCase() + first.slice(1);
+}
+/**
+* Display config values grouped by section.
+*/
+function displayConfig(config, uiHints, opts) {
+	const flat = flattenConfig(config);
+	const groups = /* @__PURE__ */ new Map();
+	for (const [key, value] of Object.entries(flat)) {
+		const hint = uiHints[key];
+		if (hint?.hidden) continue;
+		if (!opts.showAdvanced && hint?.advanced) continue;
+		const group = hint?.group ?? inferGroup(key);
+		if (!groups.has(group)) groups.set(group, []);
+		groups.get(group)?.push([key, value]);
+	}
+	const sortedGroups = Array.from(groups.entries()).sort((a, b) => a[0].localeCompare(b[0]));
+	for (const [groupName, fields] of sortedGroups) {
+		console.log(`\n${theme.heading(groupName)}`);
+		for (const [key, value] of fields) {
+			const hint = uiHints[key];
+			const label = hint?.label ?? key;
+			const isSensitive = hint?.sensitive ?? false;
+			const isSet = value !== void 0 && value !== null && value !== "";
+			let displayValue;
+			if (!isSet) displayValue = theme.muted("(not set)");
+			else if (isSensitive) displayValue = theme.muted("●●●●●●●●");
+			else if (typeof value === "object") displayValue = JSON.stringify(value);
+			else displayValue = String(value);
+			const help = hint?.help ? `  ${theme.muted(`(${hint.help})`)}` : "";
+			const paddedLabel = label.padEnd(24);
+			console.log(`  ${theme.accent(paddedLabel)} ${displayValue}${help}`);
+		}
+	}
+	console.log();
+}
+
+//#endregion
+export { registerConfigCli };

package/dist/cli/program/register.configure.js

@@ -0,0 +1,20 @@
+import { theme } from "../../terminal/theme.js";
+import { formatDocsLink } from "../../terminal/links.js";
+
+//#region src/cli/program/register.configure.ts
+function registerConfigureCommand(program) {
+	program.command("configure").description("Configuration guidance").addHelpText("after", () => `\n${theme.muted("Docs:")} ${formatDocsLink("/configuration", "docs.milady.ai/configuration")}\n`).action(() => {
+		console.log(`\n${theme.heading("Milady Configuration")}\n`);
+		console.log("Set values with:");
+		console.log(`  ${theme.command("milady config get <key>")}     Read a config value`);
+		console.log(`  Edit ~/.milady/milady.json directly for full control.\n`);
+		console.log("Common environment variables:");
+		console.log(`  ${theme.command("ANTHROPIC_API_KEY")}    Anthropic (Claude)`);
+		console.log(`  ${theme.command("OPENAI_API_KEY")}       OpenAI (GPT)`);
+		console.log(`  ${theme.command("AI_GATEWAY_API_KEY")}   Vercel AI Gateway`);
+		console.log(`  ${theme.command("GEMINI_API_KEY")}       Google (Gemini)\n`);
+	});
+}
+
+//#endregion
+export { registerConfigureCommand };

package/dist/cli/program/register.dashboard.js

@@ -0,0 +1,124 @@
+import { theme } from "../../terminal/theme.js";
+
+//#region src/cli/program/register.dashboard.ts
+async function isPortListening(port, host = "127.0.0.1", timeoutMs = 800) {
+	const net = await import("node:net");
+	return new Promise((resolve) => {
+		const socket = new net.Socket();
+		socket.setTimeout(timeoutMs);
+		socket.once("connect", () => {
+			socket.destroy();
+			resolve(true);
+		});
+		socket.once("timeout", () => {
+			socket.destroy();
+			resolve(false);
+		});
+		socket.once("error", () => {
+			socket.destroy();
+			resolve(false);
+		});
+		socket.connect(port, host);
+	});
+}
+async function openInBrowser(url) {
+	const { spawn } = await import("node:child_process");
+	const isWin = process.platform === "win32";
+	const child = spawn(process.platform === "darwin" ? "open" : isWin ? "cmd" : "xdg-open", isWin ? [
+		"/c",
+		"start",
+		"",
+		url
+	] : [url], { stdio: "ignore" });
+	child.on("error", () => {
+		console.log(theme.warn("Could not open browser automatically."));
+		console.log(`${theme.muted("Open manually:")} ${url}`);
+	});
+	child.unref();
+}
+const DEFAULT_PORT = 2138;
+const APP_DEV_PORT = 2138;
+function registerDashboardCommand(program) {
+	program.command("dashboard").description("Open the Control UI in your browser").option("--port <port>", "Server port to check", String(DEFAULT_PORT)).option("--url <url>", "Server URL (overrides --port)").action(async (opts) => {
+		const rawPort = Number(opts.port ?? DEFAULT_PORT);
+		const port = Number.isFinite(rawPort) && rawPort > 0 && rawPort <= 65535 ? rawPort : DEFAULT_PORT;
+		if (opts.url) {
+			console.log(`${theme.muted("→")} Opening Control UI: ${opts.url}`);
+			openInBrowser(opts.url);
+			return;
+		}
+		if (await isPortListening(port)) {
+			const url = `http://localhost:${port}`;
+			console.log(`${theme.muted("→")} Opening Control UI: ${url}`);
+			openInBrowser(url);
+			return;
+		}
+		if (await isPortListening(APP_DEV_PORT)) {
+			const url = `http://localhost:${APP_DEV_PORT}`;
+			console.log(`${theme.muted("→")} Opening Control UI (dev server): ${url}`);
+			openInBrowser(url);
+			return;
+		}
+		console.log(`${theme.muted("→")} Server not running on port ${port}; starting app dev server…`);
+		const path = await import("node:path");
+		const fs = await import("node:fs");
+		const { resolveMiladyPackageRootSync } = await import("../../utils/milady-root.js");
+		const pkgRoot = resolveMiladyPackageRootSync({
+			cwd: process.cwd(),
+			argv1: process.argv[1],
+			moduleUrl: import.meta.url
+		});
+		if (!pkgRoot) {
+			console.log(theme.error("Could not locate milady package root."));
+			process.exitCode = 1;
+			return;
+		}
+		const appDir = path.join(pkgRoot, "apps", "app");
+		if (!fs.existsSync(path.join(appDir, "package.json"))) {
+			console.log(theme.error("App UI is not available in this installation."));
+			console.log(theme.muted("The app dev server requires a development checkout."));
+			console.log(theme.muted("Start the agent with `milady start` and use the API at http://localhost:31337"));
+			process.exitCode = 1;
+			return;
+		}
+		const { spawn } = await import("node:child_process");
+		const child = spawn("npx", ["vite"], {
+			cwd: appDir,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			],
+			env: { ...process.env }
+		});
+		let opened = false;
+		const tryOpen = () => {
+			if (opened) return;
+			opened = true;
+			const devUrl = `http://localhost:${APP_DEV_PORT}`;
+			console.log(`${theme.muted("→")} Opening Control UI: ${devUrl}`);
+			openInBrowser(devUrl);
+		};
+		child.stdout?.on("data", (chunk) => {
+			const text = chunk.toString();
+			process.stdout.write(text);
+			if (!opened && text.includes("Local:")) tryOpen();
+		});
+		child.stderr?.on("data", (chunk) => {
+			process.stderr.write(chunk.toString());
+		});
+		child.on("error", (err) => {
+			console.log(theme.error(`Failed to start app dev server: ${err.message}`));
+			process.exitCode = 1;
+		});
+		setTimeout(tryOpen, 1e4);
+		const cleanup = () => {
+			child.kill("SIGTERM");
+		};
+		process.on("SIGINT", cleanup);
+		process.on("SIGTERM", cleanup);
+	});
+}
+
+//#endregion
+export { registerDashboardCommand };

package/dist/cli/program/register.models.js

@@ -0,0 +1,23 @@
+//#region src/cli/program/register.models.ts
+function registerModelsCli(program) {
+	program.command("models").description("Show configured model providers").action(() => {
+		const envKeys = [
+			["ANTHROPIC_API_KEY", "Anthropic (Claude)"],
+			["OPENAI_API_KEY", "OpenAI (GPT)"],
+			["AI_GATEWAY_API_KEY", "Vercel AI Gateway"],
+			["GEMINI_API_KEY", "Google (Gemini)"],
+			["GROQ_API_KEY", "Groq"],
+			["XAI_API_KEY", "xAI (Grok)"],
+			["OPENROUTER_API_KEY", "OpenRouter"],
+			["OLLAMA_BASE_URL", "Ollama (local)"]
+		];
+		console.log("[milady] Model providers:");
+		for (const [key, name] of envKeys) {
+			const status = process.env[key] ? "configured" : "not set";
+			console.log(`  ${name}: ${status}`);
+		}
+	});
+}
+
+//#endregion
+export { registerModelsCli };

package/dist/cli/program/register.setup.js

@@ -0,0 +1,36 @@
+import { theme } from "../../terminal/theme.js";
+import { formatDocsLink } from "../../terminal/links.js";
+import { runCommandWithRuntime } from "../cli-utils.js";
+
+//#region src/cli/program/register.setup.ts
+const defaultRuntime = {
+	error: console.error,
+	exit: process.exit
+};
+function registerSetupCommand(program) {
+	program.command("setup").description("Initialize ~/.milady/milady.json and the agent workspace").addHelpText("after", () => `\n${theme.muted("Docs:")} ${formatDocsLink("/getting-started/setup", "docs.milady.ai/getting-started/setup")}\n`).option("--workspace <dir>", "Agent workspace directory").action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const { loadMiladyConfig } = await import("../../config/config.js");
+			const { ensureAgentWorkspace, resolveDefaultAgentWorkspaceDir } = await import("../../providers/workspace.js");
+			let config = {};
+			try {
+				config = loadMiladyConfig();
+				console.log(`${theme.success("✓")} Config loaded`);
+			} catch (err) {
+				if (err.code === "ENOENT") console.log(`${theme.muted("→")} No config found, using defaults`);
+				else throw err;
+			}
+			const agents = config.agents;
+			const workspaceDir = opts.workspace ?? agents?.defaults?.workspace ?? resolveDefaultAgentWorkspaceDir();
+			await ensureAgentWorkspace({
+				dir: workspaceDir,
+				ensureBootstrapFiles: true
+			});
+			console.log(`${theme.success("✓")} Agent workspace ready: ${workspaceDir}`);
+			console.log(`\n${theme.success("Setup complete.")}`);
+		});
+	});
+}
+
+//#endregion
+export { registerSetupCommand };

package/dist/cli/program/register.start.js

@@ -0,0 +1,22 @@
+import { theme } from "../../terminal/theme.js";
+import { formatDocsLink } from "../../terminal/links.js";
+import { runCommandWithRuntime } from "../cli-utils.js";
+
+//#region src/cli/program/register.start.ts
+const defaultRuntime = {
+	error: console.error,
+	exit: process.exit
+};
+async function startAction() {
+	await runCommandWithRuntime(defaultRuntime, async () => {
+		const { startEliza } = await import("../../runtime/eliza.js");
+		await startEliza({ serverOnly: true });
+	});
+}
+function registerStartCommand(program) {
+	program.command("start").description("Start the ElizaOS agent runtime").addHelpText("after", () => `\n${theme.muted("Docs:")} ${formatDocsLink("/getting-started", "docs.milady.ai/getting-started")}\n`).action(startAction);
+	program.command("run").description("Alias for start").action(startAction);
+}
+
+//#endregion
+export { registerStartCommand };

package/dist/cli/program/register.subclis.js

@@ -0,0 +1,70 @@
+import { isTruthyEnvValue } from "../../utils/globals.js";
+import { buildParseArgv, getPrimaryCommand, hasHelpOrVersion } from "../argv.js";
+
+//#region src/cli/program/register.subclis.ts
+function resolveActionArgs(command) {
+	return command?.args ?? [];
+}
+const entries = [{
+	name: "plugins",
+	description: "Plugin management (ElizaOS plugins)",
+	register: async (program) => {
+		(await import("../plugins-cli.js")).registerPluginsCli(program);
+	}
+}, {
+	name: "models",
+	description: "Model configuration",
+	register: async (program) => {
+		(await import("./register.models.js")).registerModelsCli(program);
+	}
+}];
+function removeCommand(program, command) {
+	const commands = program.commands;
+	const index = commands.indexOf(command);
+	if (index >= 0) commands.splice(index, 1);
+}
+async function registerSubCliByName(program, name) {
+	const entry = entries.find((e) => e.name === name);
+	if (!entry) return false;
+	const existing = program.commands.find((cmd) => cmd.name() === entry.name);
+	if (existing) removeCommand(program, existing);
+	await entry.register(program);
+	return true;
+}
+function registerLazyCommand(program, entry) {
+	const placeholder = program.command(entry.name).description(entry.description);
+	placeholder.allowUnknownOption(true);
+	placeholder.allowExcessArguments(true);
+	placeholder.action(async (...actionArgs) => {
+		removeCommand(program, placeholder);
+		await entry.register(program);
+		const actionCommand = actionArgs.at(-1);
+		const rawArgs = (actionCommand?.parent ?? program).rawArgs;
+		const actionArgsList = resolveActionArgs(actionCommand);
+		const fallbackArgv = actionCommand?.name() ? [actionCommand.name(), ...actionArgsList] : actionArgsList;
+		const parseArgv = buildParseArgv({
+			programName: program.name(),
+			rawArgs,
+			fallbackArgv
+		});
+		await program.parseAsync(parseArgv);
+	});
+}
+function registerSubCliCommands(program, argv = process.argv) {
+	if (isTruthyEnvValue(process.env.MILADY_DISABLE_LAZY_SUBCOMMANDS)) {
+		for (const entry of entries) entry.register(program);
+		return;
+	}
+	if (!hasHelpOrVersion(argv)) {
+		const primary = getPrimaryCommand(argv);
+		const entry = primary ? entries.find((e) => e.name === primary) : void 0;
+		if (entry) {
+			registerLazyCommand(program, entry);
+			return;
+		}
+	}
+	for (const entry of entries) registerLazyCommand(program, entry);
+}
+
+//#endregion
+export { registerSubCliByName, registerSubCliCommands };