milaidy 1.0.0

package/dist/register.models-BJt9eVgZ.js

@@ -0,0 +1,26 @@
+//#region src/cli/program/register.models.ts
+function registerModelsCli(program) {
+	const models = program.command("models").description("Model configuration");
+	models.command("list").description("List configured model providers").option("--json", "Output JSON").action(async () => {
+		console.log("[milaidy] Model providers:");
+		for (const [key, name] of [
+			["ANTHROPIC_API_KEY", "Anthropic (Claude)"],
+			["OPENAI_API_KEY", "OpenAI (GPT)"],
+			["GOOGLE_API_KEY", "Google (Gemini)"],
+			["GROQ_API_KEY", "Groq"],
+			["XAI_API_KEY", "xAI (Grok)"],
+			["OPENROUTER_API_KEY", "OpenRouter"],
+			["OLLAMA_BASE_URL", "Ollama (local)"]
+		]) {
+			const status = process.env[key] ? "configured" : "not set";
+			console.log(`  ${name}: ${status}`);
+		}
+	});
+	models.command("set-default <model>").description("Set the default model").action(async (model) => {
+		console.log(`[milaidy] Set default model: ${model}`);
+		console.log("[milaidy] Use: milaidy config set agents.defaults.model.primary " + model);
+	});
+}
+
+//#endregion
+export { registerModelsCli };

package/dist/register.nodes-B5xY1s8a.js

@@ -0,0 +1,9 @@
+//#region src/cli/program/register.nodes.ts
+function registerNodesCli(program) {
+	program.command("nodes").description("Node commands").command("list").description("List connected nodes").option("--json", "Output JSON").action(async () => {
+		console.log("[milaidy] Nodes list — not yet fully implemented.");
+	});
+}
+
+//#endregion
+export { registerNodesCli };

package/dist/register.skills-SFQqYIhg.js

@@ -0,0 +1,10 @@
+//#region src/cli/program/register.skills.ts
+function registerSkillsCli(program) {
+	program.command("skills").description("Skills management").command("list").description("List available skills").option("--json", "Output JSON").action(async () => {
+		console.log("[milaidy] Skills management — not yet fully implemented.");
+		console.log("[milaidy] Skills are loaded from the agent workspace directory.");
+	});
+}
+
+//#endregion
+export { registerSkillsCli };

package/dist/register.subclis-uF_AsbWR.js

@@ -0,0 +1,187 @@
+import { t as isTruthyEnvValue } from "./entry.js";
+import { a as hasHelpOrVersion, r as getPrimaryCommand, t as buildParseArgv } from "./argv-CfSowvEA.js";
+import { createRequire } from "node:module";
+
+//#region \0rolldown/runtime.js
+var __defProp = Object.defineProperty;
+var __exportAll = (all, no_symbols) => {
+	let target = {};
+	for (var name in all) {
+		__defProp(target, name, {
+			get: all[name],
+			enumerable: true
+		});
+	}
+	if (!no_symbols) {
+		__defProp(target, Symbol.toStringTag, { value: "Module" });
+	}
+	return target;
+};
+
+//#endregion
+//#region src/cli/program/helpers.ts
+/**
+* Extract the action args from a Commander action callback.
+* Used when re-parsing after lazy-loading a subcommand.
+*/
+function resolveActionArgs(command) {
+	if (!command) return [];
+	return command.args ?? [];
+}
+
+//#endregion
+//#region src/cli/program/register.subclis.ts
+var register_subclis_exports = /* @__PURE__ */ __exportAll({
+	registerSubCliByName: () => registerSubCliByName,
+	registerSubCliCommands: () => registerSubCliCommands
+});
+const shouldRegisterPrimaryOnly = (argv) => {
+	if (isTruthyEnvValue(process.env.MILAIDY_DISABLE_LAZY_SUBCOMMANDS)) return false;
+	if (hasHelpOrVersion(argv)) return false;
+	return true;
+};
+const shouldEagerRegisterSubcommands = (_argv) => {
+	return isTruthyEnvValue(process.env.MILAIDY_DISABLE_LAZY_SUBCOMMANDS);
+};
+/**
+* Sub-CLI entries — lazy-loaded command groups.
+*
+* Each entry registers a top-level command with subcommands.
+* The module is only imported when the command is actually invoked.
+*/
+const entries = [
+	{
+		name: "gateway",
+		description: "Gateway control",
+		register: async (program) => {
+			(await import("./register.gateway-82SLAvw3.js")).registerGatewayCli(program);
+		}
+	},
+	{
+		name: "plugins",
+		description: "Plugin management (ElizaOS plugins)",
+		register: async (program) => {
+			(await import("./plugins-cli-B7kSre2c.js")).registerPluginsCli(program);
+		}
+	},
+	{
+		name: "channels",
+		description: "Channel management",
+		register: async (program) => {
+			(await import("./register.channels-CMYQ6K6Y.js")).registerChannelsCli(program);
+		}
+	},
+	{
+		name: "agents",
+		description: "Manage isolated agents (workspaces + auth + routing)",
+		register: async (program) => {
+			(await import("./register.agents-CPVmSjMG.js")).registerAgentsCli(program);
+		}
+	},
+	{
+		name: "models",
+		description: "Model configuration",
+		register: async (program) => {
+			(await import("./register.models-BJt9eVgZ.js")).registerModelsCli(program);
+		}
+	},
+	{
+		name: "skills",
+		description: "Skills management",
+		register: async (program) => {
+			(await import("./register.skills-SFQqYIhg.js")).registerSkillsCli(program);
+		}
+	},
+	{
+		name: "devices",
+		description: "Device pairing + token management",
+		register: async (program) => {
+			(await import("./register.devices-rU5I5L_y.js")).registerDevicesCli(program);
+		}
+	},
+	{
+		name: "nodes",
+		description: "Node commands",
+		register: async (program) => {
+			(await import("./register.nodes-B5xY1s8a.js")).registerNodesCli(program);
+		}
+	},
+	{
+		name: "hooks",
+		description: "Hooks tooling",
+		register: async (program) => {
+			(await import("./register.hooks-B_XTBEkt.js")).registerHooksCli(program);
+		}
+	},
+	{
+		name: "cron",
+		description: "Cron scheduler",
+		register: async (program) => {
+			(await import("./register.cron-D91lY1_Y.js")).registerCronCli(program);
+		}
+	},
+	{
+		name: "logs",
+		description: "Gateway logs",
+		register: async (program) => {
+			(await import("./register.logs-BgEGcPd8.js")).registerLogsCli(program);
+		}
+	},
+	{
+		name: "browser",
+		description: "Manage Milaidy's dedicated browser (Chrome/Chromium)",
+		register: async (program) => {
+			(await import("./register.browser-B2ooXxNx.js")).registerBrowserCli(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((candidate) => candidate.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 (shouldEagerRegisterSubcommands(argv)) {
+		for (const entry of entries) entry.register(program);
+		return;
+	}
+	const primary = getPrimaryCommand(argv);
+	if (primary && shouldRegisterPrimaryOnly(argv)) {
+		const entry = entries.find((candidate) => candidate.name === primary);
+		if (entry) {
+			registerLazyCommand(program, entry);
+			return;
+		}
+	}
+	for (const candidate of entries) registerLazyCommand(program, candidate);
+}
+
+//#endregion
+export { register_subclis_exports as n, registerSubCliCommands as t };

package/dist/run-main-XODklzS-.js

@@ -0,0 +1,56 @@
+import { n as normalizeEnv } from "./entry.js";
+import { a as hasHelpOrVersion, r as getPrimaryCommand } from "./argv-CfSowvEA.js";
+import process from "node:process";
+
+//#region src/cli/run-main.ts
+/**
+* CLI entry point — boots the Commander-based CLI.
+*
+* Mirrors the openclaw-classic pattern:
+* 1. Load .env files
+* 2. Normalize environment
+* 3. Build the Commander program
+* 4. Lazy-load the primary subcommand (if detected)
+* 5. Parse and execute
+*
+* @module cli/run-main
+*/
+/**
+* Load dotenv files (CWD first, then ~/.milaidy/.env).
+* Best-effort — never crashes.
+*/
+async function loadDotEnv() {
+	try {
+		const dotenvModule = await import("dotenv");
+		const configFn = dotenvModule.config ?? dotenvModule.default;
+		if (typeof configFn === "function") configFn();
+		else if (configFn && typeof configFn === "object" && "config" in configFn && typeof configFn.config === "function") configFn.config();
+	} catch {}
+}
+function formatUncaughtError(error) {
+	if (error instanceof Error) return error.stack ?? error.message;
+	return String(error);
+}
+async function runCli(argv = process.argv) {
+	await loadDotEnv();
+	normalizeEnv();
+	const { buildProgram } = await import("./program-6KwWwKKh.js");
+	const program = buildProgram();
+	process.on("unhandledRejection", (reason) => {
+		console.error("[milaidy] Unhandled rejection:", formatUncaughtError(reason));
+		process.exit(1);
+	});
+	process.on("uncaughtException", (error) => {
+		console.error("[milaidy] Uncaught exception:", formatUncaughtError(error));
+		process.exit(1);
+	});
+	const primary = getPrimaryCommand(argv);
+	if (primary && !hasHelpOrVersion(argv)) {
+		const { registerSubCliByName } = await import("./register.subclis-uF_AsbWR.js").then((n) => n.n);
+		await registerSubCliByName(program, primary);
+	}
+	await program.parseAsync(argv);
+}
+
+//#endregion
+export { runCli };

package/dist/theme-DBvtuGeq.js

@@ -0,0 +1,36 @@
+import chalk, { Chalk } from "chalk";
+
+//#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
+//#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 && !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 isRich = () => Boolean(baseChalk.level > 0);
+
+//#endregion
+export { theme as n, isRich as t };

package/dist/utils-C1AUpp_V.js

@@ -0,0 +1,42 @@
+import { n as theme } from "./theme-DBvtuGeq.js";
+import os from "node:os";
+import path from "node:path";
+import fs from "node:fs";
+
+//#region src/globals.ts
+let globalVerbose = false;
+function setVerbose(v) {
+	globalVerbose = v;
+}
+const success = theme.success;
+const warn = theme.warn;
+const info = theme.info;
+const danger = theme.error;
+
+//#endregion
+//#region src/utils.ts
+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 resolveConfigDir(env = process.env, homedir = os.homedir) {
+	const override = env.MILAIDY_STATE_DIR?.trim();
+	if (override) return resolveUserPath(override);
+	return path.join(homedir(), ".milaidy");
+}
+function formatTerminalLink(label, url, opts) {
+	const esc = "\x1B";
+	const safeLabel = label.replaceAll(esc, "");
+	const safeUrl = url.replaceAll(esc, "");
+	if (!(opts?.force === true ? true : opts?.force === false ? false : Boolean(process.stdout.isTTY))) return opts?.fallback ?? `${safeLabel} (${safeUrl})`;
+	return `\u001b]8;;${safeUrl}\u0007${safeLabel}\u001b]8;;\u0007`;
+}
+const CONFIG_DIR = resolveConfigDir();
+
+//#endregion
+export { resolveUserPath as n, setVerbose as r, formatTerminalLink as t };

package/dist/version-Cpn3yr5D.js

@@ -0,0 +1,26 @@
+import { createRequire } from "node:module";
+
+//#region src/version.ts
+function readVersionFromPackageJson() {
+	try {
+		return createRequire(import.meta.url)("../package.json").version ?? null;
+	} catch {
+		return null;
+	}
+}
+function readVersionFromBuildInfo() {
+	try {
+		const require = createRequire(import.meta.url);
+		for (const candidate of ["../build-info.json", "./build-info.json"]) try {
+			const info = require(candidate);
+			if (info.version) return info.version;
+		} catch {}
+		return null;
+	} catch {
+		return null;
+	}
+}
+const VERSION = typeof __MILAIDY_VERSION__ === "string" && __MILAIDY_VERSION__ || process.env.MILAIDY_BUNDLED_VERSION || readVersionFromPackageJson() || readVersionFromBuildInfo() || "0.0.0";
+
+//#endregion
+export { VERSION as t };

package/dist/workspace-Co3Wul2D.js

@@ -0,0 +1,206 @@
+import { a as DEFAULT_IDENTITY_FILENAME, c as DEFAULT_TOOLS_FILENAME, d as filterBootstrapFilesForSession, f as loadWorkspaceBootstrapFiles, i as DEFAULT_HEARTBEAT_FILENAME, l as DEFAULT_USER_FILENAME, n as DEFAULT_AGENT_WORKSPACE_DIR, o as DEFAULT_MEMORY_ALT_FILENAME, p as resolveDefaultAgentWorkspaceDir, r as DEFAULT_BOOTSTRAP_FILENAME, s as DEFAULT_MEMORY_FILENAME, t as DEFAULT_AGENTS_FILENAME, u as ensureAgentWorkspace } from "./workspace-DCA6MNVK.js";
+import { t as resolveConfigPath } from "./paths-D_yh1DEJ.js";
+import "./theme-DBvtuGeq.js";
+import "./utils-C1AUpp_V.js";
+import path from "node:path";
+import fs from "node:fs";
+import JSON5 from "json5";
+
+//#region src/config/includes.ts
+/**
+* Config includes: $include directive for modular configs
+*
+* @example
+* ```json5
+* {
+*   "$include": "./base.json5",           // single file
+*   "$include": ["./a.json5", "./b.json5"] // merge multiple
+* }
+* ```
+*/
+const INCLUDE_KEY = "$include";
+const MAX_INCLUDE_DEPTH = 10;
+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 isPlainObject(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value) && Object.prototype.toString.call(value) === "[object Object]";
+}
+/** Deep merge: arrays concatenate, objects merge recursively, primitives: source wins */
+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)) 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)) 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 = this.resolvePath(includePath);
+		this.checkCircular(resolvedPath);
+		this.checkDepth(includePath);
+		const raw = this.readFile(includePath, resolvedPath);
+		const parsed = this.parseFile(includePath, resolvedPath, raw);
+		return this.processNested(resolvedPath, parsed);
+	}
+	resolvePath(includePath) {
+		const resolved = path.isAbsolute(includePath) ? includePath : path.resolve(path.dirname(this.basePath), includePath);
+		return path.normalize(resolved);
+	}
+	checkCircular(resolvedPath) {
+		if (this.visited.has(resolvedPath)) throw new CircularIncludeError([...this.visited, resolvedPath]);
+	}
+	checkDepth(includePath) {
+		if (this.depth >= MAX_INCLUDE_DEPTH) throw new ConfigIncludeError(`Maximum include depth (${MAX_INCLUDE_DEPTH}) exceeded at: ${includePath}`, includePath);
+	}
+	readFile(includePath, resolvedPath) {
+		try {
+			return this.resolver.readFile(resolvedPath);
+		} catch (err) {
+			throw new ConfigIncludeError(`Failed to read include file: ${includePath} (resolved: ${resolvedPath})`, includePath, err instanceof Error ? err : void 0);
+		}
+	}
+	parseFile(includePath, resolvedPath, raw) {
+		try {
+			return this.resolver.parseJson(raw);
+		} catch (err) {
+			throw new ConfigIncludeError(`Failed to parse include file: ${includePath} (resolved: ${resolvedPath})`, includePath, err instanceof Error ? err : void 0);
+		}
+	}
+	processNested(resolvedPath, parsed) {
+		const nested = new IncludeProcessor(resolvedPath, this.resolver);
+		nested.visited = new Set([...this.visited, resolvedPath]);
+		nested.depth = this.depth + 1;
+		return nested.process(parsed);
+	}
+};
+const defaultResolver = {
+	readFile: (p) => fs.readFileSync(p, "utf-8"),
+	parseJson: (raw) => JSON5.parse(raw)
+};
+/**
+* Resolves all $include directives in a parsed config object.
+*/
+function resolveConfigIncludes(obj, configPath, resolver = defaultResolver) {
+	return new IncludeProcessor(configPath, resolver).process(obj);
+}
+
+//#endregion
+//#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
+//#region src/config/config.ts
+/**
+* Config loading and types.
+*
+* Reads ~/.milaidy/milaidy.json (or $MILAIDY_CONFIG_PATH), resolves $include
+* directives, and applies inline env vars.
+*
+* @module config/config
+*/
+/**
+* Load the Milaidy config from disk.
+*
+* 1. Resolves the config path (~/.milaidy/milaidy.json or MILAIDY_CONFIG_PATH).
+* 2. Parses the file as JSON5.
+* 3. Resolves any $include directives.
+* 4. Applies inline env vars (config.env.vars) to process.env.
+*
+* Returns an empty MilaidyConfig when the file is missing.
+*/
+async function loadMilaidyConfig() {
+	const configPath = resolveConfigPath();
+	let raw;
+	try {
+		raw = fs.readFileSync(configPath, "utf-8");
+	} catch {
+		return {};
+	}
+	const resolved = resolveConfigIncludes(JSON5.parse(raw), configPath);
+	const envVars = collectConfigEnvVars(resolved);
+	for (const [key, value] of Object.entries(envVars)) if (!process.env[key]) process.env[key] = value;
+	return resolved;
+}
+/**
+* Save the Milaidy config to disk.
+*
+* Writes the config as pretty-printed JSON to the resolved config path.
+* Creates the parent directory if it doesn't exist.
+*/
+function saveMilaidyConfig(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`, "utf-8");
+}
+
+//#endregion
+export { ensureAgentWorkspace, saveMilaidyConfig as n, resolveDefaultAgentWorkspaceDir, loadMilaidyConfig as t };