milaidy 1.0.0

package/dist/program-6KwWwKKh.js

@@ -0,0 +1,510 @@
+import { t as registerSubCliCommands } from "./register.subclis-uF_AsbWR.js";
+import { t as isTruthyEnvValue } from "./entry.js";
+import "./paths-D_yh1DEJ.js";
+import { n as theme, t as isRich } from "./theme-DBvtuGeq.js";
+import { r as setVerbose } from "./utils-C1AUpp_V.js";
+import { t as formatDocsLink } from "./links-BFKlWqSe.js";
+import { a as hasHelpOrVersion, i as getVerboseFlag, n as getCommandPath } from "./argv-CfSowvEA.js";
+import { t as VERSION } from "./version-Cpn3yr5D.js";
+import { createRequire } from "node:module";
+import path from "node:path";
+import fs from "node:fs";
+import { Command } from "commander";
+
+//#region src/cli/program/register.config.ts
+function registerConfigCli(program) {
+	const config = program.command("config").description("Config helpers (get/set/unset). Run without subcommand for the wizard.");
+	config.command("get <key>").description("Get a config value").action(async (key) => {
+		const { loadMilaidyConfig } = await import("./config-B-mboG4v.js");
+		let milaidyConfig;
+		try {
+			milaidyConfig = await loadMilaidyConfig();
+		} catch {
+			console.error("[milaidy] Could not load config.");
+			process.exit(1);
+		}
+		const parts = key.split(".");
+		let value = milaidyConfig;
+		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("set <key> <value>").description("Set a config value").action(async (key, value) => {
+		console.log(`[milaidy] config set ${key} = ${value}`);
+		console.log(`${theme.muted("Config set not yet fully implemented.")}`);
+		console.log(`${theme.muted("Edit ~/.milaidy/milaidy.json directly for now.")}`);
+	});
+	config.command("unset <key>").description("Remove a config value").action(async (key) => {
+		console.log(`[milaidy] config unset ${key}`);
+		console.log(`${theme.muted("Config unset not yet fully implemented.")}`);
+		console.log(`${theme.muted("Edit ~/.milaidy/milaidy.json directly for now.")}`);
+	});
+	config.command("path").description("Print the config file path").action(async () => {
+		const configPath = process.env.MILAIDY_CONFIG_PATH ?? "~/.milaidy/milaidy.json";
+		console.log(configPath);
+	});
+}
+
+//#endregion
+//#region src/cli/cli-utils.ts
+async function runCommandWithRuntime(runtime, action, onError) {
+	try {
+		await action();
+	} catch (err) {
+		if (onError) {
+			onError(err);
+			return;
+		}
+		runtime.error(String(err));
+		runtime.exit(1);
+	}
+}
+
+//#endregion
+//#region src/cli/program/register.configure.ts
+const defaultRuntime$2 = {
+	error: console.error,
+	exit: process.exit
+};
+function registerConfigureCommand(program) {
+	program.command("configure").description("Interactive prompt to set up credentials, devices, and agent defaults").addHelpText("after", () => `\n${theme.muted("Docs:")} ${formatDocsLink("/configuration", "docs.milaidy.ai/configuration")}\n`).option("--section <section>", "Configure a specific section (repeatable)", (value, previous) => [...previous, value], []).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime$2, async () => {
+			const sections = Array.isArray(opts.section) ? opts.section : [];
+			console.log(`\n${theme.heading("Milaidy Configuration")}\n`);
+			if (sections.length > 0) console.log(`Sections: ${sections.join(", ")}`);
+			console.log("Available configuration sections:");
+			console.log(`  ${theme.command("models")}      Model provider API keys`);
+			console.log(`  ${theme.command("channels")}    Channel credentials (Discord, Telegram, etc.)`);
+			console.log(`  ${theme.command("agent")}       Agent name, bio, and system prompt`);
+			console.log(`  ${theme.command("gateway")}     Gateway port and bind settings`);
+			console.log(`  ${theme.command("workspace")}   Agent workspace directory\n`);
+			console.log(`${theme.muted("Tip:")} Use 'milaidy config set <key> <value>' to set individual values.`);
+			console.log(`${theme.muted("Tip:")} Edit ~/.milaidy/milaidy.json directly for full control.\n`);
+		});
+	});
+}
+
+//#endregion
+//#region src/cli/program/register.dashboard.ts
+function registerDashboardCommand(program) {
+	program.command("dashboard").description("Open the Control UI with your current token").option("--port <port>", "Gateway port", process.env.MILAIDY_GATEWAY_PORT ?? "18789").option("--url <url>", "Gateway URL (overrides --port)").action(async (opts) => {
+		const port = opts.port ?? "18789";
+		const url = opts.url ?? `http://localhost:${port}`;
+		console.log(`${theme.muted("→")} Opening Control UI: ${url}`);
+		const { exec } = await import("node:child_process");
+		exec(`${process.platform === "darwin" ? "open" : process.platform === "win32" ? "start" : "xdg-open"} ${url}`, (err) => {
+			if (err) {
+				console.log(`${theme.warn("Could not open browser automatically.")}`);
+				console.log(`${theme.muted("Open manually:")} ${url}`);
+			}
+		});
+	});
+}
+
+//#endregion
+//#region src/cli/program/register.doctor.ts
+function registerDoctorCommand(program) {
+	program.command("doctor").description("Health checks + quick fixes for the gateway and channels").action(async () => {
+		console.log(`\n${theme.heading("Milaidy Doctor")}\n`);
+		console.log("Running health checks...\n");
+		const nodeVersion = process.version;
+		if (Number.parseInt(nodeVersion.slice(1).split(".")[0] ?? "0", 10) >= 22) console.log(`  ${theme.success("✓")} Node.js ${nodeVersion}`);
+		else console.log(`  ${theme.error("✗")} Node.js ${nodeVersion} (requires >= 22.12.0)`);
+		try {
+			const { loadMilaidyConfig } = await import("./config-B-mboG4v.js");
+			await loadMilaidyConfig();
+			console.log(`  ${theme.success("✓")} Config file loaded`);
+		} catch {
+			console.log(`  ${theme.warn("!")} No config file found — run 'milaidy setup'`);
+		}
+		if (Boolean(process.env.ANTHROPIC_API_KEY || process.env.OPENAI_API_KEY || process.env.GOOGLE_API_KEY || process.env.GROQ_API_KEY || process.env.XAI_API_KEY || process.env.OPENROUTER_API_KEY || process.env.OLLAMA_BASE_URL)) console.log(`  ${theme.success("✓")} At least one model provider API key configured`);
+		else console.log(`  ${theme.warn("!")} No model provider API key found — set one in .env or milaidy.json`);
+		console.log();
+	});
+}
+
+//#endregion
+//#region src/cli/program/register.setup.ts
+const defaultRuntime$1 = {
+	error: console.error,
+	exit: process.exit
+};
+function registerSetupCommand(program) {
+	program.command("setup").description("Initialize ~/.milaidy/milaidy.json and the agent workspace").addHelpText("after", () => `\n${theme.muted("Docs:")} ${formatDocsLink("/getting-started/setup", "docs.milaidy.ai/getting-started/setup")}\n`).option("--workspace <dir>", "Agent workspace directory").option("--wizard", "Run the interactive onboarding wizard", false).action(async (opts) => {
+		await runCommandWithRuntime(defaultRuntime$1, async () => {
+			const { loadMilaidyConfig } = await import("./config-B-mboG4v.js");
+			const { ensureAgentWorkspace, resolveDefaultAgentWorkspaceDir } = await import("./workspace-Co3Wul2D.js");
+			let config;
+			try {
+				config = await loadMilaidyConfig();
+				console.log(`${theme.success("✓")} Config loaded`);
+			} catch {
+				console.log(`${theme.muted("→")} No config found, using defaults`);
+				config = {};
+			}
+			const workspaceDir = opts.workspace ?? config?.agents?.defaults?.workspace ?? resolveDefaultAgentWorkspaceDir();
+			await ensureAgentWorkspace({
+				dir: workspaceDir,
+				ensureBootstrapFiles: true
+			});
+			console.log(`${theme.success("✓")} Agent workspace ready: ${workspaceDir}`);
+			if (opts.wizard) {
+				console.log(`\n${theme.muted("Interactive wizard not yet implemented.")}`);
+				console.log(`${theme.muted("Use 'milaidy configure' for interactive setup.")}`);
+			}
+			console.log(`\n${theme.success("Setup complete.")}`);
+		});
+	});
+}
+
+//#endregion
+//#region src/cli/program/register.start.ts
+const defaultRuntime = {
+	error: console.error,
+	exit: process.exit
+};
+function registerStartCommand(program) {
+	program.command("start").description("Start the ElizaOS agent runtime").addHelpText("after", () => `\n${theme.muted("Docs:")} ${formatDocsLink("/getting-started", "docs.milaidy.ai/getting-started")}\n`).action(async () => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const { startEliza } = await import("./eliza-CPJjgw-e.js");
+			await startEliza();
+		});
+	});
+	program.command("run").description("Start the ElizaOS agent runtime (alias for start)").action(async () => {
+		await runCommandWithRuntime(defaultRuntime, async () => {
+			const { startEliza } = await import("./eliza-CPJjgw-e.js");
+			await startEliza();
+		});
+	});
+}
+
+//#endregion
+//#region src/cli/program/register.status.ts
+function registerStatusHealthSessionsCommands(program) {
+	program.command("status").description("Show channel health and recent session recipients").option("--json", "Output JSON").option("--deep", "Run deep probes").option("--all", "Show all details (read-only/pasteable)").option("--usage", "Show usage statistics").option("--verbose", "Verbose output").option("--timeout <ms>", "Probe timeout in milliseconds", "10000").action(async () => {
+		console.log("[milaidy] Status — not yet fully implemented.");
+		console.log("[milaidy] Use the Control UI dashboard for status monitoring.");
+	});
+	program.command("health").description("Fetch health from the running gateway").option("--json", "Output JSON").option("--verbose", "Verbose output").option("--timeout <ms>", "Probe timeout in milliseconds", "10000").action(async () => {
+		console.log("[milaidy] Health — not yet fully implemented.");
+	});
+	program.command("sessions").description("List stored conversation sessions").option("--json", "Output JSON").option("--store <name>", "Filter by store name").option("--active <filter>", "Filter by active state").action(async () => {
+		console.log("[milaidy] Sessions — not yet fully implemented.");
+	});
+}
+
+//#endregion
+//#region src/cli/program/command-registry.ts
+const commandRegistry = [
+	{
+		id: "start",
+		register: ({ program }) => registerStartCommand(program)
+	},
+	{
+		id: "setup",
+		register: ({ program }) => registerSetupCommand(program)
+	},
+	{
+		id: "configure",
+		register: ({ program }) => registerConfigureCommand(program)
+	},
+	{
+		id: "config",
+		register: ({ program }) => registerConfigCli(program)
+	},
+	{
+		id: "doctor",
+		register: ({ program }) => registerDoctorCommand(program)
+	},
+	{
+		id: "dashboard",
+		register: ({ program }) => registerDashboardCommand(program)
+	},
+	{
+		id: "status-health-sessions",
+		register: ({ program }) => registerStatusHealthSessionsCommands(program)
+	},
+	{
+		id: "subclis",
+		register: ({ program, argv }) => registerSubCliCommands(program, argv)
+	}
+];
+function registerProgramCommands(program, ctx, argv = process.argv) {
+	for (const entry of commandRegistry) entry.register({
+		program,
+		ctx,
+		argv
+	});
+}
+
+//#endregion
+//#region src/cli/channel-options.ts
+/** Known channel IDs in display order */
+const CHAT_CHANNEL_ORDER = [
+	"discord",
+	"telegram",
+	"slack",
+	"whatsapp",
+	"signal",
+	"imessage",
+	"matrix",
+	"msteams",
+	"googlechat"
+];
+function dedupe(values) {
+	const seen = /* @__PURE__ */ new Set();
+	const resolved = [];
+	for (const value of values) {
+		if (!value || seen.has(value)) continue;
+		seen.add(value);
+		resolved.push(value);
+	}
+	return resolved;
+}
+/**
+* Get the list of available channel options for CLI.
+* Plugin channels are no longer supported.
+*/
+function resolveCliChannelOptions() {
+	return dedupe([...CHAT_CHANNEL_ORDER]);
+}
+
+//#endregion
+//#region src/cli/program/context.ts
+function createProgramContext() {
+	const channelOptions = resolveCliChannelOptions();
+	return {
+		programVersion: VERSION,
+		channelOptions,
+		messageChannelOptions: channelOptions.join("|"),
+		agentChannelOptions: ["last", ...channelOptions].join("|")
+	};
+}
+
+//#endregion
+//#region src/infra/git-commit.ts
+const formatCommit = (value) => {
+	if (!value) return null;
+	const trimmed = value.trim();
+	if (!trimmed) return null;
+	return trimmed.length > 7 ? trimmed.slice(0, 7) : trimmed;
+};
+const resolveGitHead = (startDir) => {
+	let current = startDir;
+	for (let i = 0; i < 12; i += 1) {
+		const gitPath = path.join(current, ".git");
+		try {
+			const stat = fs.statSync(gitPath);
+			if (stat.isDirectory()) return path.join(gitPath, "HEAD");
+			if (stat.isFile()) {
+				const match = fs.readFileSync(gitPath, "utf-8").match(/gitdir:\s*(.+)/i);
+				if (match?.[1]) {
+					const resolved = path.resolve(current, match[1].trim());
+					return path.join(resolved, "HEAD");
+				}
+			}
+		} catch {}
+		const parent = path.dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	return null;
+};
+let cachedCommit;
+const readCommitFromPackageJson = () => {
+	try {
+		const pkg = createRequire(import.meta.url)("../../package.json");
+		return formatCommit(pkg.gitHead ?? pkg.githead ?? null);
+	} catch {
+		return null;
+	}
+};
+const readCommitFromBuildInfo = () => {
+	try {
+		const require = createRequire(import.meta.url);
+		for (const candidate of ["../build-info.json", "./build-info.json"]) try {
+			const formatted = formatCommit(require(candidate).commit ?? null);
+			if (formatted) return formatted;
+		} catch {}
+		return null;
+	} catch {
+		return null;
+	}
+};
+const resolveCommitHash = (options = {}) => {
+	if (cachedCommit !== void 0) return cachedCommit;
+	const env = options.env ?? process.env;
+	const normalized = formatCommit(env.GIT_COMMIT?.trim() || env.GIT_SHA?.trim());
+	if (normalized) {
+		cachedCommit = normalized;
+		return cachedCommit;
+	}
+	const buildInfoCommit = readCommitFromBuildInfo();
+	if (buildInfoCommit) {
+		cachedCommit = buildInfoCommit;
+		return cachedCommit;
+	}
+	const pkgCommit = readCommitFromPackageJson();
+	if (pkgCommit) {
+		cachedCommit = pkgCommit;
+		return cachedCommit;
+	}
+	try {
+		const headPath = resolveGitHead(options.cwd ?? process.cwd());
+		if (!headPath) {
+			cachedCommit = null;
+			return cachedCommit;
+		}
+		const head = fs.readFileSync(headPath, "utf-8").trim();
+		if (!head) {
+			cachedCommit = null;
+			return cachedCommit;
+		}
+		if (head.startsWith("ref:")) {
+			const ref = head.replace(/^ref:\s*/i, "").trim();
+			const refPath = path.resolve(path.dirname(headPath), ref);
+			cachedCommit = formatCommit(fs.readFileSync(refPath, "utf-8").trim());
+			return cachedCommit;
+		}
+		cachedCommit = formatCommit(head);
+		return cachedCommit;
+	} catch {
+		cachedCommit = null;
+		return cachedCommit;
+	}
+};
+
+//#endregion
+//#region src/cli/banner.ts
+let bannerEmitted = false;
+const graphemeSegmenter = typeof Intl !== "undefined" && "Segmenter" in Intl ? new Intl.Segmenter(void 0, { granularity: "grapheme" }) : null;
+const hasJsonFlag = (argv) => argv.some((arg) => arg === "--json" || arg.startsWith("--json="));
+const hasVersionFlag = (argv) => argv.some((arg) => arg === "--version" || arg === "-V" || arg === "-v");
+function formatCliBannerLine(version, options = {}) {
+	const commitLabel = options.commit ?? resolveCommitHash({ env: options.env }) ?? "unknown";
+	const rich = options.richTty ?? isRich();
+	const title = "🌹 Milaidy";
+	if (rich) return `${theme.heading(title)} ${theme.info(version)} ${theme.muted(`(${commitLabel})`)}`;
+	return `${title} ${version} (${commitLabel})`;
+}
+function emitCliBanner(version, options = {}) {
+	if (bannerEmitted) return;
+	const argv = options.argv ?? process.argv;
+	if (!process.stdout.isTTY) return;
+	if (hasJsonFlag(argv)) return;
+	if (hasVersionFlag(argv)) return;
+	const line = formatCliBannerLine(version, options);
+	process.stdout.write(`\n${line}\n\n`);
+	bannerEmitted = true;
+}
+function hasEmittedCliBanner() {
+	return bannerEmitted;
+}
+
+//#endregion
+//#region src/cli/cli-name.ts
+const DEFAULT_CLI_NAME = "milaidy";
+const KNOWN_CLI_NAMES = new Set([DEFAULT_CLI_NAME]);
+const CLI_PREFIX_RE = /^(?:((?:pnpm|npm|bunx|npx)\s+))?(milaidy)\b/;
+function resolveCliName(argv = process.argv) {
+	const argv1 = argv[1];
+	if (!argv1) return DEFAULT_CLI_NAME;
+	const base = path.basename(argv1).trim();
+	if (KNOWN_CLI_NAMES.has(base)) return base;
+	return DEFAULT_CLI_NAME;
+}
+function replaceCliName(command, cliName = resolveCliName()) {
+	if (!command.trim()) return command;
+	if (!CLI_PREFIX_RE.test(command)) return command;
+	return command.replace(CLI_PREFIX_RE, (_match, runner) => {
+		return `${runner ?? ""}${cliName}`;
+	});
+}
+
+//#endregion
+//#region src/cli/program/help.ts
+const CLI_NAME = resolveCliName();
+const EXAMPLES = [
+	["milaidy start", "Start the ElizaOS agent runtime."],
+	["milaidy gateway", "Run the WebSocket Gateway locally."],
+	["milaidy --dev gateway", "Run a dev Gateway (isolated state/config) on ws://127.0.0.1:19001."],
+	["milaidy gateway --force", "Kill anything bound to the default gateway port, then start it."],
+	["milaidy dashboard", "Open the Control UI in your browser."],
+	["milaidy setup", "Initialize ~/.milaidy/milaidy.json and the agent workspace."],
+	["milaidy configure", "Interactive setup for credentials and agent defaults."],
+	["milaidy config set agents.defaults.model.primary claude-sonnet-4-20250514", "Set the default model."],
+	["milaidy plugins list", "List available ElizaOS plugins."]
+];
+function configureProgramHelp(program, ctx) {
+	program.name(CLI_NAME).description("").version(ctx.programVersion).option("--dev", "Dev profile: isolate state under ~/.milaidy-dev, default gateway port 19001, and shift derived ports (browser/canvas)").option("--profile <name>", "Use a named profile (isolates MILAIDY_STATE_DIR/MILAIDY_CONFIG_PATH under ~/.milaidy-<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))
+	});
+	if (process.argv.includes("-V") || process.argv.includes("--version") || process.argv.includes("-v")) {
+		console.log(ctx.programVersion);
+		process.exit(0);
+	}
+	program.addHelpText("beforeAll", () => {
+		if (hasEmittedCliBanner()) return "";
+		const rich = isRich();
+		return `\n${formatCliBannerLine(ctx.programVersion, { richTty: rich })}\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.milaidy.ai/cli");
+		return `\n${theme.heading("Examples:")}\n${fmtExamples}\n\n${theme.muted("Docs:")} ${docs}\n`;
+	});
+}
+
+//#endregion
+//#region src/cli/program/preaction.ts
+function setProcessTitleForCommand(actionCommand) {
+	let current = actionCommand;
+	while (current.parent && 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.MILAIDY_HIDE_BANNER) || commandPath[0] === "update" || commandPath[0] === "completion")) emitCliBanner(programVersion);
+		const verbose = getVerboseFlag(argv, { includeDebug: true });
+		setVerbose(verbose);
+		if (!verbose) process.env.NODE_NO_WARNINGS ??= "1";
+	});
+}
+
+//#endregion
+//#region src/cli/program/build-program.ts
+function buildProgram() {
+	const program = new Command();
+	const ctx = createProgramContext();
+	const argv = process.argv;
+	configureProgramHelp(program, ctx);
+	registerPreActionHooks(program, ctx.programVersion);
+	registerProgramCommands(program, ctx, argv);
+	return program;
+}
+
+//#endregion
+export { buildProgram };

package/dist/register.agents-CPVmSjMG.js

@@ -0,0 +1,17 @@
+import { n as theme } from "./theme-DBvtuGeq.js";
+
+//#region src/cli/program/register.agents.ts
+function registerAgentsCli(program) {
+	const agents = program.command("agents").description("Manage isolated agents (workspaces + auth + routing)");
+	agents.command("list").description("List configured agents").option("--json", "Output JSON").option("--bindings", "Show channel bindings").action(async () => {
+		console.log("[milaidy] Agents list — not yet fully implemented.");
+		console.log(`${theme.muted("Agents are managed via ElizaOS character files.")}`);
+	});
+	agents.command("create").description("Create a new agent workspace").argument("<name>", "Agent name").action(async (name) => {
+		console.log(`[milaidy] Creating agent workspace for: ${name}`);
+		console.log("[milaidy] Agent creation — not yet fully implemented.");
+	});
+}
+
+//#endregion
+export { registerAgentsCli };

package/dist/register.browser-B2ooXxNx.js

@@ -0,0 +1,15 @@
+//#region src/cli/program/register.browser.ts
+function registerBrowserCli(program) {
+	const browser = program.command("browser").description("Manage Milaidy's dedicated browser (Chrome/Chromium)");
+	browser.command("extension").description("Chrome extension management").action(async () => {
+		console.log("[milaidy] Browser extension management:");
+		console.log("  milaidy browser extension install  — Install the Chrome extension files");
+		console.log("  milaidy browser extension path     — Print the extension directory path");
+	});
+	browser.command("launch").description("Launch the dedicated browser").action(async () => {
+		console.log("[milaidy] Browser launch — not yet fully implemented.");
+	});
+}
+
+//#endregion
+export { registerBrowserCli };

package/dist/register.channels-CMYQ6K6Y.js

@@ -0,0 +1,42 @@
+import "./paths-D_yh1DEJ.js";
+import { n as theme } from "./theme-DBvtuGeq.js";
+import "./utils-C1AUpp_V.js";
+import { t as formatDocsLink } from "./links-BFKlWqSe.js";
+
+//#region src/cli/program/register.channels.ts
+function registerChannelsCli(program) {
+	const channels = program.command("channels").description("Channel management").addHelpText("after", () => `\n${theme.muted("Docs:")} ${formatDocsLink("/channels", "docs.milaidy.ai/channels")}\n`);
+	channels.command("list").description("List configured channels").option("--json", "Output JSON").action(async () => {
+		const { loadMilaidyConfig } = await import("./config-B-mboG4v.js");
+		let config;
+		try {
+			config = await loadMilaidyConfig();
+		} catch {
+			config = {};
+		}
+		const channelsConfig = config.channels ?? {};
+		const names = Object.keys(channelsConfig);
+		if (names.length === 0) {
+			console.log("No channels configured. Use 'milaidy configure --section channels' to set up channels.");
+			return;
+		}
+		console.log("\nConfigured channels:\n");
+		for (const name of names) console.log(`  ${theme.command(name)}`);
+		console.log();
+	});
+	channels.command("status").description("Show channel health and connection status").option("--probe", "Probe channels for connectivity").option("--json", "Output JSON").action(async () => {
+		console.log("[milaidy] Channel status — not yet fully implemented.");
+		console.log("[milaidy] Use the Control UI dashboard for channel monitoring.");
+	});
+	channels.command("login").description("Link a channel account").argument("[channel]", "Channel to link (e.g. whatsapp, telegram)").option("--verbose", "Show detailed connection logs").action(async (channel) => {
+		if (!channel) {
+			console.log("Usage: milaidy channels login <channel>");
+			console.log("Available: discord, telegram, slack, whatsapp, signal, imessage");
+			return;
+		}
+		console.log(`[milaidy] Channel login for ${channel} — not yet fully implemented.`);
+	});
+}
+
+//#endregion
+export { registerChannelsCli };

package/dist/register.cron-D91lY1_Y.js

@@ -0,0 +1,9 @@
+//#region src/cli/program/register.cron.ts
+function registerCronCli(program) {
+	program.command("cron").description("Cron scheduler").command("list").description("List scheduled jobs").option("--json", "Output JSON").action(async () => {
+		console.log("[milaidy] Cron list — not yet fully implemented.");
+	});
+}
+
+//#endregion
+export { registerCronCli };

package/dist/register.devices-rU5I5L_y.js

@@ -0,0 +1,13 @@
+//#region src/cli/program/register.devices.ts
+function registerDevicesCli(program) {
+	const devices = program.command("devices").description("Device pairing + token management");
+	devices.command("list").description("List paired devices").option("--json", "Output JSON").action(async () => {
+		console.log("[milaidy] Devices list — not yet fully implemented.");
+	});
+	devices.command("pair").description("Pair a new device").action(async () => {
+		console.log("[milaidy] Device pairing — not yet fully implemented.");
+	});
+}
+
+//#endregion
+export { registerDevicesCli };

package/dist/register.gateway-82SLAvw3.js

@@ -0,0 +1,22 @@
+import "./paths-D_yh1DEJ.js";
+import { n as theme } from "./theme-DBvtuGeq.js";
+import "./utils-C1AUpp_V.js";
+import { t as formatDocsLink } from "./links-BFKlWqSe.js";
+
+//#region src/cli/program/register.gateway.ts
+function registerGatewayCli(program) {
+	const gateway = program.command("gateway").description("Run the WebSocket Gateway").addHelpText("after", () => `\n${theme.muted("Docs:")} ${formatDocsLink("/gateway", "docs.milaidy.ai/gateway")}\n`).option("--port <port>", "Gateway port", process.env.MILAIDY_GATEWAY_PORT ?? "18789").option("--bind <address>", "Bind address", "loopback").option("--force", "Kill anything bound to the port, then start").option("--reset", "Reset gateway state before starting").action(async (opts) => {
+		console.log(`[milaidy] Starting gateway on port ${opts.port}...`);
+		console.log("[milaidy] Gateway command not yet fully implemented — see openclaw-classic.");
+		console.log("[milaidy] Use 'bun run gateway:dev' for development.");
+	});
+	gateway.command("status").description("Show gateway service status").option("--url <url>", "Gateway URL to probe").option("--timeout <ms>", "Probe timeout in milliseconds", "10000").option("--json", "Output JSON").action(async (_opts) => {
+		console.log("[milaidy] Gateway status check — not yet implemented.");
+	});
+	gateway.command("stop").description("Stop the running gateway").action(async () => {
+		console.log("[milaidy] Gateway stop — not yet implemented.");
+	});
+}
+
+//#endregion
+export { registerGatewayCli };

package/dist/register.hooks-B_XTBEkt.js

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

package/dist/register.logs-BgEGcPd8.js

@@ -0,0 +1,10 @@
+//#region src/cli/program/register.logs.ts
+function registerLogsCli(program) {
+	program.command("logs").description("Gateway logs").command("tail").description("Tail gateway logs").option("--lines <n>", "Number of lines to show", "50").option("--follow", "Follow log output").action(async () => {
+		console.log("[milaidy] Logs tail — not yet fully implemented.");
+		console.log("[milaidy] Use the Control UI dashboard for live log viewing.");
+	});
+}
+
+//#endregion
+export { registerLogsCli };