miladyai 2.0.0-alpha.27

package/dist/tui/tui-app.js

@@ -0,0 +1,311 @@
+import { tuiTheme } from "./theme.js";
+import { ChatEditor } from "./components/chat-editor.js";
+import { EmbeddingsOverlayComponent } from "./components/embeddings-overlay.js";
+import { FooterComponent } from "./components/footer.js";
+import { ModelSelectorComponent } from "./components/model-selector.js";
+import { PinnedChatLayout } from "./components/pinned-chat-layout.js";
+import { PluginsOverlayComponent } from "./components/plugins-overlay.js";
+import { SettingsOverlayComponent } from "./components/settings-overlay.js";
+import { StatusBar } from "./components/status-bar.js";
+import "./components/index.js";
+import { MODAL_PRESETS } from "./modal-presets.js";
+import { TitlebarSpinner } from "./titlebar-spinner.js";
+import path from "node:path";
+import { getModels, getProviders } from "@mariozechner/pi-ai";
+import { CombinedAutocompleteProvider, Container, ProcessTerminal, Spacer, TUI, Text } from "@mariozechner/pi-tui";
+
+//#region src/tui/tui-app.ts
+var MiladyTUI = class {
+	constructor(options) {
+		this.options = options;
+		this.terminal = new ProcessTerminal();
+		this.chatContainer = new Container();
+		this.ephemeralStatusContainer = new Container();
+		this.statusBar = new StatusBar();
+		this.footer = new FooterComponent();
+		this.modelOverlay = null;
+		this.settingsOverlay = null;
+		this.embeddingsOverlay = null;
+		this.pluginsOverlay = null;
+		this.toolOutputExpanded = false;
+		this.showThinking = process.env.MILADY_TUI_SHOW_THINKING === "1";
+		this.titlebarSpinner = new TitlebarSpinner({ setTitle: (title) => this.terminal.setTitle(title) });
+	}
+	setOnSubmit(handler) {
+		this.onSubmit = handler;
+	}
+	setOnCtrlC(handler) {
+		this.onCtrlC = handler;
+	}
+	setOnToggleToolExpand(handler) {
+		this.onToggleToolExpand = handler;
+	}
+	setOnToggleThinking(handler) {
+		this.onToggleThinking = handler;
+	}
+	getShowThinking() {
+		return this.showThinking;
+	}
+	setModelSelectorHandlers(handlers) {
+		this.modelSelectorHandlers = handlers;
+	}
+	setEmbeddingHandlers(handlers) {
+		this.embeddingHandlers = handlers;
+	}
+	getToolOutputExpanded() {
+		return this.toolOutputExpanded;
+	}
+	async start() {
+		this.ui = new TUI(this.terminal);
+		this.chatContainer = new Container();
+		this.ephemeralStatusContainer = new Container();
+		const agentName = this.options.runtime.character?.name ?? "milady";
+		this.statusBar.update({ agentName });
+		this.titlebarSpinner.setBaseTitle(this.getBaseTitle());
+		const logo = tuiTheme.bold(tuiTheme.accent("Milady")) + tuiTheme.dim(` — ${agentName}`);
+		this.chatContainer.addChild(new Spacer(1));
+		this.chatContainer.addChild(new Text(logo, 1, 0));
+		this.chatContainer.addChild(new Spacer(1));
+		this.editor = new ChatEditor(this.ui, tuiTheme.editor, { paddingX: 1 });
+		this.editor.onSubmit = (text) => {
+			const trimmed = text.trim();
+			if (!trimmed) return;
+			this.editor.addToHistory(trimmed);
+			this.editor.setText("");
+			this.onSubmit?.(trimmed);
+		};
+		this.editor.onCtrlC = () => {
+			this.onCtrlC?.();
+		};
+		this.editor.onCtrlE = () => {
+			this.toolOutputExpanded = !this.toolOutputExpanded;
+			this.onToggleToolExpand?.(this.toolOutputExpanded);
+			this.ui.requestRender();
+		};
+		this.editor.onCtrlP = () => {
+			this.showModelSelector();
+		};
+		this.editor.onCtrlG = () => {
+			this.showPlugins();
+		};
+		const getModelCompletions = (argumentPrefix) => {
+			const prefix = argumentPrefix.trim().toLowerCase();
+			const items = [];
+			for (const provider of getProviders()) for (const model of getModels(provider)) {
+				const spec = `${model.provider}/${model.id}`;
+				if (!prefix || spec.toLowerCase().startsWith(prefix)) items.push({
+					value: spec,
+					label: spec,
+					description: model.api
+				});
+				if (items.length >= 80) return items;
+			}
+			return items;
+		};
+		this.editor.setAutocompleteProvider(new CombinedAutocompleteProvider([
+			{
+				name: "model",
+				description: "Switch model (open selector or /model provider/id)",
+				getArgumentCompletions: (argumentPrefix) => getModelCompletions(argumentPrefix)
+			},
+			{
+				name: "models",
+				description: "Alias for /model",
+				getArgumentCompletions: (argumentPrefix) => getModelCompletions(argumentPrefix)
+			},
+			{
+				name: "embeddings",
+				description: "Open/switch embedding model (/embeddings [fallback|standard|performance])"
+			},
+			{
+				name: "clear",
+				description: "Clear chat"
+			},
+			{
+				name: "settings",
+				description: "Open settings panel"
+			},
+			{
+				name: "plugins",
+				description: "Open plugin manager"
+			},
+			{
+				name: "help",
+				description: "Show help"
+			},
+			{
+				name: "exit",
+				description: "Quit"
+			},
+			{
+				name: "quit",
+				description: "Alias for /exit"
+			}
+		]));
+		this.ui.addChild(new PinnedChatLayout({
+			chat: this.chatContainer,
+			ephemeralStatus: this.ephemeralStatusContainer,
+			statusBar: this.statusBar,
+			editor: this.editor,
+			footer: this.footer,
+			getTerminalRows: () => this.terminal.rows,
+			spacerLines: 1
+		}));
+		this.ui.onDebug = () => {
+			const info = [
+				`chat children: ${this.chatContainer.children.length}`,
+				`overlays: model=${!!this.modelOverlay} embeddings=${!!this.embeddingsOverlay}`,
+				`tool expand: ${this.toolOutputExpanded}`,
+				`terminal: ${this.terminal.columns}×${this.terminal.rows}`
+			].join(" | ");
+			this.addToChatContainer(new Text(tuiTheme.dim(`[debug] ${info}`), 1, 0));
+		};
+		this.ui.setFocus(this.editor);
+		this.ui.start();
+	}
+	async stop() {
+		this.titlebarSpinner.dispose();
+		this.modelOverlay?.hide();
+		this.modelOverlay = null;
+		this.settingsOverlay?.hide();
+		this.settingsOverlay = null;
+		this.embeddingsOverlay?.hide();
+		this.embeddingsOverlay = null;
+		this.pluginsOverlay?.hide();
+		this.pluginsOverlay = null;
+		this.ui.stop();
+	}
+	addToChatContainer(component) {
+		this.chatContainer.addChild(component);
+		this.ui.requestRender();
+	}
+	setEphemeralStatus(component) {
+		this.ephemeralStatusContainer.clear();
+		this.ephemeralStatusContainer.addChild(component);
+		this.ui.requestRender();
+	}
+	clearEphemeralStatus() {
+		this.ephemeralStatusContainer.clear();
+		this.ui.requestRender();
+	}
+	requestRender() {
+		this.ui.requestRender();
+	}
+	getTUI() {
+		return this.ui;
+	}
+	getStatusBar() {
+		return this.statusBar;
+	}
+	openModelSelector() {
+		this.showModelSelector();
+	}
+	openSettings() {
+		this.showSettings();
+	}
+	openEmbeddings() {
+		this.showEmbeddings();
+	}
+	openPlugins() {
+		this.showPlugins();
+	}
+	setBusy(busy) {
+		if (busy) this.titlebarSpinner.start();
+		else this.titlebarSpinner.stop();
+	}
+	clearChat() {
+		this.chatContainer.clear();
+		this.ui.requestRender();
+	}
+	getBaseTitle() {
+		const cwd = path.basename(process.cwd());
+		return `${this.options.runtime.character?.name ?? "milady"} - ${cwd}`;
+	}
+	showSettings() {
+		if (this.settingsOverlay) return;
+		const settings = new SettingsOverlayComponent({
+			showThinking: this.showThinking,
+			toolExpand: this.toolOutputExpanded,
+			onToggleThinking: (enabled) => {
+				this.showThinking = enabled;
+				this.onToggleThinking?.(enabled);
+			},
+			onToggleToolExpand: (expanded) => {
+				this.toolOutputExpanded = expanded;
+				this.onToggleToolExpand?.(expanded);
+			},
+			onClose: () => {
+				this.settingsOverlay?.hide();
+				this.settingsOverlay = null;
+				this.ui.setFocus(this.editor);
+				this.ui.requestRender();
+			}
+		});
+		this.settingsOverlay = this.ui.showOverlay(settings, MODAL_PRESETS.compact);
+		this.ui.requestRender();
+	}
+	showEmbeddings() {
+		if (!this.embeddingHandlers) return;
+		if (this.embeddingsOverlay) return;
+		const embeddings = new EmbeddingsOverlayComponent({
+			options: this.embeddingHandlers.getOptions(),
+			onSelectTier: (tier) => {
+				this.embeddingsOverlay?.hide();
+				this.embeddingsOverlay = null;
+				this.ui.setFocus(this.editor);
+				this.ui.requestRender();
+				this.embeddingHandlers?.onSelectTier(tier);
+			},
+			onCancel: () => {
+				this.embeddingsOverlay?.hide();
+				this.embeddingsOverlay = null;
+				this.ui.setFocus(this.editor);
+				this.ui.requestRender();
+			}
+		});
+		this.embeddingsOverlay = this.ui.showOverlay(embeddings, MODAL_PRESETS.standard);
+		this.ui.requestRender();
+	}
+	showPlugins() {
+		if (this.pluginsOverlay) return;
+		const plugins = new PluginsOverlayComponent({
+			runtime: this.options.runtime,
+			apiBaseUrl: this.options.apiBaseUrl,
+			onClose: () => {
+				this.pluginsOverlay?.hide();
+				this.pluginsOverlay = null;
+				this.ui.setFocus(this.editor);
+				this.ui.requestRender();
+			},
+			requestRender: () => this.ui.requestRender()
+		});
+		this.pluginsOverlay = this.ui.showOverlay(plugins, MODAL_PRESETS.wide);
+		this.ui.requestRender();
+	}
+	showModelSelector() {
+		if (!this.modelSelectorHandlers) return;
+		if (this.modelOverlay) return;
+		const selector = new ModelSelectorComponent({
+			currentModel: this.modelSelectorHandlers.getCurrentModel(),
+			hasCredentials: this.modelSelectorHandlers.hasCredentials,
+			onSelect: (model) => {
+				this.modelSelectorHandlers?.onSelectModel(model);
+				this.modelOverlay?.hide();
+				this.modelOverlay = null;
+				this.ui.setFocus(this.editor);
+				this.ui.requestRender();
+			},
+			onCancel: () => {
+				this.modelOverlay?.hide();
+				this.modelOverlay = null;
+				this.ui.setFocus(this.editor);
+				this.ui.requestRender();
+			}
+		});
+		this.modelOverlay = this.ui.showOverlay(selector, MODAL_PRESETS.standard);
+		this.ui.requestRender();
+	}
+};
+
+//#endregion
+export { MiladyTUI };

package/dist/tui/ws-client.js

@@ -0,0 +1,215 @@
+import process from "node:process";
+import { WebSocket } from "ws";
+
+//#region src/tui/ws-client.ts
+const WS_OPEN = 1;
+const WS_CONNECTING = 0;
+const WS_CLOSED = 3;
+function defaultSocketFactory(url, options) {
+	return new WebSocket(url, { headers: options.headers });
+}
+function normalizeError(error) {
+	if (error instanceof Error) return error;
+	return new Error(String(error));
+}
+function decodeWsMessage(data) {
+	if (typeof data === "string") return data;
+	if (data instanceof ArrayBuffer) return Buffer.from(data).toString("utf8");
+	if (ArrayBuffer.isView(data)) return Buffer.from(data.buffer, data.byteOffset, data.byteLength).toString("utf8");
+	if (Array.isArray(data)) {
+		const buffers = data.map((part) => {
+			if (typeof part === "string") return Buffer.from(part, "utf8");
+			if (part instanceof ArrayBuffer) return Buffer.from(part);
+			if (ArrayBuffer.isView(part)) return Buffer.from(part.buffer, part.byteOffset, part.byteLength);
+			return Buffer.from(String(part), "utf8");
+		});
+		return Buffer.concat(buffers).toString("utf8");
+	}
+	return String(data);
+}
+var ApiModeWsClient = class {
+	constructor(options) {
+		this.options = options;
+		this.ws = null;
+		this.wsSendQueue = [];
+		this.reconnectTimer = null;
+		this.closed = false;
+		this.latestActiveConversationId = null;
+		this.lastSentActiveConversationId = null;
+		this.queueLimit = Math.max(1, options.queueLimit ?? 32);
+		this.backoffMs = options.reconnectInitialDelayMs ?? 500;
+		this.reconnectMaxDelayMs = options.reconnectMaxDelayMs ?? 1e4;
+		this.wsUrl = this.buildWsUrl(options.apiBaseUrl);
+		this.socketFactory = options.socketFactory ?? defaultSocketFactory;
+		this.setTimeoutFn = options.setTimeoutFn ?? setTimeout;
+		this.clearTimeoutFn = options.clearTimeoutFn ?? clearTimeout;
+	}
+	connect() {
+		if (this.closed) return;
+		if (this.ws && (this.ws.readyState === WS_OPEN || this.ws.readyState === WS_CONNECTING)) return;
+		const token = this.getAuthToken();
+		const headers = {};
+		if (token) headers.Authorization = `Bearer ${token}`;
+		let socket;
+		try {
+			socket = this.socketFactory(this.wsUrl, { headers });
+			this.ws = socket;
+		} catch (error) {
+			const rootCause = normalizeError(error);
+			if (token) this.handleError(/* @__PURE__ */ new Error(`Failed to connect websocket with Authorization header. When MILADY_API_TOKEN is set, TUI websocket auth requires header-capable websocket support. Root cause: ${rootCause.message}`));
+			else this.handleError(rootCause);
+			this.scheduleReconnect();
+			return;
+		}
+		socket.on("open", () => {
+			if (this.closed || this.ws !== socket) return;
+			this.backoffMs = this.options.reconnectInitialDelayMs ?? 500;
+			this.flushSendQueue();
+			this.syncActiveConversation();
+		});
+		socket.on("message", (data) => {
+			if (this.closed || this.ws !== socket) return;
+			this.handleIncomingMessage(data);
+		});
+		socket.on("close", () => {
+			if (this.ws !== socket) return;
+			this.ws = null;
+			this.lastSentActiveConversationId = null;
+			if (this.closed) return;
+			this.scheduleReconnect();
+		});
+		socket.on("error", (error) => {
+			if (this.closed || this.ws !== socket) return;
+			this.handleError(error);
+		});
+	}
+	close() {
+		this.closed = true;
+		if (this.reconnectTimer) {
+			this.clearTimeoutFn(this.reconnectTimer);
+			this.reconnectTimer = null;
+		}
+		const socket = this.ws;
+		this.ws = null;
+		socket?.close();
+	}
+	sendMessage(data) {
+		const payload = JSON.stringify(data);
+		if (this.ws?.readyState === WS_OPEN) try {
+			this.ws.send(payload);
+			this.noteSentActiveConversation(data);
+			return;
+		} catch {}
+		this.queuePayload(payload, data);
+		if (!this.ws || this.ws.readyState === WS_CLOSED) this.connect();
+	}
+	setActiveConversationId(conversationId) {
+		const normalized = conversationId?.trim() || null;
+		this.latestActiveConversationId = normalized;
+		if (!normalized) {
+			this.wsSendQueue = this.wsSendQueue.filter((queued) => {
+				try {
+					return JSON.parse(queued).type !== "active-conversation";
+				} catch {
+					return true;
+				}
+			});
+			this.lastSentActiveConversationId = null;
+			return;
+		}
+		this.sendMessage({
+			type: "active-conversation",
+			conversationId: normalized
+		});
+	}
+	buildWsUrl(apiBaseUrl) {
+		const base = new URL(apiBaseUrl);
+		const wsUrl = new URL(base.toString());
+		wsUrl.pathname = `${wsUrl.pathname.replace(/\/+$/, "")}/ws`.replace(/\/+/g, "/");
+		wsUrl.protocol = base.protocol === "https:" ? "wss:" : "ws:";
+		wsUrl.search = "";
+		wsUrl.hash = "";
+		return wsUrl.toString();
+	}
+	getAuthToken() {
+		if (this.options.getAuthToken) {
+			const explicit = this.options.getAuthToken();
+			if (typeof explicit !== "string") return null;
+			return explicit.trim() || null;
+		}
+		return process.env.MILADY_API_TOKEN?.trim() || null;
+	}
+	flushSendQueue() {
+		if (!this.ws || this.ws.readyState !== WS_OPEN || this.wsSendQueue.length < 1) return;
+		const pending = this.wsSendQueue;
+		this.wsSendQueue = [];
+		for (let i = 0; i < pending.length; i++) {
+			if (!this.ws || this.ws.readyState !== WS_OPEN) {
+				this.wsSendQueue = pending.slice(i).concat(this.wsSendQueue);
+				break;
+			}
+			const payload = pending[i];
+			try {
+				this.ws.send(payload);
+				this.noteSentActiveConversationFromPayload(payload);
+			} catch {
+				this.wsSendQueue = pending.slice(i).concat(this.wsSendQueue);
+				break;
+			}
+		}
+	}
+	syncActiveConversation() {
+		if (!this.latestActiveConversationId) return;
+		if (this.lastSentActiveConversationId === this.latestActiveConversationId) return;
+		this.sendMessage({
+			type: "active-conversation",
+			conversationId: this.latestActiveConversationId
+		});
+	}
+	queuePayload(payload, data) {
+		if (data.type === "active-conversation") this.wsSendQueue = this.wsSendQueue.filter((queued) => {
+			try {
+				return JSON.parse(queued).type !== "active-conversation";
+			} catch {
+				return true;
+			}
+		});
+		if (this.wsSendQueue.length >= this.queueLimit) this.wsSendQueue.shift();
+		this.wsSendQueue.push(payload);
+	}
+	scheduleReconnect() {
+		if (this.closed || this.reconnectTimer) return;
+		this.reconnectTimer = this.setTimeoutFn(() => {
+			this.reconnectTimer = null;
+			this.connect();
+		}, this.backoffMs);
+		this.backoffMs = Math.min(this.backoffMs * 1.5, this.reconnectMaxDelayMs);
+	}
+	handleIncomingMessage(rawData) {
+		const encoded = decodeWsMessage(rawData);
+		let parsed;
+		try {
+			parsed = JSON.parse(encoded);
+		} catch {
+			return;
+		}
+		if (!parsed || typeof parsed !== "object" || Array.isArray(parsed)) return;
+		this.options.onMessage(parsed);
+	}
+	handleError(error) {
+		this.options.onError?.(normalizeError(error));
+	}
+	noteSentActiveConversation(data) {
+		if (data.type !== "active-conversation") return;
+		this.lastSentActiveConversationId = (typeof data.conversationId === "string" ? data.conversationId.trim() : "") || null;
+	}
+	noteSentActiveConversationFromPayload(payload) {
+		try {
+			const parsed = JSON.parse(payload);
+			this.noteSentActiveConversation(parsed);
+		} catch {}
+	}
+};
+
+//#endregion
+export { ApiModeWsClient };

package/dist/twitter-verify.js

@@ -0,0 +1,134 @@
+import { resolveStateDir } from "./config/paths.js";
+import fs from "node:fs";
+import path from "node:path";
+import { logger } from "@elizaos/core";
+
+//#region src/api/twitter-verify.ts
+/**
+* Twitter/X verification for whitelist eligibility.
+*
+* Users post a verification message on X containing their agent name and
+* wallet address. The app verifies the tweet exists using the FxTwitter API
+* (free, no auth required). Verified addresses are stored locally and can
+* be collected into a Merkle tree for on-chain whitelist proofs.
+*/
+const WHITELIST_FILE = "whitelist.json";
+function generateVerificationMessage(agentName, walletAddress) {
+	return `Verifying my Milady agent "${agentName}" | ${`${walletAddress.slice(0, 6)}...${walletAddress.slice(-4)}`} #MiladyAgent`;
+}
+function parseTweetUrl(url) {
+	const match = url.match(/(?:twitter\.com|x\.com)\/(\w+)\/status\/(\d+)/);
+	if (!match) return null;
+	return {
+		screenName: match[1],
+		tweetId: match[2]
+	};
+}
+async function verifyTweet(tweetUrl, walletAddress) {
+	const parsed = parseTweetUrl(tweetUrl);
+	if (!parsed) return {
+		verified: false,
+		error: "Invalid tweet URL. Use a twitter.com or x.com status URL.",
+		handle: null
+	};
+	const apiUrl = `https://api.fxtwitter.com/${parsed.screenName}/status/${parsed.tweetId}`;
+	let response;
+	try {
+		response = await fetch(apiUrl, {
+			headers: { "User-Agent": "MiladyVerifier/1.0" },
+			signal: AbortSignal.timeout(15e3)
+		});
+	} catch (err) {
+		logger.warn(`[twitter-verify] FxTwitter fetch failed: ${err}`);
+		return {
+			verified: false,
+			error: "Could not reach tweet verification service. Try again later.",
+			handle: null
+		};
+	}
+	if (!response.ok) {
+		if (response.status === 404) return {
+			verified: false,
+			error: "Tweet not found. Make sure the URL is correct and the tweet is public.",
+			handle: null
+		};
+		return {
+			verified: false,
+			error: `Tweet fetch failed (HTTP ${response.status})`,
+			handle: null
+		};
+	}
+	let data;
+	try {
+		data = await response.json();
+	} catch {
+		return {
+			verified: false,
+			error: "Invalid response from verification service",
+			handle: null
+		};
+	}
+	if (!data.tweet?.text) return {
+		verified: false,
+		error: "Could not read tweet content",
+		handle: null
+	};
+	const tweetText = data.tweet.text;
+	const handle = data.tweet.author?.screen_name ?? parsed.screenName;
+	const shortAddr = `${walletAddress.slice(0, 6)}...${walletAddress.slice(-4)}`;
+	const hasAddress = tweetText.includes(shortAddr) || tweetText.toLowerCase().includes(walletAddress.toLowerCase().slice(0, 10));
+	const hasHashtag = tweetText.includes("#MiladyAgent");
+	if (!hasAddress) return {
+		verified: false,
+		error: "Tweet does not contain your wallet address. Make sure you copied the full verification message.",
+		handle
+	};
+	if (!hasHashtag) return {
+		verified: false,
+		error: "Tweet is missing #MiladyAgent hashtag.",
+		handle
+	};
+	return {
+		verified: true,
+		error: null,
+		handle
+	};
+}
+function whitelistPath() {
+	return path.join(resolveStateDir(), WHITELIST_FILE);
+}
+function loadWhitelist() {
+	const filePath = whitelistPath();
+	if (!fs.existsSync(filePath)) return { verified: {} };
+	const raw = fs.readFileSync(filePath, "utf-8");
+	return JSON.parse(raw);
+}
+function saveWhitelist(data) {
+	const filePath = whitelistPath();
+	const dir = path.dirname(filePath);
+	if (!fs.existsSync(dir)) fs.mkdirSync(dir, {
+		recursive: true,
+		mode: 448
+	});
+	fs.writeFileSync(filePath, JSON.stringify(data, null, 2), {
+		encoding: "utf-8",
+		mode: 384
+	});
+}
+function markAddressVerified(address, tweetUrl, handle) {
+	const wl = loadWhitelist();
+	wl.verified[address.toLowerCase()] = {
+		timestamp: (/* @__PURE__ */ new Date()).toISOString(),
+		tweetUrl,
+		handle
+	};
+	saveWhitelist(wl);
+	logger.info(`[twitter-verify] Address ${address} verified via @${handle}`);
+}
+function isAddressWhitelisted(address) {
+	const wl = loadWhitelist();
+	return address.toLowerCase() in wl.verified;
+}
+
+//#endregion
+export { generateVerificationMessage, isAddressWhitelisted, markAddressVerified, verifyTweet };